在任何版本的Java中，接口都能定义抽象方法。
格式： public abstract 返回值类型 方法名称(参数列表)；
注意事项：
接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract这两个关键字修饰符，可以选择性地省略。(今天刚学，所以不推荐。)方法的 三要素，可以随意定义。 接口使用步骤： 接口不能直接使用，必须有一个“实现类”来“实现该接口”。 格式： public class 实现类名称 implements 接口名称 { //… }接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。 实现：去掉abstract关键字，加上方法体大括号。 创建实现类的对象，进行使用。 注意事项： 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。 package cn.itcast.day10.demo01; public interface MyInterfaceAbstract { //这是一个抽象方法 public abstract void methodAbsl(); //这也是抽象方法 abstract void methodAbs2(); //这也是抽象方法 public void methodAbs3(); //这也是抽象方法 void methodAbs4(); } package cn.itcast.day10.demo01; public class Demo01Interface { public static void main(String[] args) { //错误写法！不能直接new接口对象使用。 //MyInterfaceAbstract inter = new MyInterfaceAbstract(); //创建实现类的对象使用 MyInterfaceAbstractImp1 imp1 = new MyInterfaceAbstractImp1(); imp1.methodAbs1(); imp1.methodAbs2(); } } package cn.itcast.day10.demo01; public class MyInterfaceAbstractImp1 implements MyInterfaceAbstract { @Override public void methodAbs1() { System.out.println("这是第一个方法！"); } @Override public void methodAbs2() { System.out.println("这是第二个方法！"); } @Override public void methodAbs3() { System.out.println("这是第三个方法！"); } @Override public void methodAbs4() { System.out.println("这是第四个方法！"); } } 接口的默认方法，可以通过接口实现类对象，直接调用。接口的默认方法，也可以被接口实现类进行覆盖重写 package day10.demo01; public class Demo01Interface { public static void main(String[] args) { //创建了实现类对象 MyInterfaceDefaultA a = new MyInterfaceDefaultA(); a.methodAbs(); //调用抽象方法，实际上运行的是右侧实现类。 //调用默认方法，如果实现类当中没有，会向上找接口 a.methodDefault();//这是新添加的默认方法 System.out.println("============"); MyInterfaceDefaultB b = new MyInterfaceDefaultB(); b.methodAbs(); b.methodDefault();//实现类B覆盖重写了接口的默认方法 } } package day10.demo01; public class MyInterfaceDefaultB implements MyInterfaceDefault { @Override public void methodAbs() { System.out.println("实现了抽象方法，BBB"); } @Override public void methodDefault() { System.out.println("实现类B覆盖重写了接口的默认方法"); } } package day10.demo01; public class MyInterfaceDefaultA implements MyInterfaceDefault { @Override public void methodAbs() { System.out.println("实现了抽象方法，AAA"); } } package day10.demo01; public interface MyInterfaceDefault { /* 抽象方法 */ public abstract void methodAbs(); //新添加了一个抽象方法 //public abstract void methodAbs2(); //新添加的方法，改成默认方法 public default void methodDefault() { System.out.println("这是新添加的默认方法"); } }运行结果： 接口的静态方法使用：
从Java 8开始，接口当中允许定义静态方法格式： public static 返回值类型 方法名称（参数列表）{ 方法体 }提示：就是将abstract或者default换成static即可，带上方法体。注意事项： 不能通过接口实现类的对象来调用接口当中的静态方法。正确方法： 通过接口名称，直接调用其中的静态方法。格式： 接口名称.静态方法名（参数）； package day10.demo01; public class Demo02Interface { public static void main(String[] args) { //创建了实现类对象 MyinterfaceStaticlmpl imp1 = new MyinterfaceStaticlmpl(); //错误写法！ //imp1.methodStatic(); //直接通过接口名称调用静态方法 MyinterfaceStatic.methodStatic(); } } package day10.demo01; public interface MyinterfaceStatic { public static void methodStatic() { System.out.println("这是接口的静态方法！"); } } package day10.demo01; public class MyinterfaceStaticlmpl implements MyinterfaceStatic { }运行结果： 接口的私有方法定义：
问题描述：
我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法开始，不应该让实现类使用，应该是私有化的。解决方案：
从Java 9开始，接口当中允许定义私有方法。 普通私有方法，解决多个默认方法之间重复代码问题 格式： private 返回值类型 方法名称(参数列表) { 方法体 }静态私有方法，解决多个静态方法之间重复代码问题。 格式： private static 返回值类型 方法名称(参数列表) { 方法体 } package day10.demo02; public class Demo02Interface { public static void main(String[] args) { MyInterfacePrivateB.methodStatic1(); MyInterfacePrivateB.methodStatic2(); //错误写法! //MyInterfacePrivateB.methodStaticCommon(); } } package day10.demo02; public interface MyInterfacePrivateA { public default void methodDefault1() { System.out.println("默认方法1"); methodCommon(); } public default void methodDefault2() { System.out.println("默认方法2"); methodCommon(); } private void methodCommon() { System.out.println("AAA"); System.out.println("BBB"); System.out.println("CCC"); } } package day10.demo02; public interface MyInterfacePrivateB { public static void methodStatic1() { System.out.println("静态方法1"); methodStaticCommon(); } public static void methodStatic2() { System.out.println("静态方法2"); methodStaticCommon(); } private static void methodStaticCommon() { System.out.println("AAA"); System.out.println("BBB"); System.out.println("CCC"); } } package day10.demo02; public class MyInterfacePrivateAImpl implements MyInterfacePrivateA { public void methodAnother() { //直接访问到了接口中的默认方法，这样是错误的！ //methodCommon(); } }运行结果： 接口的常量定义和使用：
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。格式： public static final 数据类型 常量名称 = 数据值；一旦使用final关键字进行修饰，说明不可改变。注意事项： 接口当中的常量，可以省略public static final，注意：不写也照样是这样。接口当中的常量，必须进行赋值；不能不赋值。接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐命名规则) package day10.demo03; public class Demo03Interface { public static void main(String[] args) { //访问接口当中的常量 System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS); } } package day10.demo03; public interface MyInterfaceConst { //这其实就是一个常量，一旦赋值，不可以修改 public static final int NUM_OF_MY_CLASS = 12; }运行结果： 接口的内容小结： 继承父类并实现多个接口：
使用接口的时候，需要注意 接口是没有静态代码块或者构造方法的一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。 格式： public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB { //覆盖重写所有的抽象方法 }如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。如果实现类所实现的多个接口当中，存在重复的默认方法，那实现类一定要对冲突的默认方法进行覆盖重写。一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。 package day10.demo04; public class Demo01Interface { public static void main(String[] args) { Zi zi = new Zi(); zi.method(); } } package day10.demo04; public class Fu { public void method() { System.out.println("父类方法"); } } package day10.demo04; public class Zi extends Fu implements MyInterface { } package day10.demo04; public interface MyInterfaceA { //错误写法！接口不能有静态代码块 //static { // // } //错误写法！接口不能有构造方法 //public MyInterfaceA() { // //} public abstract void methodA(); public abstract void methodAbs(); public default void methodDefault() { System.out.println("默认方法AAA"); } } package day10.demo04; public interface MyInterfaceB { //错误写法！接口不能有静态代码块 //static { // // } //错误写法！接口不能有构造方法 //public MyInterfaceA() { // // } public abstract void methodB(); public abstract void methodAbs(); public default void methodDefault() { System.out.println("默认方法BBB"); } } package day10.demo04; public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{ @Override public void methodA() { System.out.println("覆盖重写了A方法"); } @Override public void methodB() { System.out.println("覆盖重写了B方法"); } @Override public void methodAbs() { System.out.println("覆盖重写了AB接口都有的抽象方法"); } @Override public void methodDefault() { System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写"); } } package day10.demo04; public interface MyInterface { public default void method() { System.out.println("接口的默认方法"); } } package day10.demo04; public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB { @Override public void methodA() { } @Override public void methodAbs() { } @Override public void methodDefault() { } }接口之间的多继承：
类与类之间是单继承的。直接父类只有一个类与接口之间是多实现的。一个类可以实现多个接口。接口与接口之间是多继承的 注意事项： 多个父接口当中的抽象方法如果重复，没关系。多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着 default关键字】。 package day10.demo05; public class Demo01Relations { } package day10.demo05; public interface MyInterfaceA { public abstract void methodA(); public abstract void methodCommon(); public default void methodDefault() { System.out.println("AAA"); } } package day10.demo05; public interface MyInterfaceB { public abstract void methodB(); public abstract void methodCommon(); public default void methodDefault() { System.out.println("BBB"); } } package day10.demo05; /* 这个子接口当中有几个方法？答：4个。 methodA 来源于接口A methodB 来源于接口B methodCommon 同时来源于接口A和B method 来源于我自己 */ public interface MyInterface extends MyInterfaceA, MyInterfaceB { public abstract void method(); @Override public default void methodDefault() { } } package day10.demo05; public class MyInterfaceimpl implements MyInterface { @Override public void method() { } @Override public void methodA() { } @Override public void methodB() { } @Override public void methodCommon() { } }多态的格式与使用：
代码当中体现多态性，其实就是一句话，父类引用指向子类对象。格式： 父类名称 对象名 = new 子类名称(); 或者 接口名称 对象名 = new 实现类名称(); package day10.demo06; public class Demo01Multi { public static void main(String[] args) { //使用多态的写法 //左侧父类的引用，指向了右侧子类的对象 Fu obj = new Zi(); obj.method(); obj.methodFu(); } } package day10.demo06; public class Fu { public void method() { System.out.println("父类方法"); } public void methodFu() { System.out.println("父类特有方法"); } } package day10.demo06; public class Zi extends Fu { @Override public void method() { System.out.println("子类方法"); } }多态中成员变量的使用特点：
访问成员变量的两种方式： 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找。间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。 package day10.demo07; public class Demo01MultiFiled { public static void main(String[] args) { //使用多态的写法，父类引用指向子类方法 Fu obj = new Zi(); System.out.println(obj.num);//父：10 //System.out.println(obj.age);//错误写法 System.out.println("=========="); //子类没有覆盖重写，就是父：10 //子类如果覆盖重写，就是子：20 obj.showNum(); } } package day10.demo07; public class Fu { int num = 10; public void showNum() { System.out.println(num); } } package day10.demo07; public class Zi extends Fu { int num = 20; int age = 16; }多态中成员的方法使用特点：
在多态的代码当中，成员方法的访问规则是： 看new的是谁，就优先用谁，没有则向上找。口诀：编译看左边，运行看右边。对比一下： 成员变量：编译看左边，运行还看右边 成员方法：编译看左边，运行看右边 package day10.demo08; public class Demo01MultiMethod { public static void main(String[] args) { Fu obj = new Zi();//多态 obj.method();//父子都有，优先用子 obj.methodFu();//子类没有，父类有，向上找到父类 //编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。 //obj.methodZi();//错误写法 } } package day10.demo08; public class Fu { int num = 10; public void showNum() { System.out.println(num); } public void method() { System.out.println("父类方法"); } public void methodFu() { System.out.println("父类特有方法"); } } package day10.demo08; public class Zi extends Fu { int num = 20; int age = 16; @Override public void showNum() { System.out.println(num); } @Override public void method() { System.out.println("子类方法"); } public void methodZi() { System.out.println("子类特有方法"); } }运行结果：
使用多态的好处： 对象的向上和向下转型：
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端： 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。解决方案：用对象的向下转型【还原】 package day10.demo09; public class Demo01Main { public static void main(String[] args) { //对象的向上转型，就是：父类引用指向子类对象。 Animal animal = new Cat();//本来创建的时候是一只猫 animal.eat();//猫吃鱼 //animal.catchMouse();//错误写法！ //向下转型，进行“还原”动作 Cat cat = (Cat) animal; cat.catchMouse();//猫抓老鼠 //下面是错误的向下转型 //本来是new的时候是一只猫，现在非要当做狗 //错误写法！编译不会报错，但是运行会出现异常 Dog dog = (Dog) animal; } } package day10.demo09; public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃SHIT"); } public void watchHouse() { System.out.println("狗看家"); } } package day10.demo09; public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } //子类特有方法 public void catchMouse() { System.out.println("猫抓老鼠"); } } package day10.demo09; public abstract class Animal { public abstract void eat(); }运行结果： instanceof关键字：
如何才能知道一个父类引用的对象，本来是什么子类？格式： 对象 instanceof 类名称 这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。 package day10.demo09; public class Demo02Instanceof { public static void main(String[] args) { Animal animal = new Cat(); animal.eat();//猫吃鱼 //如果希望调用子类特有方法，需要向下转型 //判断一下父类调用animal本来是不是Dog if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.watchHouse(); } //判断一下animal本来是不是Cat if (animal instanceof Cat) { Cat cat = (Cat) animal; cat.catchMouse(); } giveMePet(new Dog()); } public static void giveMePet(Animal animal) { if (animal instanceof Dog) { Dog dog = (Dog) animal; dog.watchHouse(); } if (animal instanceof Cat) { Cat cat = (Cat) animal; cat.catchMouse(); } } }运行结果： 三、笔记本USB接口案例
package day10.demo10; public class DemoMain { public static void main(String[] args) { //首先创建一个笔记本电脑 Computer computer = new Computer(); computer.powerOn(); //准备一个鼠标，供电脑使用 // Mouse mouse = new Mouse(); //首先进行向上转型 USB usbMouse = new Mouse();//多态写法 //参数是USB类型，我正好传递进去的就是USB鼠标 computer.useDevice(usbMouse); //创建一个USB键盘 Keyboard keyboard = new Keyboard();//没有使用多态写法 //方法参数是USB类型，传递进去的是实现类对象 computer.useDevice(keyboard);//正确写法1也发生了向上转型 //使用子类对象，匿名对象，也可以 //computer.useDevice(new Keyboard());//也是正确写法 computer.powerOff(); System.out.println("========="); method(10.0);//正确写法，double-->double method(20);//正确写法，int-->double int a =30; method(a);//正确写法，int-->double } public static void method(double num) { System.out.println(num); } } package day10.demo10; //鼠标就是一个USB设备 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 day10.demo10; //键盘就是一个USB设备 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 day10.demo10; public class Computer { public void powerOn() { System.out.println("笔记本电脑开机"); } public void powerOff() { System.out.println("笔记本电脑关机"); } //使用USB设备的方法，使用接口作为方法的参数 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 day10.demo10; public interface USB { public abstract void open();//打开设备 public abstract void close();//关闭设备 }运行结果：
