Java-接口、多态-第10节

学习目标：

• 掌握接口的使用，牢记多态的特点和使用规则。

---

学习内容：

一、接口

1、概念

• 接口就是多个类的公共规范
• 接口是一种引用类型，最重要的内容就是其中的抽象方法

2、接口的定义

		public interface 接口名字 {
			// 接口内容;
		}

3、接口内容

• 如果是Java7
  • 常量
    • 关键字 public static final（说明不可改变）
    • “成员变量”===常量，不可以改变
    • 格式：
      public static final int num = 10;
    • PS；注意事项
      • 必须进行赋值
      • 关键字可以选择性省略
      • 变量名要大写，用下划线分隔
  • 抽象方法
    • 关键字 public abstract
    • 关键字可以选择性省略，省略其中一个或者全部省略都可以。
• 如果是Java8
  • 默认方法
    • 格式：

			public default void func(参数列表) {
				// 方法体;
			}

• • • 作用
      解决接口升级问题（原有的实现类在增加抽象方法报错）
    • 使用
      接口的默认方法可以直接被实现类调用，也可以被覆盖重写
  • 静态方法
    • 定义
      正常定义
    • 使用
      不能通过实现类进行调用，直接通过接口名进行静态方法的调用
• 如果是Java9
  • 私有方法
    • 概念
      默认方法或静态方法共用的代码可以放在私有方法中，外面访问不到
    • 普通私有方法与静态私有方法
      • 普通私有方法：
        解决多个默认方法共用代码问题

				private void func(){
					//...;
				}

• • • • 静态私有方法：
        解决多个静态方法共用代码问题

				private static void func(){
					//...;
				}

4、接口使用步骤

• 接口不能直接使用，必须有一个“实现类”来实现接口
  格式：

  	public class 实现类名称 implements 接口名称 {
  		// ...;
  	}
  

• 接口的实现类必须覆盖接口的所有抽象方法
• 创建实现类成员并使用
• 注意事项
  实现类如果不能全部将接口中的抽象方法全部覆盖重写，需要变成抽象类
• PS；
  • 接口不能有静态代码块
  • 接口不能有构造方法
  • 一个类可以实现多个接口
  • 实现多个接口时，如果存在一样的成员方法，只需要覆盖重写一次即可
  • 对多个接口中有冲突的默认方法一定要覆盖重写
  • 一个类如果父类中的方法和接口方法冲突，优先父类的方法
  • 接口与接口之间可以多继承
  • 接口与接口之间的函数相同，有方法体就有冲突（要进行覆盖重写），没方法体没冲突

二、多态

• 小明是一个学生同时也是一个人

1、父类引用指向子类对象

• 格式：
  • 父类名称 对象名 = new 子类名称;
  • 接口名称 对象名 = new 实现类名称;

2、访问口诀：

• 编译看左边，运行看右边

3、好处：无论右边对象怎么变，左边都不需要变

4、对象的转型

• 向上转型
  • 优点：一定是安全的；
  • 缺点：不能调用子类独有的方法
• 向下转型（将父类对象还原子类对象的过程）
  • 格式：子类名称 对象名 = （子类名称）父类对象;
  • 注意：必须保证原来创建的时候就是对应子类。
• 判断父类引用的对象是什么子类
  • 格式：对象 isinstanceof 类名称; 返回boolean值
    

---

学习产出：

1、使用接口：抽象方法

package mypackage.day06.demo01;

public interface DemoInterfaceAbstract {
    public abstract void function1(int num);

    public void function2();

    abstract void function3();

    void function4();
}

package mypackage.day06.demo01;

public class DemoInterfaceAbstractImp implements DemoInterfaceAbstract {
    @Override
    public void function1(int num) {
        System.out.println("这是第1个方法！！！");
    }

    @Override
    public void function2() {
        System.out.println("这是第2个方法！！！");
    }

    @Override
    public void function3() {
        System.out.println("这是第3个方法！！！");
    }

    @Override
    public void function4() {
        System.out.println("这是第4个方法！！！");
    }
}

package mypackage.day06.demo01;

public class DemoInterface {
    public static void main(String[] args) {
        DemoInterfaceAbstractImp impl = new DemoInterfaceAbstractImp();
        impl.function1(2);
        impl.function2();
        impl.function3();
        impl.function4();
    }
}

2、使用接口：静态方法+默认方法

package mypackage.day06.demo01;

public interface InterfaceStatic {
    public abstract void func1();
    public default void func2() {
        System.out.println("新添加的默认方法！！！");
    }
    public static void func3(){
        System.out.println("这是静态方法！！！");
    }
}

package mypackage.day06.demo01;

public class Achieve1 implements InterfaceStatic{

    @Override
    public void func1() {
        System.out.println("实现类1实现覆盖重写函数1！！！");
    }

    @Override
    public void func2() {
        System.out.println("实现类1实现覆盖重写函数2！！！");
    }
}

package mypackage.day06.demo01;

public class Achieve2 implements InterfaceStatic {
    @Override
    public void func1() {
        System.out.println("实现类2实现覆盖重写函数1！！！");
    }
}

package mypackage.day06.demo01;

public class InterfaceAchieve {
    public static void main(String[] args) {
        Achieve1 achieve1 = new Achieve1();
        Achieve2 achieve2 = new Achieve2();
        achieve1.func1();
        achieve1.func2();
        achieve2.func1();
        achieve2.func2();
        InterfaceStatic.func3();
    }
}

3、 使用接口：私有方法

package mypackage.day06.demo01;

public interface InterfacePrivate1 {
    public default void func1(){
        System.out.println("默认方法1！！！");
        funccommon();
    }
    public default void func2(){
        System.out.println("默认方法2！！！");
        funccommon();
    }
    private void funccommon(){
        System.out.println("我是共有的！！！");
    }
}

package mypackage.day06.demo01;

public interface InterfacePrivate2 {
    public static void func1(){
        System.out.println("静态方法1！！！");
        funccommon();
    }
    public static void func2(){
        System.out.println("静态方法2！！！");
        funccommon();
    }
    private static void funccommon(){
        System.out.println("我是共有的！！！");
    }
}

package mypackage.day06.demo01;

public class AchievePrivate1 implements InterfacePrivate1 {

}

package mypackage.day06.demo01;

public class PrivateAchieve {
    public static void main(String[] args) {
        AchievePrivate1 achievePrivate1 = new AchievePrivate1();
        achievePrivate1.func1();
        achievePrivate1.func2();
        InterfacePrivate2.func1();
        InterfacePrivate2.func2();
    }
}

4、使用多态

package mypackage.day06.demo02;

public class Fu {
    int num = 10;
    public void func1(){
        System.out.println(num);
    }
}

package mypackage.day06.demo02;

public class Zi extends Fu {
    int num = 20;
    @Override
    public void func1(){
        System.out.println(num);
    }
}

package mypackage.day06.demo02;

public class DemoMulti {
    public static void main(String[] args) {
        Fu obj = new Zi();
        System.out.println(obj.num);
        System.out.println("=====================");
        obj.func1();
    }
}

5、计算机案例

package mypackage.day06.demo03;

public interface Usb {
    public abstract void open();
    public abstract void close();
}

package mypackage.day06.demo03;

public class Mouse implements Usb {
    @Override
    public void open() {
        System.out.println("打开鼠标设备！！！");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标设备！！！");
    }

    public void click() {
        System.out.println("点击鼠标！！！");
    }

}

package mypackage.day06.demo03;

public class Keyboard implements Usb {
    @Override
    public void open() {
        System.out.println("打开键盘设备！！！");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘设备！！！");
    }

    public void type() {
        System.out.println("打印文字！！！");
    }
}

package mypackage.day06.demo03;

public class Computer {
    public void start() {
        System.out.println("电脑开机！！！");
    }

    public void end() {
        System.out.println("电脑关机！！！");
    }

    public void useDevice(Usb usb) {
        usb.open();
        if (usb instanceof Mouse) {
            Mouse mouse = (Mouse) usb;
            mouse.click();
        } else if (usb instanceof Keyboard) {

            Keyboard keyboard = (Keyboard) usb;
            keyboard.type();
        }
        usb.close();
    }
}

package mypackage.day06.demo03;

public class UsbDevice {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.start();

        Usb mouse = new Mouse();
        computer.useDevice(mouse);

        Keyboard keyboard = new Keyboard();
        computer.useDevice(keyboard);
        computer.useDevice(new Keyboard());

        computer.end();
    }
}