java基础进阶-day27（接口和多态）

接口

接口的概述（理解）

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
• java中接口存在的两个意义
  1. 用来定义规范
  2. 用来做功能的拓展

接口的特点

• 接口用关键字interface修饰

public interface 接口名{}

• 类实现接口用implement表示

public class 类名 implements 接口名{}

• 接口不能实例化
  我们可以创建接口的实现类对象使用
• 接口的子类
  要么重写接口中所有抽象方法
  要么子类也是抽象类

接口的成员特点（记忆）

• 成员特点
  • 成员变量
    只能时常量
    默认修饰符：public static final
  • 构造方法
    没有，因为接口主要时扩展功能的，而没有具体存在
  • 成员方法
    只能时抽象方法
    默认修饰符：public abstract
    关于接口中的方法，JDK8和JDK9中有一些新特性
• 代码演示
  • 接口

package com.itheima_11;

public interface Inter {
//注：public static final为接口默认可以省略
// public abstract为接口默认可以省略
    public static final int NUM = 10;

    public abstract void show();
}

• 实现类

package com.itheima_11;

public class InterImpl implements Inter {
    public void method() {
        System.out.println(NUM);
    }

    @Override
    public void show() {

    }
}

• 测试类

package com.itheima_11;

public class TestInterface {
    public static void main(String[] args) {
        System.out.println(Inter.NUM);
    }
}

类和接口的关系（记忆）

• 类与类的关系
  继承关系，只能单继承，但可以多层继承
• 类与接口的关系
  实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
• 接口与接口的关系
  继承关系，可以单继承，也可以多继承

接口组成更新

接口组成更新概述（理解）

• 常量
  public static final
• 抽象方法
  public abstract
• 默认方法（java 8）
• 静态方法（java 8）
• 私有方法（java 9）

接口中默认方法（应用）

• 格式
  public default 返回值类型 方法名（参数列表）{}
• 作用
  解决接口升级的问题
• 范例

public default void show3（）{、
}

• 注意事项
  • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
  • public 可以省略，default不可以省略
  • 如果实现了多个接口，多个接口存在相同的发方法声明，子类必须对该方法进行重写。

接口中静态方法【应用】

• 格式
  public static 返回值类型 方法名（参数列表）{}
• 范例

public static void show(){
}

• 注意事项
  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  • public 可以省略 static不能省略

接口中私有方法【应用】

• 私有方法产生原因
  java 9中新增了带方法体的私有方法，这其实在java8中就埋下了伏笔：java8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法时不需要让别人使用的，因此用私有给隐藏起来，这就是java9增加私有方法的必然性
• 定义格式
  • 格式1
    private 返回值类型 方法名（参数列表）{}
  • 范例1

private void show（）{
}

• 格式2
  private static 返回值类型 方法名（参数列表）{}
• 范例2

private static void method（）{
}

• 注意事项
  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法

多态

多态概述

• 什么是多态
  同一个对象，在不同时刻表现出来的不同形态

• 多态的前期

  • 要有继承或实现关系
  • 要有方法重写
  • 要有父类引用指向子类对象

  代码演示

package com.itheima_12;
class Animal{
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Test1Polymorphic {
    public static void main(String[] args) {
        Cat c = new Cat();
        Animal a=new Cat();
        a.eat();
    }
}

多态中的成员访问特点（记忆）

• 成员访问特点
  • 成员变量
    编译看父类，运行看父类’
  • 成员方法
    编译看父类，运行看子类
• 代码演示

package com.itheima_12;
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 is method");
    }
}
public class Test2Polymorpic {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

多态的好处和弊端（记忆）

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

多态中的转型（应用）

• 向上转型
  父类引用指向子类对象就是向上转型
• 向下转型
  格式：子类型 对象名 =（子类型）父类引用；
  代码演示：

package com.itheima_12;
class Fa {
    public void show(){
        System.out.println("Fa...show...");
    }
}
class Son extends Fa {
    @Override
    public void show() {
        System.out.println("son show");
    }
    public void method(){
        System.out.println("我是子类特有的方法");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
//       向上转型
        Fa f = new Son();
        f.show();
//        向下转型
        Son s=(Son) f;
        s.method();

    }
}

多态中转型存在的风险和解决方法（应用）

• 风险
  如果被转的引用类型变量，对应的实际类型和目标类型不是同一种类型，那么在转换的时候就会出现ClassCastException
• 解决方案
  • 关键字
    instanceof
  • 使用格式
    变量名 instanceof
    通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果
• 代码演示

package com.itheima_13;

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome() {
        System.out.println("看家");
    }
}

class Cat extends Animal {
    @Override
    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) {
        a.eat();
        if (a instanceof Dog) {
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }
}