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

最新推荐文章于 2021-07-08 20:31:04 发布

Sandm_Wzm

最新推荐文章于 2021-07-08 20:31:04 发布

阅读量242

点赞数

文章标签：接口工厂设计模式抽象类与接口

本文链接：https://blog.csdn.net/Sandm_Wzm/article/details/89166170

版权

（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丶子类限制：
抽象类：一个子类只能继承一个抽象类
接口：一个子类可以实现多个接口