Day020 方法重写与多态

目录

一、方法重写

二、Object类

三、多态（多态的使用是因为频繁修改代码，代码可扩展性、可维护性差）

四、实例

---

一、方法重写

方法重写 Vs方法重载

方法重写是实现多态的基础。

 

二、Object类

三、多态（多态的使用是因为频繁修改代码，代码可扩展性、可维护性差）

 

  
      抽象方法：使用abstract修饰的方法为抽象方法
          1）抽象方法没有方法体
       2）抽象方法所在的类需要声明为抽象类
          3）子类继承一个抽象类后，子类中必须重写抽象父类中所有的抽象方法，如果不重写，那么子类也需要定义为抽象类
     
      抽象类：使用abstract修饰的类为抽象类
          1）抽象类的声明跟之前声明一个类没有太大的区别，依然可以封装属性、声明构造方法、声明getXxx()/setXxx()方法、重写toString()方法等
          2）抽象类中可以包含抽象方法、也可以不包含抽象方法（但是抽象方法所在的类一定要声明为抽象类）
          3）抽象类不能实例化（不能通过new的方式来创建对象）
     

四、实例

Person父类

package cn.bdqn.demo06;

public abstract class Father {
    private String name;
    private int age;

    public Father() {
        super();
    }

    public Father(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Father [name=" + name + ", age=" + age + "]";
    }

    public abstract void test();
   
}

Son1子类

package cn.bdqn.demo06;

public class Son1 extends Father{
    private double height;

    public Son1() {
        super();
    }

    public Son1(String name, int age, double height) {
        super(name, age);
        this.height = height;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public void test() {
        System.out.println("我是Son1类中从写Father类里的test()方法");

    }

    //定义一个Son1类里独有的方法
    public void son1Method(){
        System.out.println("我是Son1类里的独有方法son1Method()");
    }

}

Son2子类

package cn.bdqn.demo06;

public class Son2 extends Father{
    private double weight;

    public Son2() {
        super();

    }

    public Son2(String name, int age, double weight) {
        super(name, age);
        this.weight = weight;
    }

    public double getWeight() {
        return weight;
    }

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

    @Override
    public void test() {
        System.out.println("我是Son2类中从写Father类里的test()方法");

    }

    //定义一个Son2类中独有的方法
    public void son2Method(){
        System.out.println("我是Son2类中独有的son2Method()方法");
    }
}

Tese测试类

package cn.bdqn.demo06;

public class Test {
    public static void main(String[] args) {
        // 创建Father类对象
        // Father father = new Father();//抽象类不能实例化，因为没有意义

        //向上转型：父类引用指向子类的实例
        Father father = new Son1("张三", 22, 173);
        father.test();

//		father = new Son2("李四", 25, 160);
//		father.test();


        //父类的引用不能调用子类里的方法，需要进行强制类型转换(向下转型)
//		father.son1Method();

        if(father instanceof Son1){
            //向下转型：子类的引用指向父类的引用
            Son1 son = (Son1)father;
            son.son1Method();
        }else if(father instanceof Son2){
            //向下转型：子类的引用指向父类的引用
            Son2 son = (Son2)father;
            son.son2Method();
        }


    }
}