Java——接口interface

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("=====被代理类执行完毕======");

}

}