java学习初探6之继承 方法覆盖 多态

1.继承
引入类继承最基本的作用是：代码重用。
注：构造方法无法被子类继承
语法：【修饰符列表】class 子类名 extends 父类名{
类体}
java语言中，只支持单继承。A继承B，不能同时继承C。
一个类如果没有显示的继承其他类，则该类默认继承java.lang.Object。Object是sun提供的基类。
父类、超类、基类、superclass
子类、派生类、subclass
2.方法覆盖
（1）什么时候进行重写？
父类中方法已经无法满足子类的业务需求，需要将父类中的方法进行重写一遍。
（2）子类重写父类方法后，子类对象调用的一定是重写后的方法。
（3）发生方法覆盖的条件。
第一、发生在具有继承关系的两个雷之间；
第二、必须具有相同的方法名、相同的返回值类型、相同的参数列表。
第三、重写的方法不能有比被重写的方法拥有更低的访问权限。
第四、重写的方法不能有比被重写的方法抛出更宽泛的异常。（异常机制）
第五、私有的方法不能被覆盖。
第六、构造方法不能被覆盖（构造方法无法被继承）；
第七、静态方法不存在覆盖这一说。
第八、覆盖指的是成员方法，和成员变量无关。
（4）继承最基本的作用是：代码重用。
继承最重要的作用，方法可以重写。

public class Test01 {
    public static void main(String[] args) {
        Cat cat=new Cat();
        cat.move();//调用方法，输出猫在走猫步！
    }
}
//父类：动物
class Animal{
    public void move() {
        System.out.println("动物在移动!");
    }
}
//子类
class Cat extends Animal{
    //在子类中cat的move方法应该输出，猫在走猫步。
    //Animal中的move方法无法满足cat，所以，在cat类中move方法
    //进行重新定义（方法覆盖，方法重写，override，overwrite）
    public void move() {
        System.out.println("猫在走猫步！");
    }
}

3.多态
（1）多态语法

/*
 * 关于java语言中的向上转型和向下转型
 * 向上转型：upcasting 子--》父
 * 向下转型：downcasting 父--》子
 * 注意：无论向上转型还是向下转型，两个类必须由继承关系。
 */
public class Test02 {
    public static void main(String[] args) {

        //向上转型，自动类型转换
        //程序编译阶段只知道a1是一个Animal类型，
        //程序在运行时堆中的实际对象是Cat类型
        Animal a1=new Cat();
        //程序在编译阶段a1被编译器看做Animal类型，
        //所以程序在编译阶段a1引用的是Animal类型中的eat方法（静态绑定）
        //程序在运行时，堆中的对象实际是Cat类型，而Cat重写了eat方法，
        //所以程序在运行阶段对象的绑定的方法是Cat中的eat方法（动态绑定）
        a1.eat();//猫在吃鱼！
//------------------------------------------------------        
        //向下转型，强制类型转换。
        Animal a2=new Cat();//向上转型
        //要执行cat中move方法，怎么做。
        //只能强制转换类型，需要加强制类型转换符
        Cat c1= (Cat)a2;
        c1.move();//猫在走猫步

        /*
         * instanceof用法
         * 1.instanceof运算结果是boolean类型
         * 2.（引用instanceof 类型）--》true、false
         * 例如，（a instanceof Cat）如果结果是true，表示：a引用指向对象是Cat类型
         */
        Animal a3=new Dog();
        if(a3 instanceof Cat){//推荐在向下转型的时候，使用instanceof运算符判断，避免ClassCastException异常
        Cat c2=(Cat)a3;//java.lang.ClassCastException
        }
    }

}

（2）多态好处
第一、项目扩展能力增强，
第二、使用多态可以使代码之间的耦合度降低
下面用实例说明多态好处。
模拟人喂食宠物。未使用多态前

/*
 * 模拟主人
 */
public class Person {
    //喂养
public void feed(Dog d) {
    d.eat();    
}
    //因为用户业务改变，所以软件需要升级，主人也要喂猫
public void feed(Cat c){
    c.eat();
}
//以上的代码得出：Person类型的扩展能力太差
}

/*
 * 模拟宠物
 */
public class Dog{
    public void eat() {
        System.out.println("狗吃东西！");
    }
}

public class Cat{
    public void eat() {
        System.out.println("猫吃东西！");
    }
}

测试输出：

public class Test03 {
public static void main(String[] args) {
    //1.创建主人
    Person zhangsan=new Person();
    //2.创建宠物
    Dog taidi=new Dog();
    Cat bosi=new Cat();
    //3.喂食
    zhangsan.feed(taidi);
    zhangsan.feed(bosi);
}
}

由此，得出，人每次喂养新宠物时，Person中都得添加新的宠物喂食方法，如果项目很大，导致扩展能力太差。
下面使用多态的方法解决：

/*
 * 模拟主人
 */
public class Person {
    //喂养
    //尽量不要面向具体编程，编程父类型编程，面向抽象编程，扩展性强
public void feed(Animal a) {
    a.eat();    
}
}

//模拟宠物（抽象）
public class Animal {
public void eat() {
}
}

/*
 * 狗、猫继承宠物
 */
public class Dog extends Animal{
    public void eat() {
        System.out.println("狗吃东西！");
    }
}

public class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃东西！");
    }
}

//引用多态方式输出
public class Test03 {
public static void main(String[] args) {
    //1.创建主人
    Person zhangsan=new Person();
    //2.创建宠物
    Dog taidi=new Dog();
    Cat bosi=new Cat();
    //3.喂食
    zhangsan.feed(taidi);//向上转型，自动转型，多态，Dog--》Animal
    zhangsan.feed(bosi);//向上转型，自动转型，多态，Cat--》Animal
}
}

因此，当如果想新增宠物仓鼠、鹦鹉等时，不用再写Person，只要编写仓鼠、鹦鹉即可。