继承与多态

抽象类

使用abstract修饰的类为抽象类

1.抽象类无法实例化，因为其中的抽象方法未实现，而继承它的子类必须实现父类所有的抽象方法

2.可以包含abstract修饰的抽象方法,也可以有无abstract的非抽象方法

package over;

public abstract class fruit {
    String name="fruit";
    int value;

    fruit(){}
    fruit(String name, int value) {
        this.name = name;
        this.value = value;
    }

    public void tellName(){
        System.out.println("father::I am "+name+"!");
    };
    public abstract void tellPrice();

    public void say(){
        System.out.println("hello fruit！");
    }
}

 抽象类子类

必须实现父类的抽象方法

package over;

public class apple extends fruit {
    private int size;
    public apple(){};
    public apple(String name,int value,int size){
        super(name,value);
        this.size=size;
    };

    //实现父类抽象方法
    @Override
    public void tellPrice() {
        System.out.println("I am worth "+value);
    }


}

重写父类的非抽象方法与子类私有而父类没有的方法

package over;

public class apple extends fruit {
    private int size;
    public apple(){};
    public apple(String name,int value,int size){
        super(name,value);
        this.size=size;
    };

    //实现父类抽象方法
    @Override
    public void tellPrice() {
        System.out.println("I am worth "+value);
    }

    //重写父类方法
    public void tellName(){
        System.out.println("child::This is "+name);
    }
    
    //子类私有而父类没有的方法
    public void tellSize(){
        System.out.println("My size is"+size);
    }
}

 多态，向上转型

通过父类引用实例化的子类

        fruit apple1=new apple("apple",10,1);

 该引用所使用的方法父类都必须要有，在父类中找到后再从子类中查找，子类中有则使用，没有则使用父类自己实现的方法

测试

package over;

public class test {
    public static  void main(String argv[]){
        fruit apple1=new apple("apple",10,1);
        //调用抽象方法
        apple1.tellPrice();
        //调用子类覆盖重写的方法
        apple1.tellName();
        //调用子类没有而父类有的方法
        apple1.say();
    }
}

 子类中有而父类中没有的方法该引用是无法调用的

面试考点

1.覆盖与重载

• 覆盖（Override）存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法；

• 重载（Overload）存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。应该注意的是，返回值不同，其它都相同不算是重载。     

2.多态

 概念:类引用对象的具体类型与它调用的具体方法在编程时是不确定的，而在程序运行的时候才会被确定

条件：继承，重写，向上转型

优点：可以实现不修改程序代码，却能改变引用所绑定的具体对象与其具体方法；例如输入1234来确定将fruit绑定苹果还是香蕉还是其他水果；可扩充性：将来要新增一个子类，不用对父类与其他子类做出修改，降低了耦合性

缺点：子类的私有属性与方法引用是无法使用的