Java—多态

• 多态——对象的多种形态（继承是多态实现的基础）

1. 引用多态：父类的引用可以指向本类的对象；父类的引用可以指向子类的对象
2. 方法多态：创建本类对象时，调用的方法为本类方法；创建子类对象时，调用的方法为子类重写的方法或者继承的方法
3. 父类的引用不能调用子类独有的方法

package com.test;

public class Animal {
    public int age = 1;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
}

package com.test;

public class Cat extends Animal{
    public int age = 2;
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
    public void nature() {
        System.out.println("兔子胆小");
    }
}

package com.test;

public class Initail {

    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal cat = new Cat();
        //Cat cat1 = new Animal();错误
        animal.eat();
        cat.eat();
        //cat.nature();错误
    }
}

• 引用类型转换

1. 向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
2. 向下类型转换（强制类型转换），是大类型到小类型的转换。这种转换存在风险，可能会发生数据的溢出
3. instanceof运算符（一个引用是否是某个类型或某个类型的子类型），可以解决引用对象的类型转换的安全性问题

package com.test;

public class Initail {

    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog;//向上类型转换

        if (animal instanceof Dog) {
            Dog dog2 = (Dog)animal;
        } else {
            System.out.println("无法转换为Dog类型");
        }

        if (animal instanceof Cat) {
            Cat cat = (Cat)animal;
        } else {
            System.out.println("无法转换为Cat类型");
        }
    }
}

　　Dog类和Cat类都继承Animal类

　　执行结果：

　　无法转换为Cat类型

• 抽象类

1. 语法定义：抽象类前使用abstract关键字修饰
2. 应用场景：a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法；b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
3. 作用：限制规定子类必须实现某些方法，但不关注实现细节
4. 使用规则：a、abstract定义抽象类；b、定义的抽象方法，只有声明，不需要实现c、包含抽象方法的类是抽象类d、抽象类中可以包含普通的方法，也可以没有抽象方法e、抽象类不能直接创建，可以定义引用变量指向子类对象

package cn.test;

public abstract class Telephone {
    public abstract void call();
    public abstract void sendMsg();
}

package cn.test;

public class Cellphone extends Telephone {
    public void call() {
        System.out.println("用键盘打电话");
    }
    public void sendMsg() {
        System.out.println("用键盘发短信");
    }
}

package cn.test;

public class Smartphone extends Telephone {

    @Override
    public void call() {
        System.out.println("用语音打电话");
    }

    @Override
    public void sendMsg() {
        System.out.println("用语音发短信");
    }

}

package cn.test;

public class Initail {
    public static void main(String[] args) {
        Telephone phone1 = new Cellphone();
        phone1.call();
        Telephone phone2 = new Smartphone();
        phone2.call();
    }
}

　　执行结果：

　　用键盘打电话
　　用语音打电话

• 接口

1. 概念：类是一种具体的实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
2. 接口定义：使用interface关键字，不再使用class关键字
3. 语法：[修饰符] abstract interface 接口名 [extends 父接口1,父接口2...] {
4. 零到多个常量定义...
5. 零到多个抽象方法定义...
6. } 接口是用来被继承、被实现的，修饰符一般建议用public，不能使用protected和private
7. 接口定义：常量：即使定义时不添加public static final 修饰符，系统也会自动加上；方法：接口中的方法只能是抽象方法，即使定义时不添加pubic static 修饰符，系统也会自动加上。
8. 使用接口：一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。
9. 继承父类实现接口的语法：[修饰符] class 类名 extends 父类 implements 接口1,接口2...{//类体部分}，继承父类必须在实现接口之前。

package cn.test;

public abstract interface IPlayGame {
    public abstract void playGame();
    public static final int NUM = 12;
}

package cn.test;

public class Psp implements IPlayGame {
    @Override
    public void playGame() {
        System.out.println("游戏机能够打游戏");
    }
}

package cn.test;

public class Initail {
    public static void main(String[] args) {
        IPlayGame iplay2 = new Psp();
        iplay2.playGame();
        System.out.println(Psp.NUM);
    }
}

　　执行结果：

　　游戏机能够打游戏
　　12