接口的特点
1、 所有属性都是公开静态常量
2、 所有方法都是公开抽象方法
abstract class MyAbstractClass{
public static final int VALUE1 = 100; //属性是公开静态常量
public static final int VALUE2 = 200; //第二个属性
public abstract void m1(); //方法是公开抽象方法
public abstract void m2(int n); //第二个方法
}
class MySubClass extends MyAbstractClass{#公开抽象方法
public void m1(){}
public void m2(int n){}
}
interface MyInterface{#接口
public static final int VALUE1 = 100;
public static final int VALUE2 = 200;
public abstract void m1();
public abstract void m2(int n);
}
interface 替代了 abstract class 这两个关键字。interface 关键字和 class 关键字类似,一个接口编译后会生成一个.class 文件;一个.java 文件中可以有多个接口,但是最多只能有一个公开的接口,且公开接口的接口名与文件名相同。
既然接口中所有属性都是公开静态常量,则接口中的属性,可以省略 public static final关键字;同样的,由于接口中所有方法都是公开抽象方法,因此可以省略 public abstract 关键字。因此,上面的 MyInterface 可以改写如下:
interface MyInterface{
int VALUE1 = 100;
int VALUE2 = 200;
void m1();
void m2(int n);
}
implements。使用这个关键字表示“实现”,类似于抽象类中子类继承父类的关系。
class MyImpl implements MyInterface{
public void m1(){}
public void m2(int n){}
}
1. 一个类实现接口,如果不希望这个类作为抽象类,则应该实现接口中定义的所有方法。
2. 接口中所有的方法都是公开方法。因此,在实现接口中的方法时,实现类的方法也必须写成公开的!由于类中的方法,默认访问修饰符是“default”,因此,在实现接口中的方法时,修饰符“public”不能省略。
除此之外,抽象类之间可以继承,同样的,接口之间也可以继承。接口之间继承时,使用的关键字同样为 extends。例如:
interface IA{
void ma();
}
interface IB extends IA{
void mb();
}
上面这个例子中,IB 接口继承自 IA 接口。因此,IB 中存在两个方法:ma 方法是从 IA接口中继承来的,mb 方法是 IB 接口自身定义的。如果有一个类要实现 IB 接口,则必须实现 ma 和 mb 两个方法,例如:
class IAIBImpl implements IB{
public void ma(){}
public void mb(){}
}
1.2 多继承
接口之间可以多继承。不同于 Java 中对于类之间的单继承的要求,接口之间没有这个限制。一个接口可以继承多个接口,例如下面这个例子:
interface IA{
void ma();
}
interface IB{
void mb();
}
interface IC extends IA, IB{ //IC 同时继承 IA 和 IB 两个接口
void mc();
}
除此之外,一个类在继承另外一个类的同时,还可以实现多个接口,例如下面的例子:
interface IA{
void ma();
}
interface IB(){
void mb();
}
//IC 继承自 IA,IB 接口。这里是接口的多继承
interface IC extends IA, IB{
void mc();
}
interface ID{
void md();
}
abstract class ClassE{
public abstract void me();
}
/*
一个类可以继承自一个类,并实现多个接口
MyImpl 继承自 ClassE 类,实现了 IC 和 ID 接口
注意,先写继承自哪个类,再写实现了哪些接口
*/
class MyImpl extends ClassE implements IC, ID{
//IC 接口中包含 ma、mb、mc 方法
public void ma(){}
public void mb(){}
public void mc(){}
//ID 接口中包含 md 方法
public void md(){}
//ClassE 中包含 me 方法
public void me(){}
}
接口和接口之间可以多继承;一个类在继承一个父类的同时,还能够实现多个接口。
1.3 接口与多态
有了接口的多继承特性,加上一个类能够实现多个接口,这样,接口结合多态,语法和概念都变得非常的灵活。
public class TestMyImpl{
public static void main(String args[]){
IA ia = new MyImpl();
System.out.println(ia instanceof IA);//true
System.out.println(ia instanceof IB);//true
System.out.println(ia instanceof IC);//true
System.out.println(ia instanceof ID);//true
System.out.println(ia instanceof ClassE);//true
System.out.println(ia instanceof MyImpl);//true
}
}
2 接口的作用
在 Java 中,接口主要用来实现两大功能:一是用接口实现多继承;二是用接口来进行解耦合。其中,后者是接口最重要的作用。
2.1 接口与多继承
首先,使用接口实现多继承,能够区分主要类型和次要类型。
父类体现了设备的共性,而子类体现了特性。
另外,单继承相对多继承的好处,就在于单继承具有简单性。使用单继承,类与类之间能够形成简单的树状结构。而对于多继承,类和类之间的关系相对要复杂的多,很有可能会形成复杂的网状结构。但是,用接口实现的多继承,则不会破坏类之间树状结构的简单性。这是因为这棵树是由类之间形成的,是事物主要类型所组成的关系。一个类实现再多的接口,有再多的次要类型,也不会改变其主要类型之间的树状结构。
2.2 接口与解耦合
除了实现多继承之外,接口最重要的作用就是解耦合。
class RedBulb {
public void shine(){
System.out.println(“Shine in Red”);
}
}
class YellowBulb{
public void shine(){
System.out.println(“Shine in Yellow”);
}
}
class GreenBulb{
public void shine(){
System.out.println(“Shine in Green”);
}
}
class Lamp{
private RedBulb bulb;
public void setBulb(RedBulb bulb){
this.bulb = bulb;
}
public void on(){
bulb.shine();
}
}
public class TestLamp{
public static void main(String args[]){
Lamp lamp = new Lamp();
RedBulb rb = new RedBulb();
lamp.setBulb(rb);
lamp.on();
}
}
由于 Lamp 类中的 bulb 属性是 RedBulb 类型,因此,一旦要修改,则必须要把 Lamp类中的属性类型进行修改,并且修改setBulb 方法的相应参数和实现。也就是说,当我们希望把 bulb 属性由 RedBulb 替换为 GreenBulb 的时候,必须修改 Lamp 类的代码。
也就是说,如果要想更换不同种类的灯泡,就要修改台灯的内部结构!这无疑是跟现实生活不相符合的。之所以产生这样的矛盾,原因在于 Lamp 类与 RedBulb 类型紧密联系在一起,形成了强耦合的关系,如下图:
下面我们使用接口来解决这样的问题。
interface Bulb{//首先,定义 Bulb 接口
void shine();
}
class RedBulb implements Bulb{
public void shine(){
System.out.println(“Shine in Red”);
}
}
class YellowBulb implements Bulb{
public void shine(){
System.out.println(“Shine in Yellow”);
}
}
class GreenBulb implements Bulb{
public void shine(){
System.out.println(“Shine in Green”);
}
}
class Lamp{
private Bulb bulb;
public void setBulb(Bulb bulb){
this.bulb = bulb;
}
public void on(){
bulb.shine();
}
}
public class TestLamp{
public static void main(String args[]){
Lamp lamp = new Lamp();
Bulb b1 = new RedBulb();
lamp.setBulb(b1);
lamp.on();
Bulb b2 = new GreenBulb();
lamp.setBulb(b2);
lamp.on();
}
}
Lamp 类的 bulb 属性被改为接口类型 Bulb,从而,Lamp 类与具体的实现类之间用 Bulb接口分离开了。当 Lamp 类希望把 bulb 属性由 RedBulb 对象变更为 GreenBulb 对象时,不需要修改任何自身代码。只需要调用 setBulb 方法,接受不同的 Bulb 接口的实现类就可以了,从而,Lamp 类通过 Bulb 接口,实现了与 Bulb 实现类的弱耦合。如下图所示:
3 接口回调