3.5接口interface
①有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
②接口(interface)是抽象方法和常量值的定义的集合。
③从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
3.5.1接口基础语法：
接口也是一种引用类型，可以等同看做类.
①如何定义接口，语法：
[修饰符] interface 接口名{}
②接口中只能出现：常量、抽象方法。
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有方法都默认是由public abstract修饰的。
③接口其实是一个特殊的抽象类，特殊在接口是完全抽象的。
④接口中没有构造方法，无法被实例化。
⑤接口和接口之间可以多继承。
⑥一个类可以实现多个接口。(这里的“实现”可以等同看做“继承”)
⑦一个非抽象的类实现接口，需要将接口中所有的方法“实现/重写/覆盖”，方可实例化。否则，仍为抽象类。
⑧如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类
⑨接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性。
定义Java类的语法格式：先写extends，后写implements
|
public interface A{ //常量(必须用public static final修饰) public static final String SUCCESS = "success"; public static final double PI = 3.14; byte MAX_VALUE = 127; //常量//public static final是可以省略的。 //抽象方法(接口中所有的抽象方法都是public abstract) public abstract void m1(); void m2();//public abstract是可以省略的。 } interface B{ void m1(); } interface C{ void m2(); } interface D{ void m3(); } interface E extends B,C,D{ void m4(); } //implements是实现的意思，是一个关键字. //implements和extends意义相同。 class MyClass implements B,C{ public void m1(){} public void m2(){} } class F implements E{ public void m1(){} public void m2(){} public void m3(){} public void m4(){} } |
3.5.2接口的作用
①可以使项目分层，所有层都面向接口开发，开发效率提高了。
②接口使代码和代码之间的耦合度降低，就像内存条和主板的关系，变得“可插拔”。可以随意切换。
③接口和抽象类都能完成某个功能，优先选择接口。因为接口可以多实现，多继承。并且一个类除了实现接口之外，还可以去继承其他类（保留了类的继承）。
举例1：
|
public interface CustomerService{
//定义一个退出系统的方法 void logout();
} |
|
/* 编写接口的实现类. 该类的编写完全是面向接口去实现的。 */ public class CustomerServiceImpl implements CustomerService{ //对接口中的抽象方法进行实现。 public void logout(){ System.out.println("成功退出系统！"); } } |
|
public class Test{ //入口 public static void main(String[] args){ //要执行CustomerServiceImpl中的logout方法.
//以下程序面向接口去调用 CustomerService cs = new CustomerServiceImpl(); //多态 //调用 cs.logout(); } } |
举例2：
|
/* 汽车和发动机之间的接口。
生产汽车的厂家面向接口生产。 生产发动机的厂家面向接口生产。 */ public interface Engine{
//所有的发动机都可以启动. void start(); } |
|
//生产汽车 public class Car{
//Field //引擎 //面向接口编程 Engine e;
//Constructor Car(Engine e){ this.e = e; }
//汽车应该能够测试引擎 public void testEngine(){ e.start();//面向接口调用 } } |
|
public class YAMAHA implements Engine{ public void start(){ System.out.println("YAMAHA启动"); } } |
|
public class HONDA implements Engine{ public void start(){ System.out.println("HONDA启动"); } } |
|
public class Test{
public static void main(String[] args){
//1.生产引擎 YAMAHA e1 = new YAMAHA();
//2.生产汽车 Car c = new Car(e1);
//3.测试引擎 c.testEngine();
//换HONDA c.e = new HONDA();
c.testEngine(); } } |
3.5.3接口的应用：工厂方法(FactoryMethod)& 代理模式(Proxy)
①工厂方法(FactoryMethod)
概述：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
适用性：
1)当一个类不知道它所必须创建的对象的类的时候
2)当一个类希望由它的子类来指定它所创建的对象的时候
3)当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候
工厂方法举例：
总结：
FactoryMethod模式是设计模式中应用最为广泛的模式，在面向对象的编程中，对象的创建工作非常简单，对象的创建时机却很重要。FactoryMethod解决的就是这个问题，它通过面向对象的手法，将所要创建的具体对象的创建工作延迟到了子类，从而提供了一种扩展的策略，较好的解决了这种紧耦合的关系。
//接口的应用：工厂方法的设计模式
|
public class TestFactoryMethod { public static void main(String[] args) { IWorkFactory i = new StudentWorkFactory(); i.getWork().doWork();
IWorkFactory i1 = new TeacherWorkFactory(); i1.getWork().doWork(); } } interface IWorkFactory{ Work getWork(); } |
|
class StudentWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new StudentWork(); }
} class TeacherWorkFactory implements IWorkFactory{ @Override public Work getWork() { return new TeacherWork(); }
} interface Work{ void doWork(); } class StudentWork implements Work{ @Override public void doWork() { System.out.println("学生写作业"); } } class TeacherWork implements Work{ @Override public void doWork() { System.out.println("老师批改作业"); } } |
②代理模式(Proxy)
概述：
为其他对象提供一种代理以控制对这个对象的访问。
|
interface Object{ void action(); } class ProxyObject implements Object{ Object obj; public void action(){ System.out.println("代理开始"); obj.action(); System.out.println("代理结束"); } public ProxyObject(){ System.out.println("这是代理类"); obj = new ObjectImpl(); } } class ObjectImpl implements Object{ public void action(){ System.out.println("======"); System.out.println("======"); System.out.println("被代理的类"); System.out.println("======"); System.out.println("======"); } } public class Test2 { public static void main(String[] args) { Object ob = new ProxyObject(); ob.action(); } } |
//接口的应用：代理模式（静态代理）
|
public class TestProxy { public static void main(String[] args) { Object obj = new ProxyObject(); obj.action(); } } interface Object{ void action(); } //代理类 class ProxyObject implements Object{ Object obj; public ProxyObject(){ System.out.println("代理类创建成功"); obj = new ObjctImpl(); } public void action(){ System.out.println("代理类开始执行"); obj.action(); System.out.println("代理类执行结束"); } } //被代理类 class ObjctImpl implements Object{ @Override public void action() { System.out.println("=====被代理类开始执行======"); System.out.println("=====具体的操作======"); System.out.println("=====被代理类执行完毕======"); } } |