Java_接口

　接口与抽象类相比，接口使用率更高，所有设计都围绕着接口设计

接口是特殊的类，但里面的组成与类不同，主要有抽象方法和全局常量组成。

接口使用interface定义

定义一个接口：

interface A{

　　public static final String MSG = "Hello";

　　public abstract void print();

}

接口定义完成后，需要遵循：

接口一定要定义子类，子类利用implements实现接口，一个子类可以同时实现多个接口，一个抽象类只能被一个子类继承

接口的子类（如果不是抽象类），必须覆写接口中全部抽象方法

接口对象利用子类对象的向上转型进行实例化操作

范例：使用接口

interface A{

　　public static final String MSG = "Hello";

　　public abstract void print();

}

interface B{

　　public abstract void fun();

}

class X implements A,B{  //X类同时实现了A和B两个父类接口

　　public void print(){}

　　public void fun(){}

}

public class TestDemo{

　　public static void main(String args[]){

　　　　X x = new X();  //实例化子类对象
　　　　A a = x;　　　//子类为父接口实例化
　　　　B b = x;
　　　　a.print();
　　　　b.fun();
　　}

}

interface A{

　　public static final String MSG = "Hello";

　　public abstract void print();

}

interface B{

　　public abstract void fun();

}

class X implements A,B{  //X类同时实现了A和B两个父类接口

　　public void print(){}

　　public void fun(){}

}

public class TestDemo{

　　public static void main(String args[]){

　　　　A a = new X(); //子类为父接口实例化
　　　　B b = (B)a ; B和A没有关系了，但可以转换是因为X是子类
　　　　b.fun(); 　　
　　　} 
}

注意：

接口里面定义的时候就明确的开发要求：抽象方法、全局常量。接下来两个操作完全相同：

interface A{

　　public static final String MSG = "Hello";

　　public abstract void print();

}

interface A{

　　String MSG = ""Hello";

　　public void print();

}

一般都写public，但不去写abstract

一个普通类如果要实现接口又要继承抽象类，要先extends继承抽象类，再implements实现接口

class 子类 extends 抽象类 implements 接口1，接口2，接口3{}

一个抽象类可以直接实现接口：

 接口不能继承抽象类，但一个接口可以使用extends继承多个父接口。

interface A{

　　public void printA();

}

interface B{

　　public void printB();

}

interface C extends A,B{  //C是A与B的子接口

 　　public void printC();
}

class X implements C{

　　public void printA(){}

　　public void printA(){}

　　public void printA(){}

}

 虽然接口只能有抽象方法和全局常量，但其他结构不受限制，也就是说可以定义内部类，内部抽象类，内部接口。

如果一个内部接口使用了static定义，那么这个内部接口就属于外部接口

接口特点：

避免了单继承的局限，一个子类可实现多个接口

接口中的权限统一为public，方法是抽象方法

所有的内部类结构都不受到定义语法的限制，一个内部接口使用了static定义，那么这个内部接口就属于外部接口

开发中接口三个使用原则：

　　制定操作的标准

　　表示一种能力

　　将服务器端的远程方法视图提供给客户端

用接口定义个标准

interface USB{

　　public void start();

　　public void stop();

}

class Computer{

　　public void plugin(USB usb){ // 不管有多少个设备，plugin只要接受的是USB实例，那么操作就是固定的

　　　　usb.start();

　　　　usb.stop();

　　}

}

class Flash implements USB{

　　public void start(){

　　　　System.out.println("U盘开始工作");

　　}

　　public void stop(){

　　　　System.out.println("U盘停止工作");

　　}

}

class Keyboard implements USB{

　　public void start(){

　　　　System.out.println("键盘开始工作");

　　}

　　public void stop(){

　　　　System.out.println("键盘停止工作");

　　}

}

public class TestDemo{

　　public static void main(String args[]){

　　　　Computer c = new Computer();
　　　　c.plugin(new Flash());  //传递u盘对象
　　　　c.plugin(new Keyboard()); //传递键盘对象
　　}

}

 所以接口有千万个子类，也是可以在一个接口上使用的。所以接口是定义标准的。 

工厂设计模式

 interface Fruit{

　　public void eat();

}

class Apple implements Fruit {

　　public void eat(){

　　　　System.out.println("吃苹果");

　　}

}

class Cherry implements Fruit{

　　public void eat(){

　　　　System.out.println("吃樱桃");

　　}

}

class Factory {

　　public static Fruit getInstance(String className){ //直接取得接口实例

　　　　if("apple" equals(className)){

　　　　　　return new Apple();

　　　　} else if("cherry" equals(className)){

　　　　　　return new Cherry();　　

　　　　} else {

　　　　　　return null;

　　　　}

　　}

}

public class TestDemo{

　　public static void main(string args[]){

　　　　Fruit f = Factory.getInstance(args[0]);  //为了方便模拟调用

　　　　if(f != null) {

　　　　　　f.eat();

　　　　}

　　}

}

代理设计模式

 在接口上的一种应用，一个接口有一个核心的操作主题，但是在整个操作中只依靠核心操作主题是无法完成所需要功能的，那么需要一个代理的主题。代理主题完成所有的与核心有关的概念。

 interface Subject{ //核心操作主题

　　　public void get();
}

class RealSubject implements Subject{

　　public void get(){

　　　　System.out.println("取回了被强行霸占的钱");
　　}

}

class ProxySubject implements Subject{

　　private Subject subject;  //代理的真实主题

　　public ProxySubject(Subject subject){

　　　　this.subject = subject;
　　}

　　public void prepare(){

　　　　System.out.println("【追讨前的准备】");
　　}

　　public void get(){

　　　　this.prepare();
　　　　this.subject.get(); //真实主题讨债
　　　　this.destroy();
　　}

　　public void destroy{

　　　　System.out.println("【追讨后的收尾】");
　　}

}

public class TestDemo{

　　public static void main(String args[]){

　　　　Subject sub = new ProxySubject(new RealSubject());
　　　　sub.get();
　　}

}

抽象类与接口区别（面试题）

No.	区别	抽象类	接口
1	定义关键字	abstract	interface
2	组成	属性、常量、抽象方法、构造方法、普通方法	抽象方法、全局常量
3	权限	可使用各种权限	只能public
4	子类实现	利用extends可继承一个抽象类	利用implements可实现 多个接口
5	关系	抽象类可以实现多个接口	接口不能继承抽象类，接口却可以利用extends实现接口的多继承
6	对象实例化	依靠子类对象的向上转型	依靠子类对象的向上转型
7	设计模式	模板设计模式	工厂设计模式、代理设计模式
8	操作局限	单继承局限	无单继承局限

 抽象类与接口都可以显示子类必须要覆写的方法要求，但由于抽象类有单继承局限，开发中如果发现抽象类与接口 都可以同时使用的时候，有限考虑接口，抽象类实际应用中，往往是作为接口与普通类之间的过度类使用