java--接口与工厂设计模式--知识点总结

（1）接口是什么？

接口是一个集合，里面全部由抽象方法和全局变量组成，可以把接口理解为一个特殊的类。

（2）为什么要用接口？

java中用抽象类会存在单继承局限，所以用接口来实现多继承。

（3）接口的特点

• 1丶定义接口使用关键字interface 接口的名称使用I来表示。
  2丶接口中的数据成员默认为 public static final 。
  接口中的方法默认为 public abstract 。
  3丶接口内不能有已经实现的方法。
  4丶接口不能进行实例化。如：

  IMessage imessage = new IMessage（）；

  
  5丶接口可以继承多个接口，此时的接口拥有了继承的接口里面的抽象方法。
  6丶如果一个抽象类继承了接口，那么抽象类可以不实现接口的方法,
  但是如果再有一个普通类继承了此抽象类，那么普通类一定要实现接口和抽象类 里面的抽象方法。

**例：**USB接口 有 read（）和 write（）两种方法

interface  USB{
void read();
void write();
}

class YouPan implements USB{

@Override
public void read() {
System.out.println("U盘正在通过USB功能读取数据");
}

@Override
public void write() {
System.out.println("U盘正在通过USB功能写入数据");

}
}

class JianPan implements USB{

@Override
public void read() {
System.out.println("键盘正在通过USB功能读取数据");
}

@Override
public void write() {
System.out.println("键盘正在通过USB功能写入数据");

}
}

public class TestDemo3{

public static void main(String[] args) {
YouPan youPan = new YouPan();
youPan.read();
youPan.write();

JianPan jianPan = new JianPan();
jianPan.read();
jianPan.write();
}

}

运行结果如下：

一丶简单工厂模式

优点：1丶简单易于实现 2丶把类的实例化交给工厂，易于解耦
缺点：添加产品需要修改工厂违反OCP开放封闭原则

实例：
创建生产电脑的工厂，客户需要购买什么样的电脑，只需要输入电脑类型就可以获取该电脑

接口：

package com.bit.src;

public interface Computer {
void printComputer();
}

一个电脑工厂：

public class ComputerFactory {
public static Computer gatInstance(String type){
Computer computer=null;
if(type.equals("苹果笔记本")){
computer=new MacComputer();
}else if(type.equals("小米笔记本")){
computer=new MiComputer();
}

return computer;
}
}

具体产品：

1丶苹果笔记本

public class MacComputer implements Computer {
@Override
public void printComputer() {
System.out.println("这是苹果笔记本");
}
}

2丶小米笔记本

public class MiComputer implements Computer {
@Override
public void printComputer() {
System.out.println("这是小米笔记本");
}
}

客户端：

public class KeHu {
public static void buy(Computer computer){
computer.printComputer();
}

public static void main(String[] args) {
KeHu kehu = new KeHu();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您想要的电脑型号");
String type=scanner.nextLine();
/*  Computer computer=ComputerFactory.gatInstance(type);
kehu.buyComputer(computer);*/

buy(ComputerFactory.gatInstance(type));
}
}

二丶工厂方法模式

定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类。

优点：1丶降低了代码耦合度，对象的生成交给子类去完成。2丶实现了开放封闭原则–每次添加子产品不需要修改原有代码。

缺点：1丶增加了代码量，每个具体产品都需要一个具体共厂。2丶当增加抽象产品也就是添加一个其他产品族，需要修改工厂，违背OCP。

实例：

增加一个接口：

电脑工厂类

interface ComputerFactory {
Computer creatComputer();
}

增加两个电脑工厂：
1丶苹果电脑工厂

public class MacFactory implements ComputerFactory{

public Computer creatComputer(){

return new MacComputer();
}

}

2丶小米电脑工厂

public class MiFactory implements ComputerFactory {

public Computer creatComputer(){

return new MiComputer();
}

}

客户类

public class KeHu {
public static void buyComputer(Computer computer){
computer.printComputer();
}

public static void main(String[] args) {
ComputerFactory computerFactory = new MacFactory();
Computer computer = computerFactory.creatComputer();
buyComputer(computer);
}
}

三丶抽象工厂模式
如果要用不同的操作系统比如：苹果系统和windows 8两种系统，就需要用抽象工厂模式。
需要新增创建系统的方法，然后由实例工厂去实现。

新增一个接口：
操作系统类

public interface operatingSystem {

void printSystem();
}

工厂新增两个重写方法：
1丶

public class MacFactory implements ComputerFactory{

public Computer creatComputer(){

return new MacComputer();
}

@Override
public operatingSystem creatSystem() {
return new MacSystem();

}

}

2丶

public class MiFactory implements ComputerFactory{

public Computer creatComputer(){

return new MiComputer();
}

@Override
public operatingSystem creatSystem() {
return new Windows8System();

}

}

新增两个系统：
1丶window8系统：

class Windows8System implements operatingSystem{

@Override
public void printSystem() {
System.out.println("这是windows8系统");
}
}

2丶苹果系统：

public class MacSystem implements operatingSystem {
@Override
public void printSystem() {
System.out.println("这是苹果系统");
}
}

客户类：

public class KeHu {
public static void buyComputer(Computer computer){
computer.printComputer();
}

public static void Use(operatingSystem operatingSystem) {
operatingSystem.printSystem();

}

public static void main(String[] args) {
ComputerFactory computerFactory = new MiFactory();
ComputerFactory computerFactory1 = new MacFactory();
Computer computer = computerFactory.creatComputer();
Computer computer1 = computerFactory1.creatComputer();
operatingSystem  operatingSystem= computerFactory.creatSystem();
operatingSystem operatingSystem1= computerFactory1.creatSystem();
buyComputer(computer);
Use( operatingSystem);
buyComputer(computer1);
Use( operatingSystem1);

}

}

代理设计模式
两个子类共同实现一个接口，其中一个子类负责真实业务实现，另外一个子类完成辅助真实业务主题的操作

package com.bit.src;

public interface ISubject {
void buyComputer();
}

public class RealSubject implements ISubject{

@Override
public void buyComputer() {
System.out.println("2,购买电脑");
}
}

public class DaiLISubject implements ISubject {
private RealSubject realSubject;//真实的业务
public DaiLISubject(RealSubject realSubject){
this.realSubject=realSubject;
}
public void produceComputer(){
System.out.println("1,生产电脑");
}
public void afterSale(){
System.out.println("3,售后服务");
}
@Override
public void buyComputer() {
this.produceComputer();//真是操作前准备
this.realSubject.buyComputer();//调用代理业务
this.afterSale();//操作后结尾
}
}

public class Client {
public static void main(String[] args) {
RealSubject realSubject=new RealSubject();
DaiLISubject daiLISubject=new DaiLISubject(realSubject);
daiLISubject.buyComputer();

}

抽象类与接口的区别

1丶结构组成：
抽象类：普通类+抽象方法
接口：抽象方法+全局变量
2丶权限：
抽象类：各种权限
接口：public
3丶子类使用：
抽象类：使用extends关键字继承抽象类
接口：使用implements关键字实现接口
4丶关系：
抽象类：一个抽象类可以实现若干接口
接口：接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
5丶子类限制：
抽象类：一个子类只能继承一个抽象类
接口：一个子类可以实现多个接口