Day15.封装、继承、多态

Day15.封装、继承、多态

目录

封装(Encapsulation)

继承(extends)

重写(override)

多态(polymorphism)

instanceof、类型转换

---

封装(Encapsulation)

• 该露的露，该藏的藏

  • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据 *** 作细节自己完成，不允许外部干涉；低耦合：减少模块之间的联系的紧密性，仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  • 通常，应禁止直接访问一个对象中的数据的实际表示，而应通过 *** 作接口来访问，这称为信息隐藏。private 私有的 public 公开的

• 记住这句话就够了：属性私有，get/set

    private String name;
    //属性私有
    private int age;

    //提供一些可以 *** 作这个属性的方法！
    //get 获得这个数据
    public int getAge(){
        return this.age;
    }
    //set 给这个数据设置值
    public void setAge(int age) {
        if (age>120 || age<0){ //不合法
            this.age = -1;
        }else{
            this.age = age;
        }
    //Alt+ins

控制权限：public(公共)  →protected(受保护) →default(默认) →private(私有)

继承(extends)

• 继承的本质是对某一批类的冲向，从而实现对现实世界更好的建模。

• extends的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承！一个儿子只能有一个爸爸

方法复用、继承多态!

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。

• 子类和父类之间，从意义上讲应该具有“is a”的关系。 Ctrl+H查看树

• object 类 祖父类：在Java中，所有的类，都默认直接或间接继承Object

public class Person {

    protected String name = "父亲";
    private void sex(){                //私有方法无法被继承
        System.out.println("xxx");
    }
}
public class Student extends Person{

    private String name = "儿子";

    public void test(String name){
        System.out.println(name);   //赵本山
        System.out.println(this.name);  //儿子
        System.out.println(super.name); //父亲
    }
}
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        //student.test("赵本山");
        //student.sex() //报错: 'sex()' has private access in 'Person'

• 要调用父类的构造器，必须在子类构造器的第一行 super();

public class Person {

    public Person() {
        System.out.println("Person无参执行了");
    }

public class Student extends Person{

    public Student() {
        //隐藏代码：默认调用了父类的无参构造  因此，有参构造前面必须有无参
        //super();    //因此，调用父类的构造器，必须在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        //Person无参执行了
        //Student无参执行了

• 初始化对象的父类型特征，并不是创建新对象。 

super注意点：
    1.super 调用父类的构造方法，必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中！
    3.super 和 this 不能同时调用构造方法！ 因为必须在第一行

Vs this：
    代表的对象不同：
        this：本身调用者这个对象
        super：代表父类对象的应用
    前提
        this：没有继承也可以使用
        super：只能在继承条件才可以使用
    构造方法
        this();本类的构造
        super();父类的构造

重写：需要有继承关系，子类重写父类的方法！  A<-B
    1.返回值类型、方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大： public>Protected>Default>private  访问权限不能更低只能更高
    4.抛出的异常：范围可以被缩小，但不能扩大： ClassNotFounExeption --> Exeption(大)  不能比之前的抛出更多异常，可以更少

重写：子类的方法和父类必须要一致；方法体不同！
    Alt + Insert : override;
为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！

重写(override)

重写：需要有继承关系，由子类重写父类的方法 
    1.方法名相同、返回值类型相同或为其子类
    2.参数列表相同
    3.修饰符：范围可以扩大： public > Protected > Default > private                                                   访问权限不能更低只能更高
    4.抛出的异常：范围可以被缩小，但不能扩大： ClassNotFounExeption --> Exeption(大)  不能比之前的抛出更多异常，可以更少
    5.方法重写只针对“实例方法”，“静态方法”使用类名调用，重写没有意义
重写：子类的方法和父类要一致；方法体不同！
  快捷键：Alt + Insert  → override;
    
为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！ 

public class Person {
    public void eat(){
        System.out.println("吃");
    }
}

public class Student extends Person{
    public void eat() {
        System.out.println("吃鱼香肉丝");
    }
}

多态(polymorphism)

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

• 多态存在的条件：

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性。

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.run();  //子
        s2.run();  //子  子类重写了，父类的方法，执行子类的方法
        
        s2.eat();//报错 父类不能调用子类独有的方法
        	↓
        ((Student)s2).eat(); //转换才可以调用      
    }
}
1. 使用父类类型的引用指向之类的对象；
2. 该引用只能调用父类中定义的方法和变量；
3. 如果子类中重写了父类的方法，那么调用这个方法时，将会调用子类中的方法；
public class Person {
//Person父类
    public void run(){
        System.out.println("父");
    }
}
public class Student extends Person {
//Student子类
    public void run() {
        System.out.println("子");
    }
    public void eat(){
        System. out.println("eat");
    }
}

 多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，需要有继承关系，不然会类型转换异常！ClassCastException(类型转换异常）
3.多态存在的条件：继承关系、方法需要重写，父类引用指向子类对象 father f1 = new son();

不能被重写的
1.static方法 属于类，它不属于任何一个实例
2.final 常量
3.private方法 私有的，不能被重写
 

多态存在的意义：

降低了代码的耦合性，简化了书写，从某种程度上来说，也提高了效率，多态，最直观的解释就是：父类引用指向子类对象。比如，你有一个父类是动物，有很多子类，比如猫狗这些，动物都有吃东西和睡觉的方法，当你有一个方法，需要一个参数，这个参数有可能是猫或者狗，那么，你就可以把形参定义成动物类型，这样，就不需要重载方法了，还有一个好处是，如果你用重载方法，当后续升级代码的时候，又给动物增加了一个子类鸡，那么，你还要重载一个参数为鸡的方法，但是，如果是用多态，就不需要了，因为形参类型是动物，鸡也是动物子类，这样便于升级。

instanceof、类型转换

• instanceof 和==，>，<是同一类东西。判断一个变量所指向的实例是否是指定类型，或者这个类型的子类。

理解：(判断其左边对象是否为其右边类的实例) 

           (判断左边栈中存地址所指向的是否为指定堆内存)

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object a = new Student();

        System.out.println(a instanceof Student);   //true
        System.out.println(a instanceof Person);    //true
        System.out.println(a instanceof Object);    //true
        System.out.println(a instanceof Teacher);   //false
        System.out.println(a instanceof String);    //false

• 引用数据类型转换

    public static void main(String[] args) {
        //引用数据类型之间的转换  父 ←——→ 子

        //高              低
        Person x = new Student();
        //我们将 x 对象转换为Student类型，才能使用Student类的方法
        //向下转型  强制转换
        Student y = (Student)x;
        y.go();

        //子类转为父类，可能会丢失一些子类特有的方法
        Student student = new Student();
        //向下转型  自动转换
        Person p = student;
        //p.go();  报错: Cannot resolve method 'go' in 'Person'
    }

• 调用子类特有方法，向下转型。转型前要用instancof进行判断