Java学习Day03------接口和多态

接口

1、概念

  接口就是一种公共的规范标准

2、存在意义

  （1） 用来定义规范
  （2） 用来做功能的拓展

3、使用

  定义接口：public interface 接口名 {}
  实现接口：public class 类名 implements 接口名 {}

4、特点

  （1）接口不能实例化，可以创建实现类对象
  （2）接口的子类要么重写接口中的所有抽象方法，要么子类也是抽象类

5、接口的成员特点

  （1）成员变量
    只能是常量，默认修饰符：public static final
  （2）构造方法
    没有构造方法
  （3）成员方法
    只能是抽象方法，默认修饰符：public abstract

6、类和接口的关系

  （1）类与类的关系：继承关系，只能单继承或者多层继承
  （2）类与接口的关系：实现关系，可以使单实现，也可以是多实现，还可以继承一个类的同事实现多个接口
  （3）接口与接口的关系：继承关系，可以是单继承也可以是多继承

接口中的默认方法

1、格式
  public default 返回值类型 方法名(参数列表) { 实现代码 }
2、注意事项
  （1）默认方法不是抽象方法，所以不被强制重写。但是仍然是可以重写的，但是在实现类中重写的时候要去掉default关键字
  （2）public可以省略，但是default不能被省略
  （3）如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写，并且只重写一次就行

接口中的静态方法

1、格式
  public static 返回值类型 方法名(参数列表) { }
2、注意事项
  （1） 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  （2） public可以省略，static不能省略

接口中的私有方法

1、介绍
  当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来
2、格式
  private 返回值类型 方法名(参数列表) { }
  private static 返回值类型 方法名(参数列表) { }
3、注意事项
  （1） 默认方法可以调用私有的静态方法和非静态方法
  （2） 静态方法只能调用私有的静态方法

多态

1、概念

   同一个对象，在不同时刻表现出来的不同形态

2、使用前提

（1）要有继承或者实现关系
（2）要存在方法的重写
（3）要有父类引用指向子类对象
案例：

class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test1Polymorphic {
    /*
        多态的前提:
            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();
    }
}

3、多态中的成员访问特点

（1）成员变量： 编译看父类，运行看父类
（2）成员方法： 编译看父类，运行看子类
案例：

class Fu {
    int num = 10;
    public void method(){
        System.out.println("Fu.. method");
    }
}
class Zi extends Fu {
    int num = 20;
    public void method(){
        System.out.println("Zi.. method");
    }
}
public class Test2Polymorpic {
    /*
         多态的成员访问特点:
                成员变量: 编译看左边 (父类), 运行看左边 (父类)
                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

4、多态的好处和弊端

（1）好处： 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
（2）弊端： 不能使用子类的特有成员

5、多态中的转型

（1）向上转型：父类引用指向子类对象就是向上转型
（2）向下转型：子类型 对象名 = (子类型)父类引用;（近似的理解为强制类型转换，但是不是强制类型转换）
案例;

class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}
class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }
    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}
public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();
        // A: 直接创建子类对象
        // B: 向下转型
        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

6、多态中转型存在的风险和解决方案

（1）风险： 如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException
（2）使用关键字instanceof进行类型判断，然后执行相应的业务逻辑。使用格式： 变量名 instanceof 类型（ 通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果）。
案例：

abstract class Animal {
    public abstract void eat();
}
class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }
    public void watchHome(){
        System.out.println("看家");
    }
}
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }
    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        //a.watchHome();
//        Dog dog = (Dog) a;
//        dog.watchHome();  // ClassCastException  类型转换异常
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }
}