注意：接口的定义不是class，而是interface,当然最后编译时还是class文件
interface Demo{ abstract void show(); abstract void show1(); } 接口中常见的成员：（所有是固定的修饰符） 1.全局常量（public static final） 2.抽象方法（public abstract） 3.当然还有别的
interface Demo{ public static final int num = 4;//num终身为4 public int num = 4;//不写。会自己主动加上去，默认的，最好写上。否则阅读性差 public abstract void show();} 由此得出结论： 接口里的成员是公共的，->权限最大 假设是类的话。会用继承。假设用接口的话。就不用继承了。用第二种更加直观的表述方式。叫 实现 （implements） 。 为什么叫实现？
接口里的方法都是抽象的，所以必要要全实现，对于抽象类里，有一些不是抽象的。子类拿过来直接用的。继承能够拿过来一些我不须要做，直接能够用的东西，而实现是我所有都要用的。都要覆盖，都要自己重写。
所以：类与类之间是继承关系，类与接口之间是实现关系
接口实现的特点：
import java.util.Scanner;interface Demo{ public abstract void show(); public abstract void show1(); public static final int num = 4;} //类与类是继承关系。类与接口之间是实现关系(implements)/* * 接口不能够实例化 * 仅仅能由实现了接口的子类，而且覆盖了接口中全部的抽象方法后才干够实例化 * 否则，这个子类仅仅是一个抽象类 * */class Demo1_Imple implements Demo//一个类实现接口后，必须覆盖接口里全部的方法，才干实现类implements接口{ public void show() { System.out.println("show打印"+num); } public void show1() { System.out.println("show1打印"+num); }}public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); Demo1_Imple BLF = new Demo1_Imple(); BLF.show(); BLF.show1(); BLF.num = 5;//错误。num是final修饰的 System.out.println(BLF.num);//对象用num System.out.println(Demo.num);//接口的静态成员 System.out.println(Demo1_Imple.num);//实现接口的子类的静态成员num }} 接口的长处： java不直接支持多继承，由于会出现调用的不确定性（存在隐患），所以java将C++的多继承机制，进行了改良，在java中变成了多实现（一个类实现多个接口） 多继承：同是继承一个或两个父类，一个父类有A,B两功能，一个父类有C,D两个功能，子类一继承就具备A,B,C,D四个功能 多实现：一个父类有A,B两抽象功能，一个父类有C,D两个抽象功能。一个子类实现就具备这4个功能 （与多继承的小差别） 我们注重的是事物的功能。至于功能该怎么用，由子类明白，假设父类的功能已经符合子类的需求。子类直接用就能够了。假设不符合，子类还是具备这个功能。可是要重写，可是功能干什么，子类说的算 为什么java的多实现称为改良的多继承？ 多继承的弊端就是假设两个的父类的方法名同样，就会出现不确定性。而多实现呢？就不存在了，由于show（）的方法体是子类自己写的，而多继承，继承的是方法体。java改良后，没有方法体，方法体是子类决定的
多实现。小练习：interface A{ public abstract void show();}interface B{ public abstract void show(); public abstract int add(int a,int b);}class C implements A,B{ public void show() { System.out.println("你好"); } public int add(int a,int b) { return a+b+10; }}public class Main { public static void main(String[] args) { C BLF = new C(); BLF.show(); System.out.println(BLF.add(1, 3)); }} 故：多实现，对多继承实现了改良 当然，下面两种test的代码方式，是java不能忍受的
interface A{ public abstract void show();}interface B{ public abstract int show();}Test 1：class C implements A,B{ public void show()//假设这样写的C还是一个抽象类。由于没有覆盖所以的方法 { System.out.println("你好"); }}Test 2：class C implements A,B{ public void show() { System.out.println("你好"); } public int show() { System.out.println("你好,世界");//C中已经定义了show，调用show，返回值确定不了。int还是void }} 当然，接口的功能。远不于仅仅如此 一个类在继承，还有一个类在多实现（也就是先给该类找一个父类，然后在扩展这些功能） 见代码：
interface A{ public abstract void show();}interface B{ public abstract void show(); public abstract int add(int a,int b);}class D{ public void print() { System.out.println("你好好"); }}//非常猛！！ ！ class E extends D implements A,B//E继承了D，实现了A和B，这样E的功能就丰富多了 { //E单继承了D中的print功能，可是还想用A,B中的功能，可是这些功能无发通过继承了， //那么就同一时候实现接口的方式，来扩展E中的功能 public void show() { System.out.println("你好"); } public int add(int a,int b) { return a+b+10; } public void test() { System.out.println("測试"); } } /* * 接口的出现，避免了单继承的局限性*/ public class Main { public static void main(String[] args) { E BLF = new E(); BLF.show(); System.out.println(BLF.add(1, 3)); BLF.test(); BLF.print(); } }
类与类之间是继承关系。类与接口之间是实现关系。接口与接口之间呢？ java不支持多继承的原因，就在于方法体
interface A{ public abstract void show();}interface B{ public abstract void show(); public abstract int add(int a,int b);}interface E extends A,B//继承关系。且能够多继承，更猛！ ！。 { //多继承。差就差在方法体上，接口没方法体，所以能够多继承 public abstract void test(); } class G implements E { public void show() { System.out.println("你好好啊"); } public int add(int a,int b) { return 250; } public void test() { System.out.println("你不好"); } } public class Main { public static void main(String[] args) { G BLF = new G(); System.out.println(BLF.add(3, 4)); BLF.show(); } }
哥们仅仅能说，java真的特别猛！！。 以上为接口的基本实现。。
。
接口的特点： 接口是对外暴露的规则 接口是程序的功能扩展 接口的出现减少耦合性 接口能够用来多实现类和接口是实现关系，而且类能够继承一个类同一时候实现多个接口 接口与接口是继承关系 接口的概念很大，凡是对外暴露的内容都是接口，比方电脑的USB插口，来连接鼠标。规则是仅仅能连接USB鼠标。 耦合性：能够理解为紧密相联，减少耦合性就是减少了两者紧密相连的程度。比方早期的笔记本电脑，电脑和鼠标是相连的，非常不方便，而USB接口的出现。使非常多不同的鼠标都能够连接电脑。仅仅要这个鼠标是USB的（即符合USB这个规则）。这就叫减少了电脑和鼠标的耦合性，同一时候呢，USB还能够插U盘。这就体现了功能的扩展。
接口和抽象类的差别：
共性：都是不断向上抽取出来的抽象的概念 差别： 1.抽象类体现继承关系。一个类仅仅能但继承 接口是实现关系，一个接口能够多实现 2.抽象类是继承，是“A is a B”，（A是一种B）。定义体系的基本共性内容（我今年上大二。我就是一个大二的学生） 接口是实现，是“A like a B”，A类似于B，定义体系的额外的功能 （大二学生。基本功能是学习，有的会抽烟，有的不会，会抽烟的属于大二学生这个体系，抽烟是他具备的额外功能） 3.抽象类中能够定义抽象的，还能够定义非抽象的，供子类直接使用其非抽象方法 接口，必须全是定义抽象的，其方法子类必须自己实现，并且其内成员还必须是固定的修饰符
abstract 犬{ public static vois 叫();}interface 导盲 //导盲的方式可能不一样，导盲是犬的额外功能。所以定义接口{// 导盲 为什么不定义类？无法多继承。 //又有疑问为什么犬不定义为接口？ //犬中可能存在一些同样的共性，全部犬科都是一样的，那么这些共性内容。就不是必需定义 //为抽象方法了，定义为一般方法就能够了。而这些接口是实现不了的 public static void 导盲();}class 导盲犬 extends 犬 implements 导盲//这里甚至能够多实现{ public void 叫() { } public void 导盲()//导盲嘛，不一定就是犬，猪，猫，训练好，也能导盲 { //那么导盲就是一个共性内容->抽取 //可能会想大不了每一个类里（导盲犬、猫。猪），都写导盲这种方法，何必抽取？ //这样想：导盲犬上，导盲猫上，导盲猪上。这样好，还是具备导盲功能的都上好 //答案不言而喻 }} 所以,在不同的问题领域，有不同的分析方式，不要固化思维方式 接口的应用： /* * 笔记本电脑的使用 * 为了扩展笔记本电脑的功能。可是怎样会用到什么功能不知道 * 所以。定义一个规则，仅仅要满足这个规则，那么笔记本就能够具备这个功能 * 这个规则呢。就是USB接口，鼠标、键盘、视频都能够用，仅仅有满足USB规则 * 这个规则在java中就是interface*/
interface USB//暴露的规则{ public abstract void open();//开启 public abstract void close();//关闭}class Mouse implements USB//实现规则{ public void open() { System.out.println("Mouse open"); } public void close() { System.out.println("Mouse close"); }}class Upan implements USB{ public void open() { System.out.println("Upan open"); } public void close() { System.out.println("Upan close"); }}//这些设备和电脑的耦合性就减少了public class Main { public static void main(String[] args) { UseUsb(new Upan());//功能扩展 UseUsb(new Mouse()); } //使用规则 public static void UseUsb(USB a)//接口型引用，用于接受接口的子类的对象 { a.open(); a.close(); }}