接口工厂设计模式代理设计模式

最新推荐文章于 2019-07-02 08:37:07 发布

这个手刹丿不太灵

最新推荐文章于 2019-07-02 08:37:07 发布

阅读量176

点赞数

本文链接：https://blog.csdn.net/h1346706115/article/details/89165312

版权

接口
接口就是抽象方法和全局常量的集合。
1、定义接口使用关键字interface 接口名称使用I表示
2、接口中的数据成员默认为 public static final
接口中的方法默认为 Public abstract
3、接口内不能有已经实现的方法。
4、接口不能实例化 IMessage imessage = new IMessage();
5、接口可以继承多个接口，此时的接口拥有了继承接口里面的抽象方法
6、如果一个抽象类的继承接口，那么抽象类当中可以不实现接口的方法
但是如果再有一个普通类继承了此抽象类，那么普通类一定要实现接口
定义接口
定义IMessage接口

public interface IMessage {
    String MSG="hello bit";
    void print();
}

定义INews接口

public interface INews {
    String getNews();
}

子类QQMessagelmp实现接口

5、接口可以继承多个接口，此时的接口拥有了继承接口里面的抽象方法
class QQMessagelmp implements IMessage ,INews{
    @Override
    public void print() {
        System.out.println("QQMessage");
    }

    @Override
    public String getNews() {
        return IMessage.MSG;
    }
}

测试类

public class TestDemo1 {
public static void main(String[] args) {
        IMessage iMessage=new QQMessagelmp();
        iMessage.print();

         INews iNews2=(INews)iMessage; //  INews类型 强转为 IMessage类型
        System.out.println(iNews2.getNews());

        IMessage qqMessagelmp=new QQMessagelmp();//子类向上转型，为父接口实例化对象
        qqMessagelmp.print();//调用被子类覆写过的方法

        INews iNews=new QQMessagelmp();
        //((QQMessagelmp) iNews).print();
        System.out.println(iNews.getNews());
}

简单工厂模式
简单工厂模式：专门定义一个类用来创建其它类的实例，被创建的实例通常都具有相同的父类。
1、一个抽象类产品
2、具体产品类
3、一个工厂
4、客户端
优点：简单易于实现
把类的实例化交给工厂，易于解耦
缺点：添加具体产品需要修改工厂违反OCP开放封闭原则
例如：创建生产电脑的工厂
Computer 接口 1、一个抽象类产品

package com.bit.src;

public interface Computer {
    void printComputer();
}

三种类型的电脑（子类） MacBookComputer 、SurfaceBookComputer、MIComputer
来实现Computer接口 2、具体产品类

package com.bit.src;

public class MacBookComputer implements Computer {

    @Override
    public void printComputer() {
        System.out.println("MacBook电脑");
    }
}
package com.bit.src;

public class SurfaceBookComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("SurfaceBook电脑");
    }
}
package com.bit.src;

public class MIComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("小米电脑");
    }
}

工厂类ComputerFactory 3、一个工厂

package com.bit.src;
把类的实例化交给工厂，易于解耦
public class ComeputerFactory {
    public static Computer getInstance(String type) {
        Computer computer = null;
        switch (type) {
            case "MAC":
                computer = new MacBookComputer();
                break;
            case "SUR":
                computer = new SurfaceBookComputer();
                break;
            case "MI":
                computer = new MIComputer();
                break;
                default:
                    System.out.println("请输入正确的电脑型号");
        }
        return computer;


    }
}

客户端类（Client)

package com.bit.src;

import java.util.Scanner;

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

    public static void main(String[] args) {
        System.out.println("请输入你要的电脑型号");
        Scanner scanner=new Scanner(System.in);
        String type=scanner.nextLine();
        buyComputer(ComeputerFactory.getInstance(type));
        }
}

工厂方法模式
工厂方法模式：定义一个用来创建对象的接口，让子类决定实例化哪一个类，让子类决定实例化延迟到子类
1、一个抽象产品类
2、多个具体产品类
3、一个抽象工厂
4、多个具体工厂-每一个具体产品对应一个具体工厂
优点
1、降低了代码耦合度，对象的⽣成交给子类去完成
实现了开放封闭原则 - 每次添加子产品不需要修改原有代码
缺点：
2、增加了代码量，每个具体产品都需要一个具体工⼚
当增加抽象产品也就是添加一个其他产品族需要修改⼯厂违背OCP
1、一个抽象产品类

package com.bit.src;

public interface Computer {
    void printComputer();
}

2、多个具体产品类

package com.bit.src;

public class MacBookComputer implements Computer {

    @Override
    public void printComputer() {
        System.out.println("MacBook电脑");
    }
}
package com.bit.src;

public class SurfaceBookComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("SurfaceBook电脑");
    }
}

3、一个抽象工厂

package com.bit.src;

public interface ComputerFactory {
        Computer createComputer();
}

4、多个具体工厂-每一个具体产品对应一个具体工厂

package com.bit.src;

public interface ComputerFactory {
        Computer createComputer();
}

5、客户端

package com.bit.src;


public class Client {

    public static void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static void main(String[] args) {
     ComputerFactory ComputerFactory=new AppleFactory();
     Computer computer=ComputerFactory.createComputer();
     buyComputer(computer);
    }
}

抽象工厂模式
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它的具体的类。
1、多个抽象产品类
2、具体产品类
3、抽象工厂类 - 声明（一组）返回抽象产品的方法
4、具体工厂类 - 生成（一组）具体产品
优点
代码解耦
实现多个产品族(相关联产品组成的家族)，而⼯⼚⽅法模式的单个产品,可以满足更多的生产需求
很好的满⾜足OCP开放封闭原则
抽象工厂模式中我们可以定义实现不⽌一个接口，⼀个工厂也可以⽣成不⽌一个产品类对于复杂对象的生产相当灵活易扩展
缺点：
扩展产品族相当麻烦而且扩展产品族会违反OCP,因为要修改所有的⼯⼚
由于抽象⼯⼚模式是⼯⼚方法模式的扩展总体的来说很笨重
1、多个抽象产品类

package com.bit.src;

public interface Computer {
    void printComputer();
}
package com.bit.src;

public interface OperatingSystem  {
    void printSystem();
}

2、具体产品类

package com.bit.src;

public class MacBookComputer implements Computer {

    @Override
    public void printComputer() {
        System.out.println("MacBook电脑");
    }
}
package com.bit.src;

public class SurfaceBookComputer implements Computer{
    @Override
    public void printComputer() {
        System.out.println("SurfaceBook电脑");
    }
}

3、抽象工厂类 - 声明（一组）返回抽象产品的方法

package com.bit.src;

   public interface OperatingSystem  {
    void printSystem();
}
package com.bit.src;

public class MacSystem implements OperatingSystem {
    @Override
    public void printSystem() {
        System.out.println("Mac电脑系统");
    }
}
package com.bit.src;

public class Windows10System implements OperatingSystem {
    @Override
    public void printSystem() {
        System.out.println("Windows10系统");
    }
}

4、具体工厂类 - 生成（一组）具体产品

package com.bit.src;

public interface ComputerFactory {
        Computer createComputer();
        OperatingSystem createSystem();
}
package com.bit.src;

public class AppleFactory implements ComputerFactory {
    @Override
    public Computer createComputer() {
        return new MacBookComputer();
    }

    @Override
    public OperatingSystem createSystem() {
        return new MacSystem();
    }
}
package com.bit.src;

public class MsFactory implements ComputerFactory {

    @Override
    public Computer createComputer() {
        return new SurfaceBookComputer();
    }

    @Override
    public OperatingSystem createSystem() {
        return new Windows10System();
    }
}

5、客户端

package com.bit.src;
public class Client {

    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 MsFactory();
        ComputerFactory computerFactory2=new AppleFactory();
        Computer computer=computerFactory.createComputer();
        Computer computer2=computerFactory2.createComputer();
        OperatingSystem operatingSystem=computerFactory.createSystem();
        OperatingSystem operatingSystem2=computerFactory2.createSystem();
        buyComputer(computer);
        Use(operatingSystem);
        buyComputer(computer2);
        Use(operatingSystem2);

    }

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

package com.bit.src;

public interface ISubject {
    void buyComputer();
}

package com.bit.src;

public class RealSubject implements ISubject{

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

package com.bit.src;

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();//操作后结尾
    }
}

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

    }

抽象类和接口的区别
区别一：结构组成
抽象类：普通方法+抽象方法

abstract class Person{
 public abstract void getPersonInfo();//抽象方法
}

接口：抽象方法+全局变量

public interface IMessage {
    String MSG="hello bit";
    void print();
}

区别二：权限不同
抽象类：各种权限
接口：public
区别三：子类的使用
抽象类：使用extends关键字继承象类
接口:使用implements关键字实现接口
区别四：关系
抽象类：一个抽象类可以实现若干接口

 abstract class QQMessagelmp implements IMessage ,INews{
 }

接口：接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口

public interface ISubject extends Computer {}

区别五：子类限制
抽象类：一个子类只能继承一个抽象类
接口：一个子类可以实现多接口

class QQMessagelmp implements IMessage ,INews,...{
}

这个手刹丿不太灵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
接口工厂设计模式代理设计模式

接口接口就是抽象方法和全局常量的集合。1、定义接口使用关键字interface 接口名称使用I表示2、接口中的数据成员默认为 public static final接口中的方法默认为 Public abstract3、接口内不能有已经实现的方法。4、接口不能实例化 IMessage imessage = new IMessage();5、接口可以继承多个接口，此时的接口拥...
复制链接

扫一扫