java面向对象类的继承~ 匿名类 ；多态特性；强制类型转换

类的继承

创建子类语法：

    修饰符 class 子类名 extends 父类名{
    
    }

匿名子类语法：

直接实例化，过程中通过匿名类 继承父类，在实例化过程中将子类匿名

<父类类名>  实例名 = new 父类名()  {

　　匿名类代码逻辑....

}

自定义类默认继承了Object类：

自定义类默认隐藏式继承了Object类
    class Cat {
    ...
    }
    等价于如下
    class Cat extends Object{
    .........
    }

类的继承特性：

1、没指定继承哪个父类，默认继承Object
        2、在Java中Object类是所有类的父类
        3、子类继承父类时，不能继承父类的构造方法【这一点不如Python】
        4、父类叫做基类，子类叫做派生类
        5、满足条件is a
        6、一个类只能继承一个直接父类
        7、类继承具有传递性。

理解视图举例

代码举例：水果~苹果

父类：水果

package com.zmd.study.exten;

public class Fruit {
    /**
     * 水果的重量属性
     */
    private double weight ;

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

子类：苹果类

package com.zmd.study.exten;

public class Apple extends Fruit{
    public String color ;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

测试类输出：

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.setWeight(0.3);
        System.out.println("苹果重量：" + apple.getWeight());
    }
}

/**
输出:
苹果重量：0.3
*/

重写父类方法

---子类的方法名、参数列表、修饰符一致
    ---子类的返回类型一致或父类方法返回类型的子类型：
        例如：String 是Object的子类型
            int 是 Double的子类型

super

注意事项：
        1、super.方法/变量。直接访问父类的资源
        2、如果不写，默认为访问本类中资源即隐含了this.
        3、如果子类重写父类的方法体中，有调用被重写的方法，则只能使用super
        4、访问父类中的实例变量可以是this. 也可以是super. 但是范围子类独有的实例变量/方法 只能用this
        5、super(); super([参数列表])完成对父类构造方法赋值

重写的方法无返回值测试

水果父类

package com.zmd.study.exten;

/**
 * @ClassName Fruit
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/3/28.
 */
public class Fruit {
    /**
     * 水果的重量属性
     */
    private double weight ;

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
    public void showInfo(){
        //被子类重写的方法
        System.out.println("我是水果，我的重量是：" + weight );
    }
}

子类

package com.zmd.study.exten;

import java.sql.SQLOutput;

/**
 * @ClassName Apple
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/3/28.
 */
public class Apple extends Fruit{
    public String color ;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public void showInfo(){
        //调用父类中的方法用super
        super.showInfo();
        System.out.println("我是苹果，我的重量是：" + this.getWeight());
    }
}

测试类&执行效果

import com.zmd.study.exten.Apple;

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.setWeight(0.2);
        apple.showInfo();
    }
}
/**
输出：
我是水果，我的重量是：0.2
我是苹果，我的重量是：0.2
*/

子类和父类的属性名相同

如果在子类中定义了与父类中同名的变量，那么子类中会隐藏父类的变量。但不是完全覆盖。在子类初始化的时候依然会为父类变量分配内存空间。通过父类中public属性的方法仍然可以访问父类的对应属性。

如下示例：水果父类中名字 苹果类中名字重复

package com.zmd.study.exten;

public class Fruit {
    /**
     * 水果的重量属性
     */
    private double weight ;

    /**
     * 名字
     */
    private String name = "水果";

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
    public void showInfo(){
        //被子类重写的方法
        System.out.println("我是"+ name +"，我的重量是：" + weight );
    }
}

苹果类

package com.zmd.study.exten;

import java.sql.SQLOutput;

/**
 * @ClassName Apple
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/3/28.
 */
public class Apple extends Fruit{
    public String name = "苹果";
    public String color ;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public void showInfo(){
        //调用父类中的方法用super
        super.showInfo();
        System.out.println("我是"+ name +"，我的重量是：" + this.getWeight());
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.setWeight(0.2);
        apple.showInfo();
    }
}

输出：

我是水果，我的重量是：0.2
我是苹果，我的重量是：0.2

父类中含有构造方法

父类中只有一个有参构造。则子类构造方法必须给父类构造方法参数传值：

　　即有参构造方法会覆盖无参构造方法，当不存在无参构造方法不存在的时候，java自动会运行一个空的无参构造方法。

如果子类构造方法不想给父类调用父类有参构造：父类必须含有无参构造方法。

语法：
    public 类名([参数列表]){
        完成对子类成员变量赋值;
        super(参数); //完成对父类构造方法赋值
    }

水果(父)类举例

package com.zmd.study.exten;

/**
 * @ClassName Fruit
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/3/28.
 */
public class Fruit {
    /**
     * 水果的重量属性
     */
    private double weight ;

    /**
     * 名字
     */
    private String name = "水果";

    /**
     * 父类无参构造方法
     */
    public Fruit() {
    }

    /**
     * 父类有参构造方法
     * @param weight
     * @param name
     */
    public Fruit(double weight, String name) {
        this.weight = weight;
        this.name = name;
    }
    public void showInfo(){
        //被子类重写的方法
        System.out.println("我是"+ name +"，我的重量是：" + weight );
    }
}

苹果类~子类

package com.zmd.study.exten;

import java.sql.SQLOutput;

/**
 * @ClassName Apple
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/3/28.
 */
public class Apple extends Fruit{
    public String name = "苹果";
    public String color ;

    /**
     * 子类无参构造
     */
    public Apple() {
    }

    /**
     * 子类有参构造
     * @param weight
     * @param name
     */
    public Apple(int weight, String name) {
        super(weight,name);
    }
}

对比说明

实例化子类过程中发生了什么？

　1、子类名obj =  new 子类();

2、执行了父类对应构造super()
   　　如果不手动执行super(参数)，而子类构造方法中直接执行对父类的成员变量赋值，则默认会执行super()父类无参构造一次
    则：需注意,构造方法无参的无用也要写上避免出现错误

所有类的祖类(默认父类)都是Object

instanceof 判断前面的实例是不是后面类的实现

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        System.out.println(apple instanceof Object);
}
/**
输出：true
*/

多态特性

Javad 引用变量有两个类型，一个是编译时类型，一个是运行时类型。

编译时类型由声明该变量时使用的类型决定。

运行时类型由实际赋给该变量的对象决定，如果编译时类型和运行时类型不一致，就可能出现所谓的“多态”

通俗理解：用父类声明变量，用子类来实例化   

语法：
    父类类名 引用名称 = new 子类类名();

    注意，引用名称.只能访问父类的实例属性和实例方法，如果子类重写了父类的方法，则优先访问子类的方法。

示例：动物类、 下属 猫类、狗类

package com.zmd.study.exten;

public class Animal {
    public void say(){
        System.out.println("本动物要叫了....");
    }
}

package com.zmd.study.exten;
public class Dog extends Animal{
    public void say(){
        System.out.println("小狗汪汪汪~~~！！！");
    }
}

package com.zmd.study.exten;
public class Cat extends Animal{
    public void say(){
        System.out.println("本小猫 喵喵喵~~~！！！");
    }
}

测试类

//import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import com.zmd.study.exten.Animal;
import com.zmd.study.exten.Cat;
import com.zmd.study.exten.Dog;

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        dog.say();
        cat.say();
}
/**
小狗汪汪汪~~~！！！
本小猫 喵喵喵~~~！！！
*/

使用子类特有的方法报错：比如小狗比动物多了生气的方法

package com.zmd.study.exten;

public class Dog extends Animal{
    public void say(){
        System.out.println("小狗汪汪汪~~~！！！");
    }
    public void angry(){
        System.out.println("小狗生气了~要咬人");
    }
}

测试

import com.zmd.study.exten.Animal;
import com.zmd.study.exten.Cat;
import com.zmd.study.exten.Dog;

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.angry();//这里直接报语法错误：找不到符号，因为父类中没有
}

强制类型转换

语法：子类类型 引用名称 = (子类类型) 父类对象

注意：需要保证当前运行时的对象，一定是我们要转换对象的实例或者子类的实例。

import com.zmd.study.exten.Animal;
import com.zmd.study.exten.Cat;
import com.zmd.study.exten.Dog;

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Dog dog1 = (Dog)dog;
        dog1.angry();
}
/**
小狗生气了~要咬人
*/

instanceOf 关键字

判断实例是不是后面类或者子类实例化的一个对象

语法：<引用类型的变量> instanceOf  <类>

返回布尔值true/false

示例

        System.out.println(dog instanceof Animal);
        System.out.println(dog instanceof Cat);
/**
true
false
*/