接口

接口

 

接口的本质

普通类：只有具体实现

抽象类：具体实现和规范(抽象方法) 都有！

接口：只有规范！

 

 

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

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：

规范和具体实现的分离。

抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面

向规范的，规定了一批类具有的公共方法规范。

从接口的实现者角度看，接口定义了可以向外部提供的服务。

从接口的调用者角度看，接口定义了实现者能提供那些服务。

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义

好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系

统时往往就是使用“面向接口”的思想来设计系统。

 

---

 

【接口的本质探讨】

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。如果你是天

使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则

必须欺负好人。

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具

备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合

理的去抽象。

 

 

接口与抽象类的区别

抽象类也是类,除了可以写抽象方法以及不能直接new对象之外,其他的和普通类没有什么不一样的。

接口已经另一种类型了,和类是有本质的区别的,所以不能用类的标准去衡量接口。

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

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

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

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

注:继承的关键字是extends

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

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

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

注:实现的关键字是implements

 

---

 

 

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

 

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

public abstract void run(); 

//默认就是public abstract修饰的 

void test(); 

public void go(); 

}

　　

接口中的变量都是静态常量(public static final修饰)

 

接口中可以不写任何属性,但如果写属性了,该属性必须是public static fifinal修饰的静态常量。

注:可以直接使用接口名访问其属性。因为是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);
 

 

 

 

一个类可以实现多个接口

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();
​
​
//
A s1 = new Student(); 
s1.test(); 
B s2 = new Student(); 
s2.run();
if(s1 instanceof B){ 
((B)s1).run(); 
}
 

 

 

 

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

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三个接口,需要实现所有的抽象方法 
//Student的对象也就同时属于A类型 B类型 C类型 
public class Student implements C{
public viod testA(){
​
} 
public viod testB(){
​
}
public viod 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 X);

如果o是一个接口类型声明的变量,那么只要X不是一个final修饰的类,该代码就能通过编译,至于其结果

是不是true,就要看变量o指向的对象的实际类型,是不是X的子类或者实现类了。

 

---

 

接口的作用

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

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

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

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

b（）就是用b的方法

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

总结：

1、Java接口中的成员变量默认都是public,static,fifinal类型的(都可省略),必须被显示初始化,即接

口中的成员变量为常量(大写,单词之间用"_"分隔)

2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化

3、Java接口中只能包含public,static,fifinal类型的成员变量和public,abstract类型的成员方法

4、接口中没有构造方法,不能被实例化

5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口

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(); 
​
} 
​
}