Day08_三大特性，覆盖，instanceof

一. 封装

封装的必要性

public class TestEncapsulation {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "Tom";
        s1.age = 20000; // 在对象的外部，为对象的属性赋值，可能存在非法数据的录入。
        s1.sex = "male";
        s1.score = 100D;
    }
}

class Student {
    String name;
    int age;
    String sex;
    double score;
}

什么是封装

概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。

访问修饰符: private (可将属性修饰为私有，仅本类可见)

public class TestEncapsulation {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.age = 20000; // 编译错误：私有属性在类的外部不可访问
    }
}

class Student {
    String name;
    private int age;
    String sex;
    double score;
}

公共访问方法

public class TestEncapsulation {
    public static void main(String[] args) {
        Student s1 = new Student();
        // 以访问方法的形式，进而完成赋值与取值操作。
        // 问题：依旧没有解决非法数据录入
        s1.setAge(20000); 
        System.out.println(s1.getAge());
    }
}

class Student {
    String name;
    private int age;
    String sex;
    double score;
    // 提供公共访问方法，以保证数据的正常录入
    // 命名规范：
    // 赋值：setXXX() // 使用方法参数实现赋值
    // 取值：getXXX() // 使用方法返回值实现取值
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return this.age;
    }
}

过滤有效数据

public class TestEncapsulation {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(20000); 
        System.out.println(s1.getAge());
    }
}

class Student {
    String name;
    private int age;
    String sex;
    double score;
    // 在公共的访问方法内部，添加逻辑判断，进而过滤掉非法数据，以保证数据安全。
    public void setAge(int age) {
        if (age > 0 && age <= 160) { // 指定有效范围
            this.age = age;
        } else {
            this.age = 18; // 录入非法数据时的默认值
        }
    }
    
    public int getAge() {
        return this.age;
    }
}

总结：

二. 继承

继承是施方的一种赠予，受方的一种获得。

程序的继承，是类与类之间特征和行为的一种赠予和获得。

两个类之间的继承关系，必须满足 “is-a” 的关系。

Dog is an Animal (成立)

Cat is a Animal (成立)

则可以让Dog类和Cat类继承Animal类

父类的选择

现实生活中，很多类别之间都存在着继承关系，都满足"is-a"的关系。

狗是一种动物，狗是一种生物，狗是一种物质。

多个类别都可作为"狗"的父类，需要从中选择出最适合的父类。

狗	动物	生物	物质
属性：品种、年龄、性别、毛色、…	属性：品种、年龄、性别	属性：品种、年龄、性别	属性：…
方法：呼吸、吃、睡、看家、…	方法：呼吸、吃、睡	方法：呼吸	方法：…

功能越精细，重合点越多，越接近直接目的。

功能越粗略，重合点越少，越接近Object类。(超类)

父类的抽象

实战：可根据程序需要使用到的多个具体类，进行共性抽取，进而定义父类。

🐕狗	蛇🐍	🐟鱼	🐦鸟	动物
属性：品种、年龄、性别、毛色	属性：品种、年龄、性别	属性：品种、年龄、性别	属性：品种、年龄、性别、毛色	属性：品种、年龄、性别
方法：吃、睡、跑	方法：吃、睡、爬	方法：吃、睡、游	方法：吃、睡、飞	方法：吃、睡

在一组相同或类似的类中，抽取出共性的特征和行为，定义在父类中，实现重用。

继承

语法：

class 子类 extends 父类{} // 定义子类时，显示继承父类

应用：

产生继承关系之后，子类可以使用父类中的属性和方法，也可以定义子类独有的属性和方法。

好处：

既提高代码的复用性，又提高代码的可扩展性。

继承的特点

Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐级叠加。

不可继承：

构造方法：

• 类中的构造方法，只负责创建本类对象，不可继承。

private 修饰的属性和方法：

• 访问修饰符的一种，仅本类可见。

父类子类不在同一个package中时，default修饰的属性和方法：

• 访问修饰符的一种，仅同包可见。

三. 访问修饰符

	本类	同包	非同包子类	其他
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

四. 方法重写/覆盖

思考：

• 子类中是否可以定义和父类相同的方法?
• 为什么需要在子类中定义和父类相同的方法?

分析：

当父类提供的方法无法满足子类需求时，可在子类中定义和父类相同的方法进行重写(Override)。

方法重写原则：

方法名称、参数列表、返回值类型必须与父类相同。

访问修饰符可与父类相同或是比父类更宽泛。

方法重写的执行：

子类重写父类方法后，调用时优先执行子类重写后的方法。

super关键字

在子类中，可直接访问从父类继承到的属性和方法，但如果父类子类的属性和方法存在重名(属性遮蔽、方法重写) 时，需要加以区分，才可专项访问。

两种用法：

1.在子类中访问父类方法

public class TestSuperKeyword {
    public static void main(String[] args) {
        B b = new B();
        b.upload();
    }
}

class A { 
    public void upload() {
        // 操作1
    }
}

class B extends A {
    // 使用super.的形式访问父类的方法，进而完成在子类中的复用；再叠加额外的功能代码，组成新的功能。
    public void upload() {
        super.upload(); // 操作1
        // 操作2
    }
}

2.在子类中访问父类属性

public class TestSuperKeyword {
    public static void main(String[] args) {
        B b = new B();
        b.print();
    }
}

class A { 
  int value = 10;
}

class B extends A {
    int value = 20;
    
    public void print() {
        int value = 30;
        System.out.println(value);
        System.out.println(this.value);
        System.out.println(super.value);
        // 父类和子类的同名属性不存在重写关系，两块空间同时存在(子类遮蔽父类属性)，需使用不同前缀进行访问。
    }
}

运行结果：

30
20
10

继承中的对象创建

在具有继承关系的对象创建中，构建子类对象会先构建父类对象。

由父类的共性内容，叠加子类的独有内容，组合成完整的子类对象。

class Father {
    int a;
    int b;
    public void m1() {}
}
class Son extends Father {
    int c;
    public void m2() {}
}

子类Son所持有的属性和方法：

int a
int b
int c
m1()
m2()

继承后的对象创建过程

public class TestSuperKeyword {
    public static void main(String[] args) {
        new C();
    }
}

class A {}
class B extends A {}
class C extends B {}

super调用父类构造方法

无参构造:

public class TestSuperKeyword {
    public static void main(String[] args) {
        new C();
    }
}

class A {
    public A() {
        System.out,println("A()");
    }
}
class B extends A {
    public B() {
        super();
        System.out,println("B()");
    }
}
class C extends B {
    public C() {
        super();
        System.out,println("C()");
    }
}

运行结果：

A()

B()

C()

有参构造:

public class TestSuperKeyword {
    public static void main(String[] args) {
        new B();
        new B(10);
    }
}

class A {
    public A() {
        System.out,println("A()");
    }
    public A(int value) {
        System.out,println("A(int value)");
    }
}
class B extends A {
    public B() {
        super(); // super(): 调用无参构造。  
        System.out,println("B()");
    }
    public B(int value) {
        super(value); // super(实参): 调用有参构造
        System.out,println("B(int value)");
    }
}

运行结果：

A()

B()

A(int value)

B(int value)

this 与 super

public class TestSuperKeyword {
    public static void main(String[] args) {
        new B(10);
    }
}

class A {
    public A() {
        System.out.println("A-无参构造");
    }
    public A(int value) {
        System.out.println("A-有参构造");
    }
}
class B extends A {
    public B() {
        super();
        System.out.println("B-无参构造");
    }
    public B(int value) {
        this(); // this或super使用在构造方法中时，都要求在首行。
        // 当子类构造中使用了this()或this(实参),即不可再同时书写super()或super(实参),会由this()指向的构造方法完成super()的调用。
        System.out.println("B-有参构造")
    }
}

运行结果：

A-无参构造

B-无参构造

B-有参构造

【注】：同一个子类构造方法中，super()、this()不可同时存在。

五. 多态

概念：

父类引用指向子类对象，从而产生多种形态。

	Animal a = new Dog();

二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态。

父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。

多态中的方法重写

思考：如果子类中重写了父类中的方法，以父类类型引用调用此方法时，优先执行父类中的方法还是子类中的方法？

• 实际运行过程中，依旧遵循重写原则，如果子类重写了父类中的方法，执行子类中重写后的方法，否则执行父类中的方法。

多态的应用

class Master {
    public void feed(Dog dog) {
        dog.eat();
    }
    
    public void feed(Cat cat) {
        cat.eat()
    }
    
    public void feed(Fish fish) {
        fish.eat()
    }
    
    public void feed(Bird bird) {
        bird.eat()
    }
}

方法重载可以解决接收不同对象参数的问题。但缺点也比较明显。

• 随着子类增加，Master类需要继续提供大量的方法重载，多次修改并重新编译源文件。

• 每一个feed方法与某一种具体类型形成了密不可分的关系，耦合太高。

多态的作用：

• 屏蔽子类间的差异。

• 灵活，耦合度低。

场景一：

使用父类作为方法形参实现多态，使方法参数的类型更为宽泛。

场景二：

使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

六. 装箱、拆箱

向上转型(装箱)

public class TestConvert {
    public static void main(String[] args) {
        Animal a = new Dog();
        // 父类引用中保存真实子类对象，称为向上转型(即多态核心概念)。
        // 【注】:仅可调用Animal中所声明的属性和方法。
    }
}

class Animal {
    public void eat() {
        System.out.println("动物在吃...")
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗在吃骨头")
    }
}

向下转型(拆箱)

public class TestConvert {
    public static void main(String[] args) {
        Animal a = new Dog();
        Dog dog = (Dog)a;
        // 将父类引用中的真实子类对象，强转回子类本身类型，称为向下转型。
        // 【注】:只有转换回子类真实类型才可调用子类中所声明的属性和方法。
    }
}

class Animal {
    public void eat() {
        System.out.println("动物在吃...")
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗在吃骨头")
    }
}

类型转换异常

public class TestConvert {
    public static void main(String[] args) {
        Animal a = new Dog();
        Cat cat = (Cat)a;
        // Exception in thread "main" java.lang.ClassCastException
    }
}

class Animal {
    public void eat() {
        System.out.println("动物在吃...")
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗在吃骨头")
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫在吃鱼")
    }
}

向下转型时，如果父类引用中的子类对象类型和目标类型不匹配，则会发生类型转换异常。

instanceof关键字

向下转型前，应判断引用中的对象真实类型，保证类型转换的正确性。

语法：

父类引用 instanceof 类型 // 返回boolean类型结果

public class TestConvert {
    public static void main(String[] args) {
        Animal a = new Dog();
        
        if (a instanceof Dog) {
            Dog dog = (Dog)a;
            dog.eat();
        } else if (a instanceof Cat) {
            Cat cat = (Cat)a;
            cat.eat()
        }        
    }
}