java-接口（java独有的）

一、接口的基本语法：

Java中的四种类型：类、接口、枚举、标注

接口（Java中的四种类型之一）：特殊的抽象类（都是公开的）

1.属性都是公开静态常量 public static final

2.方法都是公开抽象方法。public abstract

3.没有构造方法

接口类代码：

package day12;

public class TestInterface {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

}

abstract class ClassA {
	public static final int A = 10;
	public static final double B=2.5;
	public abstract void m1();
	public abstract void m2();
}

　　接口关键字：interface

 

 

ClassA类与IA接口

用dos命令来运行文件，分别对应生成的类或接口的.class（字节码）文件。

对比ClassA类与IA接口，有什么区别？IA接口（自己也不能写构造方法）内容一致，区别差在ClassA类有构造方法，而IA接口却没有。

接口里的属性都是公开静态常量，所以public static final可以不写，方法也同样如此，public abstract不写也可以。

类实现接口，二者之间不能用extends关键字，需要用到implements。虽然接口与类的继承不能用到继承关键字，但是确是继承关系。

 IA：接口

MyClass：接口的实现类

解决报红方法：

1）自己（abstract）成为抽象类。

2）实现接口的所有抽象方法。

 

 一个类实现接口，如果这个类不希望成为抽象类，就必须实现接口中的所有抽象方法。在jdk8.0以后，方法有默认实现。

接口可以声明引用，但不能创建对象，因为它是抽象类。可以IA a=new MyClass();把子类给父类引用（即多态）。

二、接口和类的关系：

类和类之间有继承，接口和接口之间也能有继承（extends），类实现接口是implements。

类和类之间的继承：只支持单继承。一个类只能有一个直接父类。

接口和接口之间的继承，可以多继承。一个子接口可以同时拥有多个父接口。

一个类在继承另外一个类的同时，还能实现多个接口。

代码：

package day12;

public class TestInterface {

	public static void main(String[] args) {
	　　MyClass mc =new MyClass();
		IA a=mc;
		IB b=mc;
		IC c=mc;
		ID d=mc;
		ClassE e=mc;
		a.m1();
		a.m2();
		b.m3();
		d.m3();
		d.m4();
		d.m5();
		e.m6();
	}

}

abstract class ClassA {
	public static final int A = 10;
	public static final double B = 2.5;

	public abstract void m1();

	public abstract void m2();
}

interface IA {
	public static final int A = 10;
	public static final double B = 2.5;

	void m1();

	void m2();
}

interface IB {
	void m3();
}

interface IC {
	void m4();
}

interface ID extends IB, IC {
	void m5();
}
abstract  class ClassE{
	public abstract void m6();
}
class MyClass extends ClassE implements IA,ID {
	public void m1() {}
	public void m2() {}
	public void m3() {}
	public void m4() {}
	public void m5() {}
	public void m6() {}
}

三：多继承的复杂性:

　　子类引用可以直接赋值给父类引用。

　　父类引用需要强转才能给子类引用。

　　没有继承关系的两种类型不能进行强转。

代码：

package day12;

public class TestMultiInheritance {

	public static void main(String[] args) {
		Animal a;
		Dog d;
		a=new Dog();
		d=(Dog)a;//强制转换 有成功的可能
//		Person p=(Person)d;//狗不可能是人，强制转换只能发生在有继承关系的，不能随便强转
	}

}
class Animal{
	
}
class Dog extends Animal{
	
}
class Person{
	
}

　　如果Person是接口，一个对象可以既放进狗的引用，也可以放进人的引用。

例如：

class Snoopy extends Dog implements Person{
}

　　强转的两种类型中，如果包含接口类型，强转代码一定编译通过。

四、接口与多继承：

　　类可以单接口多实现。

　　接口实现多继承？有多继承的逻辑，也保证了树的简单性。根本上，接口的出现并不是为了多继承。

五、接口的解耦合

　　接口主要作用：接口的方法都是抽象的话，接口成为一种标准。接口中的方法都是没实现的，只规定了做什么，没有规定怎么做。

　　标准的出现是为了解耦合。

　　什么是耦合？对象之间和对象之间会形成联系，耦合：对象和对象之间的紧密程度。

　　松散：弱耦合 联系弱  人和眼镜   比较好

　　紧密：强耦合 切不断  人和眼球

　　接口作为标准，使接口的使用者和接口的实现者分离，实现弱耦合关系。

 代码例子：

package day12;

public class TestInterface2 {

    public static void main(String[] args) {
        Light light=new Light();
        RedBulb bulb1=new RedBulb();
        light.setBulb(bulb1);//把灯泡安装到台灯上，建立两者的关联关系
        light.powerOn();
        
        YellowBulb bulb2=new YellowBulb();
        light.setBulb(bulb2);
        light.powerOn();
    }

}
class Light{
    private Bulb bulb;
    public void setBulb(Bulb bulb) {
        this.bulb=bulb;
    }
    public void powerOn() {
        bulb.shine();
    }
}
interface Bulb{
    void shine();
    }
class RedBulb implements Bulb{
    public void shine() {
        System.out.println("发出红光");
    }
}
class YellowBulb implements Bulb{
    public void shine() {
        System.out.println("发出黄光");
    }
}

运行结果：