接口

接口（interface）可理解为一种特殊的类，里面有

1）全局常量 2）公共的抽象方法

接口中没有构造方法，所以不能被实例化

public interface A{

    public A(){...}  //错，接口没有构造方法

}

interface A{
	public static final String name= "isaac";
	//String name = "isaac";
	public abstract void print();
	//void print();
	public abstract String getInfo();
	//String getInfo();
}

两种声明方法其实是一样的，由于接口里的属性都是static和final的，所以可以很方便地声明一些常量，使用时可以直接用A.name这样的方式来引用

接口的实现：

class 子类 implements 接口A，接口B{...}

一个子类可实现多个借口，并且将其中所有抽象方法全部实现，除非这个子类是抽象的

接口不可以被实例化，但是可以定义一个引用实例来引用实现该接口的类的实例

public class B implements A{...}

A a=new B();正确             A a =new A()；错误，接口不可被实例化

一个子类可同时继承抽象类与实现接口，这在java中是十分常见的，关于抽象类与接口的区别将在后面讨论

eg：class A extends B implements C,D{...}(当然这样就要将父类和实例中的全部抽象方法都实现啦！）

另外，接口也是可以被继承的！

interface A{
	public void printA();
}
interface B{
	public void printB();
}
interface C extends A,B{
	public void printC();
}
class D implements C{
	public void printA(){
		System.out.println("helloa");
	}
	public void printB(){
		System.out.println("hellob");
	}
	public void printC(){
		System.out.println("helloc");
	}
}

D实现了继承A，B的C，就要将A，B，C中的抽象方法全部实现了！

举一个上课时的例子：

interface USB{					// 定义USB接口
	public void start() ;				// USB设备开始工作
	public void stop() ;				// USB设备结束工作
}
class Computer{
	public static void plugin(USB usb){			// 只要是USB的设备就都可以向此地方插入
		usb.start() ;			// 让USB设备开始工作
		System.out.println("======= USB 设备工作 =======") ;
		usb.stop() ;			// 让USB设备停止工作
	}
};
class Flash implements USB{				// U盘
	public void start(){				// 覆写start()方法
		System.out.println("U盘开始工作。") ;
	}
	public void stop(){				// 覆写stop()方法
		System.out.println("U盘停止工作。") ;
	}
};
class Print implements USB{				// 打印机
	public void start(){				// 覆写start()方法
		System.out.println("打印机开始工作。") ;
	}
	public void stop(){				// 覆写stop()方法
		System.out.println("打印机停止工作。") ;
	}
}

关键在于computer中的函数参数是一个接口，这样做有很大好处。

下面谈谈接口与抽象类的区别：

1）抽象类中可以有自己的数据成员，也可以有非抽象成员方法（例如构造函数），但在接口中所有成员都为同一类型（即public

static final，不过在interface中一般不定义数据成员），且所有方法都为抽象方法。可以说interface是一种特殊的abstract class。

2）一个类只可以继承一个父类，但却可以实现多个接口。

3）继承关系为“is a”，接口为“like a”，例如我们要声明一个类为alarmdoor，那我们把哪些方法放入父类，哪些方法放入接口呢，这时就要考虑到alarmdoor实际上还是door，只不过因为拥有了alarm的功能而像是alarm，也就是说"is a door like a alarm"，这时我们就可以声明了 class alarmdoor extends door implements alarm{...}

接口中也可以声明静态方法：

public interface Calculator{
	static Calculator getInstance{
		return new BasicCalculator;
	}
	int add(int first,int second);
}
class BasicCalculator implements Calculator{
	public int add(int first,int second){
		return first+second;
	}
}
public class TestStatic{
	public static void main(String []args){
		Calculator t=Calculator.getInstance();
		int i=t.add(1,2);
		System.out.println(i);
	}
}

向上转型与向下转型：

向上：子类->父类 （程序会自动完成

向下：父类->子类（必须声明要转型的子类类型，否则会报错

class A{
	public void fun1(){
		System.out.println("A->fun1");
	}
	public void fun2(){
		this.fun1();
	}
}
class B extends A{
	public void fun1(){
		System.out.println("B->fun1");
	}
	public void fun3(){
		System.out.println("B->fun3");
	}
}
public class Demo{
	public static void main(String []args){
		B b=new B();
		A a=b;
		a.fun1();
	}
}

A a = b ；为向上转型，而a.fun1();调用的是B中的函数，因为子类覆写了父类

A a=new B();
B b=(B)a;

这里为向下转型，即先向上转型再向下转型，如果直接向下转型则会报错：对象转换异常

csdn自带的换行太垃圾了啊啊啊啊啊！！！考虑下次写用markdown了OVO