Java入门：Day07—封装与继承

Day07—封装与继承

封装、继承、多态是Java面向对象的三大特征。

1、封装

（1）定义

将类的状态信息进行隐藏，在类的内部，不允许外部直接访问，而是通过提供公共方法来访问。

（2）实际意义

将该隐藏的信息进行隐藏，该暴露的信息进行暴露（getter/setter方法），加以限制，拒绝不合法数据的操作。

（3）为 了解决数据不合法，使用封装的三个步骤

①用 private（私有的） 修改成员变量，此时本类可见、可访问，外界不可见；

②为属性提供公共的赋值/取值方法，getter/setter方法；

③对赋值方法进行限制。

（4）除了属性之外，还可以对方法，内部类实现封装

（5）赋值（getter）方法：有参数无返回值

（6）取值（setter）方法：无参数有返回值

2、继承（extends）

    class 父类 {
    }
    class 子类 extends 父类 {
    }

（1）定义

继承是描述类与类之间的一种关系，这种关系 is … a 关系，将所有子类（派生类）的共有的属性和方法向上抽取定义在父类中；子类通过 extends 关键字继承父类，就可以获取父类的这部分内容，不需要自已定义，子类还可以定义自己特有的内容，从而实现代码复用效果，同时提高程序的扩展性。

（2）作用

①提高代码复用性及扩展性。

②继承是多态的基础。

（3）特点

①单继承：Java 只支持单继承， 与父类成员重名时，会产生冲突问题。

②不能多继承，但可以多级（多层）继承。

③成员属性重名，执行子类的变量。

④成员方法重名，执行子类的方法。

⑤子类拥有父类非 private 的属性、方法。

⑥子类可以用自己的方式实现父类的方法。

⑦子类可以拥有自己特有的属性和方法（子类可以对父类进行扩展）。

    //多层继承
    class A{}
    class B extends A{}  //B是A的子类
    class C extends B{}  //C是B的子类，是A的孙子类

3、方法重载和方法重写（覆盖）

（1）方法的重载

在同一个类中，方法名相同，参数的个数与类型不同，跟返回值、访问修饰符无关

（2）方法的重写（覆盖）

在子父类中，方法名相同、返回值类型相同、参数列表相同，这样的方法叫做方法的重写（覆盖）——（@Override）

（3）方法重写的应用场景

子类继承父类方法但是发现不能满足子类的需求，子类可以重写此方法。

（4）注意

子类重写方法时，访问修饰符权限不能小于父类的访问修饰符。

（5）构造方法的特点

子类不可以继承父类的构造方法，和类名一样，每个类都要有自己的构造方法，构造方法的作用为初始化对象的属性。

4、super关键字和this关键字

（1） super

①定义：指父类对象的引用

②作用：在子类中访问父类的成员变量 super.属性；成员方法 super.方法()；构造方法 super()；

（2）this

①定义：指的是当前对象的引用

②作用：在本类方法中使用区分成员变量和局部变量同名的问题。成员变量 this.属性；成员方法 this.方法()；构造方法 this()；

（3）二者共同点

在构造方法中使用时必须放在首行。

5、数组继承

    //父类（数组类）
    public class Array {
        private int[] arr;  //数组
        private int index; //下标
        //构造方法
        public Array(int len){
            if(len > 5){
                arr = new int[len];
            }else{
                arr = new int[6];
            }
        }
        //增加功能
        public boolean addArr(int num){
            if(index < arr.length){//10W
                this.arr[index++] = num;
                return true;
            }else {
                return false;
            }
        }
        //获取
        public int[] getArr(){
            return this.arr;
        }
        //显示
        public void print(int[] arr){
            System.out.println("输出内容："+Arrays.toString(arr));
        }
    }

    //子类（数组反转）
    public class ArrayReverse extends Array {
        public ArrayReverse(int len) {
            super(len);
        }
        @Override  //方法重写
        public int[] getArr() {
            super.print(super.getArr());
            int [] arr = new int[super.getArr().length];
            int index = arr.length-1;
            for (int i = 0; i < arr.length; i++) {
                arr[index] = super.getArr()[i];  //数组反转
                index--;
            }
            return arr;
        }
    }

    //子类（数组排序）
    public class ArraySort extends Array {
        private int[] arr;
        //构造方法
        public ArraySort(int len){
            super(len);
        }
        //排序
        public int[] getArr(){  //重写方法
            arr = super.getArr();
            super.print(arr);
            for (int i = 0; i < arr.length-1; i++) {
                for (int j = 0; j < arr.length-i-1; j++) {
                    if(arr[j] > arr[j+1]){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
            return arr;
        }
    }

6、Java访问修饰符

Java的访问修饰符分为：类和类成员

（1）类的访问修饰符

修饰符	访问权限
public	所有、任意位置
default（默认）	本包内

（2）类成员的访问修饰符

修饰符	当前类（本类）	同包（本包）	同包子孙类	不同包子孙类	其他包
public	可见	可见	可见	可见	可见
protected	可见	可见	可见	可见	不可见
default	可见	可见	可见	不可见	不可见
private	可见	不可见	不可见	不可见	不可见