接口

1.接口的本质

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范

【为什么需要接口？接口和抽象类的区别】

• 接口就是比抽象类还抽象的抽象类，可以更加规范的对子类进行约束。全面的专业的实现了规范和具体实现的分离
• 抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范
• 从接口的实现者角度看，接口定义了可以向外部提供的服务
• 从接口的调用者角度来看，接口定义了实现者能提供哪些服务
• 接口的两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。在工作以后，做系统时往往是使用面向接口的思想来设计系统

【接口本质探讨】

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想。如果你是汽车，必须能跑。如果你是好人，必须帮助他人。
• 接口的本质是契约，就像我们人间的法律一样，制定好了大家都要遵守
• oo的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如：c++,java,c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

2.接口与抽象类的区别

抽象类也是类，除了可以写抽象方法以及不能直接new对象之外，其他的和普通类没有不一样的。接口是另一种类型，和类是有本质的区别的，所以不能用类的标准去衡量接口。

声明类的关键字是class，声明接口的关键字是interface

抽象类是用来被继承的，java中的类是单继承。

类A继承了抽象类B，那么类A的对象就属于B类型了，可以使用多态

一个父类的引用，可以指向这个父类的任意子类对象

注：继承的关键字extends

接口是用来被类实现的，java中的接口可以被多实现

类A实现接口B,C,D,E...那么类A的对象就属于B,C,D,E等类型，可以使用多态

一个接口的引用，可以指向这个接口的任意实现类对象

注：实现的关键字是implements

3.接口中的方法都是抽象方法

接口中可以不写任何方法，但如果写方法了，该方法必须是抽象方法

public interface Action{
  public abstract void run();
  //默认就是public abstract修饰的
  void test();
  public void go();        
}

 

4.接口中的变量都是静态常量（public static final修饰）

接口中可以不写任何属性，但如果写属性了，该属性必须是public static final 修饰id静态变量。

注：可以直接使用接口名访问其属性。因为public static修饰的

注：声明的同时必须赋值（因为接口中不能编写静态代码块）

public interface Action{
  public static final String name = "tom";
  //默认就是public static final修饰的
  int age =20;      
}
main:
System.out.println(Action.name);
System.out.println(Action.age);

 

5.一个类可以实现多个接口

public class Student implements A,B,C,D{ 
//Student需要实现接口A B C D中所有的抽象方法 
//否则Student类就要声明为抽象类,因为有抽象方法没实现 
}
main: 
A s1 = new Student(); 
B s2 = new Student(); 
C s3 = new Student(); 
D s4 = new Student();

 

注：

s1只能调用接口A中声明的方法以及Object中的方法。

s2只能调用接口B中声明的方法以及Object中的方法。

s3只能调用接口C中声明的方法以及Object中的方法。

s4只能调用接口D中声明的方法以及Object中的方法。

注：必要时可以类型强制转换

例如：接口A中有test()，接口B中有run()

A s1 = new Student();
s1.test();

B s2 = new Student();
s2.run();

if(s1 instanceof B){
  ((B)s1).run();  
}

 

6.一个接口可以继承多个父接口

public interface A{
  public void testA();  
}

public interface B{
  public void testB();  
}
//接口C把接口A,B中的方法都继承过来了
public interface C extends A,B{
  public void testC();  
}

//Student相当于实现了A,B,C三个接口，需要实现所有的抽象方法
//Studdent的对象也就是同事属于A类型 B类型 C类型
public class Student implements C{
  public void testA(){}  
  public void testB(){}  
  public void testC(){}      
}

main:
C o = new Student();
System.out.println(o instanceof A);//true
System.out.println(o instanceof B);//true
System.out.println(o instanceof C);//true
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false

//编译报错
System.out.println(o instanceof String);

 

注：System.out.println(o instanceof A);

如果o是一个接口类型声明的变量，那么只要A不是一个final修饰的类，该代码就能通过编译，至于其结果是不是true，就要看变量o指向的对象的实际类型，是不是A的子类或者实现类了。

注：一个引用所指向的对象，是有可能实现任何一个接口的。（java中的多实现）

7.接口的作用

接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建。

【接口名】 【对象名】=new 【实现接口的类】

这样你想用哪个类的对象就可以new哪个对象了，不需要改原来的代码。

假如我们两个类中都有个function()的方法，如果我用接口，那样我new a();就是用a的方法，new b()就是用b的方法

这个就叫统一访问，因为你实现这个接口的类的方法名相同，但是实现内容不同

总结：

1. java接口中的成员变量默认都是public,static，final类型的（都可以省略），必须被显示初始化，即接口中的成员变量为常量（大写，单词直接用_分隔）
2. java接口中的方法默认都是public，abstract类型的（都可省略），没有方法体，不能被实例化
3. java接口中只能包含public，static,final类型的成员变量和public，abstract类型的成员方法
4. 接口中没有构造方法，不能被实例化
5. 一个接口不能实现另一个接口，但它可以继承多个其他的接口
6. java接口必须通过类来实现它的抽象方法
7. 当类实现了某个java接口时，它必须实现接口中的所有抽象方法，否则这个类必须声明为抽象类
8. 不允许创建接口的实例（实例化），但允许定义接口类型的引用变量，该引用变量引用实现了这个接口的类的实例
9. 一个类智能继承一个直接的父类，但可以实现多个接口，间接的实现了多继承。

interface SwimInterface{ 
    void swim(); 
}

class Fish{ 
    int fins=4; 
}
class Duck { 
    int leg=2; 
    void egg(){}; 
}

class Goldfish extends Fish implements SwimInterface { 
    @Override 
    public void swim() { 
    System.out.println("Goldfish can swim "); 
    } 
}

class SmallDuck extends Duck implements SwimInterface { 
    public void egg(){ 
    System.out.println("SmallDuck can lay eggs "); 
}
    @Override 
    public void swim() { 
    System.out.println("SmallDuck can swim "); 
    } 
}

public class InterfaceDemo { 
    public static void main(String[] args) { 
     Goldfish goldfish=new Goldfish();
     goldfish.swim(); 
    SmallDuck smallDuck= new SmallDuck(); 
    smallDuck.swim(); 
    smallDuck.egg(); 
    } 
}