12.10 Java基础10

• 继承（昨日回顾加今日份）
• 回顾

面向对象的三个特征： 封装 继承 多态
构造方法  new对象会自动调用的方法
方法的重载 同一个类中，方法名相同，参数项不同； 个数不同，或者个数相同类型不同.
封装  [类内部一些细节隐藏起来，方式就是将属性给私有化 ; 提供公共的方法来访问私有的属性.] 

赋值时可以通过setter赋值，或者通过带参的构造方法直接赋值。
继承 A extends B A继承了B ，类只支持单继承.  一个类只能有一个直接的父类 
     A继承了B中的非私有的属性和方法，但是构造方法不能被继承。

 

封装一键三连

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

    public String getName() {//getter setter
        return name;
    }

    public void setName(String name) {//setter带参数
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // alt+/
    public Person() {
        // TODO Auto-generated constructor stub
    }

    public Person(String name, int age) {//全参构造方法
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {//Object类的toString方法
        return "Person [name=" + name + ", age=" + age + "]";
    }

• 继承中成员变量的关系

如果子类和父类中有同名的成员变量，访问的是子类的成员变量（就近原则）。

操作方法检验：

1.在父类中定义一个成员变量

2.在子类中定义一个成员变量和父类中成员变量名称不同，然后再在子类中定义一个方法去访问变量，发现变量名不同，访问非常简单，就是访问父类中的成员变量。

3.在子类中再定义一个成员变量，和父类中的成员变量名称一致，然后继续访问，会发现访问的是子类的成员变量。

4.如果我们要访问父类的成员变量该怎么办呢? 通过回想this来引入super关键字。

注意：子类和父类中同名的成员方法也和同名成员变量一样，遵循就近原则，先子类中找，如果没有再去父类中找，如果没有就报错（不考虑父类的父类里的成员方法）。

• super关键字

super的用法和this很像：

this代表本类对应的引用。

super代表父类存储空间的标识(可以理解为父类引用)。

• 访问成员变量

this.成员变量 super.成员变量

• 访问构造方法

this(…) super(…)//...构造方法里的为参数

• 访问成员方法

this.成员方法() super.成员方法()

super :在子类中，构造方法： super() 调用父类的构造
在子类的普通方法中使用，调用父类的实例方法，普通的属性 super.属性  super.方法

• 继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中无参数的构造方法，所以子类初始化之前，一定要先完成父类数据的初始化。

每一个构造方法的第一条语句默认都是：super()，不然会编译错误。如果父类中没有构造方法，

子类可以通过super去显式调用父类其他的带参的构造方法

子类也可通过this去调用本类的其他构造方法：本类其他构造也必须首先访问了父类构造。

注意：假如A继承于B，创建子类A对象，会调用父类B的无参数构造和子类A无参数的构造，而且，是先调用父类的构造，再调用子类的构造。

• 方法的覆盖（复写）

子类可以重写父类中某一个方法，称为方法覆盖，也称方法重写。如果子类需要修改从父类继承到的方法的方法体，就可以使用方法覆盖。

规则：

条件一:两个类必须要有继承关系
条件二:重写之后的方法和之前的方法具有:
       相同的返回值类型
       相同的方法名
       相同的形式参数列表
条件三:访问权限不能更低,可以更高(这个可以先记住)
       父类原先是public,不能低于public
       父类原先是protected,子类可以是public
条件四:重写之后的方法不能比之前的方法抛出更多的异常,可以更少.(这个先记住)
       父类子类没有异常,父类抛出异常,程序正常运行
       父类子类没有异常,子类抛出异常,程序报错:

 

备注：如果父类中存在一方法，子类中重新又定义了一遍,子类就会优先调用子类自己的方法。

public String toString() 方法是来自java.lang.Object这个类中的方法
object是所有类的父类（最高级别）。

• 多态

多态的含义：对外的一种表现形式，内在有多种具体实现。

• 方法的重载

在Java类中如果有多个同名但是参数不同的方法就称为“方法的重载”。

编译器会根据调用时传递的实际参数自动判断具体调用的是哪个重载方法。

方法重载的三原则：

① 方法名相同

② 参数不同（可以有三方面的不同，数量不同、类型不同、顺序不同）

③ 同一作用域

注意：方法重载跟方法的返回值类型没有任何关系，只有返回值不同的方法不能构成重载。

• 对象向上造型

自动类型提升，作用:提高程序可拓展性

// Father superclass 父类
        // Son subclass 子类

        // 正常写法1 子类 引用名 = new 子类();
        Son son = new Son();
        //
        son.eat();

        // 正常写法2 父类 引用名 = new 父类();
        Father f = new Father();
        f.eat();

        System.out.println("******** 向上转型 s1是son类型，也是Father类型************");
        // 正常写法3 父类 引用名 = new 子类对象();
        Father s1 = new Son();//S1只能调用父类中定义的方法，子类扩展的新方法不能调用

        //谁的方法？子类对象的方法 =>编译看左侧，运行看右侧。前提是方法做了重写。（Ps：代码没写全，不过意思可以理解，用的是子类对象的方法）
        s1.eat();
        //谁的方法？ 父类的方法 ->静态方法 >编译看左侧，运行看左侧。（假设drink方法是static）
        s1.drink();
        //这个num是1还是1呢? 属性不存在所谓重写。左侧是谁，就是谁。
        System.out.println(s1.num);
        
        System.out.println("********************");
        // 不正常写法4  子类 引用名 = new 父类对象();
        //cast转换
        //java.lang.ClassCastException
        Son s2 = (Son) new Father();
        s2.eat();

相关总结：

多态性的情况下对非静态成员方法的调用：编译看左边 ，运行看右边 （当父类和子类具有相同的非静态方法（就是子类重写父类方法），多态下访问的是子类的成员方法。）

多态性的情况下对静态成员方法的调用：编译和运行都看左边。（当父类和子类具有相同的静态方法（就是子类重写父类静态方法），多态下访问的是父类的静态方法。）

多态性的情况下对成员变量的调用：编译运行都看左边。（父类和子类有相同的成员变量(静态和非静态)，多态下访问的是父类的成员变量）

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。所以，静态变量也是编译和运行都看等号左边。

• 对象向下造型（强制类型转换）（为了使用子类中的特有方法）

样例：

class  Pet{

            void printInfo() {

             System.out.println(“pet");

          }

}

class Dog extends Pet{

              void catchingFlyDics() {

                    System.out.println(“玩接飞盘游戏，狗狗很开心");

              }

}

 Pet pet =   new Dog() ；

 pet.printInfo();              //只能使用父类中的方法，主要是子类自己也没重写这方法啊。

 Dog dog =（Dog）pet;  //将父类引用名转换为子类对象 向下造型(强制类型转换)

 dog.catchingFlyDics();  //不报错！子父类中的方法都可以调用

注意：

不能把父类向下转型成子类类型（否则会报ClassCastException类型转换异常），要转也要先向上造型然后再向下造型。

不具备继承关系的类不能互转。

对于转型，只能强制转换成这个对象的运行期类型。

 

相关应用代码：假设子类Tiger，父类ZooAnimal，在Zoo类中定义一个方法，参数为ZooAnimal对象。。

* @这个方法的参数是父类引用名; ZooAnimal animal
     * @当我们调用这个方法的时候,传递子类对象
     * @最终执行结果是子类对象的那个重写了的方法.
     * @其实就是java中的多态-》实现过程
     * @param animal
     */
    public void perform(ZooAnimal animal) {
        //这里引用是同一个名字，但是根据传递过来的对象不同，执行过程和结果也不同
        //这就是多态概念
        animal.show();
    }

}

• instanceof运算符

运算符instanceof用来判断对象是否属于某个类的实例。

具体语法如下：该表达式为一个boolean表达式，如果对象的类型是后面提供的类或其子类，则返回true，反之返回false

• 多态总结

多态存在的三个必要条件：

继承；

重写覆盖；

对象向上造型-父类引用指向子类对象。

 

感想：还行，就是向上造型那个一开始不是很好理解。。

23:24:37 2021-12-12