虽然注释看着不明显，但是可以直接到编辑器中运行。结合注释与代码，一定能更好理解！

/**
 * @author wangze
 */
public class Day06 {
    /**
                          多态
     1.多态的概念：同一对象在不同情况下表现出的不同状态或行为
     2.实现多态的步骤：
        要有继承（或实现）的关系
        要有方法重写
        父类引用指向子类对象（is a关系）  例如：Animal a = new Dog();
      成员方法：！！！  编译看左边（左边类型有没有这个成员Animal），运行看右边（Dog运行时具体用右边类的该成员）
     3.多态的应用场景：
        父类型变量作为参数时，可以接受任意子类对象  例子：showAnimal
        这样可以接受其任意的子类
     4.多态关系中成员变量的使用。  子父类中定义了同名的成员变量，如何调用？？？？？
       多态关系中，成员变量是不涉及到重写的！！！   成员变量：  编译看左（编译期间看左边有没有成员），运行看左（运行用左边类型成员）
     5.多态的优缺点：
        优点：可维护性  可扩展性
        缺点：不能使用子类特有成员    如果必要使用需要进行类型转换
     6.类型转换： 向上转型(自动)              （强制）向下转型
               子类型转父类型              父类型转子类型
           Animal animal =new Dog（）；  Dog dog=(Dog)animal;
      注意事项：只能在继承层次内进行转换（不能把猫转成狗）
              将父类转成子类之前，使用instanceof进行检查


                                抽象类
     抽象方法abstract，只有方法声明，没有方法体的方法。例如：public abstract void eat();  要求子类必须重新！！
     包含抽象方法的类，就是抽象类，用abstract修饰     例如：public abstract class Animal{}
     抽象方法的由来：当需要定义一个方法，缺不明确方法的具体实现时，可以将方法定义为abstract，具体实现延迟到子类。
     alt+enter 快捷键帮你重写
     抽象类的特点：必须用abstract修饰
                抽象类不能被实例化，不能new
                抽象类的子类有两种，重写父类的子类，抽象的子类
     抽象类的成员特点：可以有普通的成员变量，也可以有成员常量（final）
            方法特点：可以有抽象方法也可以有普通方法。。。有抽象方法的类一定是抽象类或接口
     抽象类有构造方法，并且可重载；

     final关键字：
       final修饰的类：不能被继承
       final修饰的方法：不能被重写，不能与abstract共存
       final修饰的变量：常量（若修饰引用型变量，则地址值不能变）

     static（静态的）关键字：
        用于修饰类的成员：成员变量————>类变量    成员方法---->类方法
            调用方式： 类名.成员变量名；   类名.成员方法名（参数）；
            特点：被本类所有对象共享  （一个对象改了大家都用新内容）
     可以与final共同使用；
     公共静态常量： public final static String ABC_DEF="小仙云"
        用于修饰成员方法（静态方法）
            静态方法中没有对象this，不能访问非静态成员
        使用场景： 只需要访问静态成员     不需要访问对象状态，所需参数都是由参数列表显示提供
        例子：定义静态方法，翻转数组中的元素

                                接口
     用来描述具有什么功能，但是并不给出具体实现，类要遵从接口描述的统一规则进行定义，所以，接口是对外提供的一组规则，标准！
     接口的定义：使用关键字interface      interface接口名{}
                类与接口是实现关系，用implements表示      class类名implements接口名{}
     接口的特点：接口不能实例化   通过多态的方式来实例化子类对象
                接口的子类（实现类）  可以是抽象类，也可是普通类
     接口继承关系的特点：
         接口与接口之间的关系：
                            可以多继承！！！  格式： 接口 extends 接口1，接口2...
        继承和实现的区别： 继承体现 is a关系 ，父类中定义共性内容
                        实现体现like a关系，接口中定义拓展功能
     接口成员的特点：
        接口没有成员变量，只用公共的，静态的常量； public static final常量名=常量值；
        方法：共有，抽象；  默认，静态；  私有；
     接口构造方法的特点： 没有构造方法！！



     */
    public static void main(String[] args) {
//        这就是多态
        Animal a=new Dog();
        a.setName("花椒");
        showAnimal(a);

        Animal m=new Mouse();
        m.setName("jerry");
        showAnimal(m);
//        调用子类独有的方法，向下转型
//        Dog dog=(Dog)a;
//        dog.watch();
        if(a instanceof Dog){ //判断a是否是dog类的对象

            Dog dog=(Dog) a;
            dog.watch();
        }
        System.out.println("下面测试static方法");
        ReverseArray.show();
        int[] arr={1,6,8,9,7};
        for (int j : arr) {
            //打印数组中的值
            System.out.println(j);
        }
        ReverseArray.reverse(arr);
        System.out.println("------------");
        for (int j : arr) {
            //打印翻转后数组中的值
            System.out.println(j);
        }
        System.out.println("测试接口");
        System.out.println("------------------");
        Drink drink=new Teacher();
        drink.drink();
        Girl girl=new Girl();
        girl.drink();
        girl.open();
        girl.close();


    }
//    多态的应用
    public static void showAnimal(Animal an){
        an.eat();

    }
}

//父类
class Animal{
    private String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
//    成员方法
    public  void eat(){
        System.out.println("干饭");
    }
}

//Dog子类
class Dog extends Animal{
//    由于狗干饭干骨头，所以优化一下
    @Override
    public void eat() {
        System.out.println(getName()+"吃骨头");
    }
//    独有方法
    public  void watch(){
        System.out.println("狗会看家");
    }
}

//mouse子类
class Mouse extends Animal{
    @Override
    public void eat() {
        System.out.println(getName()+"吃奶酪");
    }
}

//static方法测试类，，翻转数组
class ReverseArray{
    int num1=10;
    static  int num2=20;
    public static void show(){
        System.out.println(num2);//只能访问静态
    }
    public static  void reverse(int[] arr){
        for (int i=0;i< arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;

         }

    }
}

//接口
 interface Drink{
//    成员方法
    public abstract void drink();
}
interface Usb{
    public  abstract void open();
    public  abstract void close();
}
//接口实现类
class Teacher implements Drink{
    @Override
    public void drink() {
        System.out.println("来杯小鸟伏特加");
    }
}
class Girl implements Usb,Drink{
    @Override
    public void drink() {
        System.out.println("喝酒壮胆");
    }

    @Override
    public void open() {
        System.out.println("进入");
    }

    @Override
    public void close() {
        System.out.println("出来");
    }
}

原文链接:https://blog.csdn.net/Ares___/article/details/114655557