Day22

Posted 2021-06-05 筠亭之

1. 封装详解

封装

• 程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

• 封装 -- 数据的隐藏

  通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

• 属性私有 private，get/set alt + insert 快捷键 构造Getter and Setter

优点

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 提高了系统的可维护性

2. 继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
• extends -- 扩展。子类是父类的扩展
• Java中类只有单继承，没有多继承！
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

2.1 父类与子类的关系

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应具有“is a”的关系。
• 子类可以继承父类的所有方法。

examples:

//父类
//在Java中，所有的类，都默认直接或者间接继承Object
public class Person /*extends Object */{

    //public
    //protected
    //default
    //private
    
    private String skill = "Teaching";
    private int savings = 10_0000_0000;

    //设置get set以封装属性
    public int getSavings() {
        return savings;
    }

    public void setSavings(int savings) {
        this.savings = savings;
    }

    public void say(){
        System.out.println("说了一句话");
    }
    
}

//子类1
//派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {

    //Ctrl + H -- 展示树结构

}

//子类2
public class Teacher extends Person{
}

//可调用
public static void main(String[] args) {

    Student student = new Student();
    student.say();
    System.out.println(student.getSavings());
}

2.2 object类

在Java中，所有的类，都默认直接或者间接继承Object

2.3 super

super 父

this 当前类/对象的属性或方法

//example
public Student() {
    //隐藏代码：调用了父类的无参构造

    super();    //调用父类的构造器，必须要在子类构造器的第一行
    //父类构造器和本身的构造器只能选其一调用
    //如果调用父类的有参构造器，必须用super(参数）否则默认调用父类无参构造
}

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一行
2. super必须只能出现在子类的方法或构造方法中
3. super和this 不能同时调用构造方法

vs this:

• 代表的对象不同：

  this: 本身调用者这个对象

  super: 代表父类对象的应用

• 前提

  this: 没有继承也可以使用

  super: 只能在继承条件下才可以使用

• 构造方法

  this(); 本类的构造

  super(): 父类的构造

2.4 方法重写

重点 --> 多态

• 重写override 需要有继承关系，是子类重写父类的方法

  1. 方法名必须相同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大，但不能缩小 非static和private的方法都可以重写

     public > protected > default > private

  4. 抛出的异常：范围：可以被缩小，但不能扩大； ClassNotFoundException --> Exception(大)

• 与重载区分开：重载是同一方法名但参数不同，重写：子类的方法和父类必须要一致，方法体不同！

example:

//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}

public class A extends B{

    //Override 重写
    //alt + insert => Override Methods

    @Override
    public void test() {
        //super.test();   //默认调用父类的方法
        System.out.println("A=>test()");
    }
}

//-------------------------------------------------------------------------
//调用

//静态的方法和非静态的方法区别很大！
//静态方法：方法的调用只和左边，定义的数据类型有关
/*
如果A B的test方法均为static，则输出结果为： 
A=>test()
B=>test()
如果A B的test方法均为public，则输出结果为： 
A=>test()
A=>test()
*/
/*原因：
静态方法是类的方法，而费静态是对象方法
有static时，b调用了B类的方法，因为b是用B类定义的；
没有static时，b调用的是对象的方法，b是A 类new出来的对象，因此调用了A方法
*/

public static void main(String[] args) {

    A a = new A();
    a.test();   

    //父类的引用指向了子类
    B b = new A();
    b.test();   //B
}

为什么需要重写：

父类的功能，子类不一定需要，或者不一定能满足

对于重写的使用，需在后续学习中不断增加理解