【java】封装1——封装一个超级数组

悠悠 2022-11-25 11:52 163阅读 0赞

## 1、封装 ##

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。  
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。  
要访问该类的代码和数据，必须通过严格的接口控制。  
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。  
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

## 2、封装的优点 ##

1.  良好的封装能够减少耦合。
2.  类内部的结构可以自由修改。
3.  可以对成员变量进行更精确的控制。
4.  隐藏信息，实现细节。

## 3、封装一个数组 ##

**要求：  
实现数组的添加、删除、修改、查找等功能。**

**superArray.java代码如下：**

package com.zhl.util;
    
    public class superArray { 
        //维护一个数组
        private int[] array;
        //当前的最后一个数字下标，要为-1，因为数组第一个下标为0
        private int currentIndex = -1;
        //构造初始化
        superArray(){ 
            array = new int[8];
        }
    
        //添加数据的方法
        public superArray add(int data){ 
            currentIndex++;
            //自动扩容
            if(currentIndex > array.length-1){ 
                array = expand(array);
            }
            array[currentIndex] = data ;
            //返回当前的对象，方便链式调用
            return this;
        }
    
        /** * 删除数据的方法 * 1.把末位的删了 * 2.给一个下标删除 * 3.给值删除 */
        public Integer delete(){ 
            currentIndex--;
            if(currentIndex < -1){ 
                return null;
            }else { 
                return array[currentIndex+1];
            }
        }
        public Integer deleteIndex(int index){ 
            boolean flag = validateIndex(index);
            if(currentIndex < 0 || !flag){ 
                return null;
            }else{ 
                int number = array[index];
                for (int i = index; i < currentIndex; i++) { 
                    array[i] = array[i+1];
                }
                currentIndex--;
                return number;
            }
    
        }
    
        //修改
        public void update(int index, int data){ 
            boolean flag = validateIndex(index);
            if(flag){ 
                array[index] = data;
            }else{ 
                System.out.println("你要修改的数据不存在");
            }
        }
    
        //1查找数组里有几个该数据
        public int findNumber(int data){ 
            int count = 0;
            for (int i = 0; i < array.length; i++) { 
                if(array[i] == data){ 
                    count++;
                }
            }
            return count;
        }
    
        //2查找这个数据第一次出现的下标
        public  int findNumberIndex(int data){ 
            for (int i = 0; i < array.length; i++) { 
                if(array[i] == data) { 
                    return i;
                }
            }
            return -1;
        }
        //3根据下标查询数字
        public int get(int index){ 
            return array[index];
        }
        //查看当前有多少个数字
        public int size(){ 
            return currentIndex+1;
        }
    
        //排序
        public void sort(){ 
            for (int i = 0; i < currentIndex; i++) { 
                for (int j = 0; j < currentIndex - i; j++) { 
                    if(array[j]>array[j+1]){ 
                        int temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                    }
                }
            }
        }
    
        //打印数组
        public void print(){ 
            System.out.println("当前数组为： ");
            for (int i = 0; i <= currentIndex ; i++) { 
                System.out.print(array[i] + " ");
            }
        }
        //数组扩容
        private int[] expand(int[] oldArray){ 
            int[] newArray = new int[oldArray.length*2];
            for (int i = 0; i < oldArray.length; i++) { 
                newArray[i] = oldArray[i];
            }
            return newArray;
        }
        //验证下标是否合法
        private boolean validateIndex(int index) { 
            return index >= 0 && index <= currentIndex;
        }
    }

**test.java代码如下：**

package com.zhl.util;
    
    public class test { 
        public static void main(String[] args) { 
            superArray superArray = new superArray();
            //因为方法内把自己this返回了出去，所以能一直调add方法
            superArray.add(3).add(3);
            superArray.add(4).add(7).add(3);
    
    // int delete = superArray.delete();
    // System.out.println(delete);
            superArray.add(9).add(7);
    // superArray.update(0,0);
    
    // int findNumber = superArray.findNumber(3);
    // System.out.println(findNumber);
    
    // int findNumberIndex = superArray.findNumberIndex(5);
    // System.out.println(findNumberIndex);
    
            superArray.print();
            Integer number = superArray.deleteIndex(5);
            System.out.println("\n删除内容" + number);
    
            superArray.print();
    
    // superArray.sort();
    
    // for (int i = 0; i < superArray.size(); i++) { 
    // System.out.print(superArray.get(i) + " ");
    // }
        }
    }

**test结果如下：**  
（这里只展示删除数组索引为5的值的结果）  
![在这里插入图片描述][20200808210435757.png]  
**参考：**  
1.[菜鸟教程][Link 1]  
2. [B站IT楠老师java课程][B_IT_java]

[20200808210435757.png]: /images/20221124/a3d127e178504382b8f84728e3b07374.png
[Link 1]: https://www.runoob.com/java/java-encapsulation.html
[B_IT_java]: https://www.bilibili.com/video/BV1jJ411H7pf?p=49