Java设计模式

设计模式

装饰者模式

:在原有的基础上动态的添加新的功能,是在对象层面实现功能扩展,而不是继承的层面.

// 一个机器人
interface robot {
    void doSomething();
}
//原有的功能
class Robot implements robot {
    @Override
    public void doSomething() {
        System.out.println("dosomething");
    }
}
//在原有的功能上进行动态的扩展
//定义成抽象的更加灵活
abstract class RobotDecorator implements robot {
    //需要关联 原有的功能
    private Robot robot;
     public RobotDecorator(Robot robot) {
         this.robot = robot;
     }
     @Override
    public void doSomething() {
        robot.doSomething();
    }
        //动态的扩展
    public void moreSomething(){
        System.out.println("more");
    }
}

适配器模式

：是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式

主要解决 ：原本接口不匹配而无法工作的两个类能够在一起工作

public class Test {
    public static void main(String[] args) {
        System.out.println(new Adapter(new Speaker()).translate());
    }
}

class Speaker {
    public String speak() {
        return "演讲";
    }
}
interface Translator {
    String translate();
}

//Adapter属于是桥梁 将speak 和 translate 放在一起工作
class Adapter implements Translator {
    private Speaker speaker;
    public Adapter(Speaker speaker) {
        this.speaker = speaker;
    }
    @Override
    public String translate() {
        String translate = "翻译"
        String speak = speaker.speak();
        return  speak+translate;
    }
}

观察者模式

:定义对象间的一种一对多依赖关系，当一个对象被修改时，则会自动通知依赖它的对象 观察者模式属于行为型模式。

class guanchazhe{
    public static void main(String[] args) {
        poor p = new poor();
        rich r = new rich();
        p.borrow(r);
        p.notifyCreditor();
    }
}

//举个例子 类似与一份合同，想要借钱就要实现这个合同。
interface Debit{
    void borrow (Creditor creditor);
    void notifyCreditor();
}
interface Creditor {
    void repay();
}
//穷人借钱 实现接口
class poor implements Debit{
    private List<Creditor> allCreditor = new ArrayList<>();
    //把每个债主记录一下
    @Override
    public void borrow(Creditor creditor) {
        allCreditor.add(creditor);
    }

    @Override
    public void notifyCreditor() {
        //通知每个债主还钱
        allCreditor.forEach(Creditor::repay);
    }
}
//富人借给穷人 实现接口
class rich implements Creditor{

    @Override
    public void repay() {
        System.out.println("rich");
    }
}

外观模式

：向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。

**主要解决：**降低访问复杂系统的内部子系统时的复杂度，简化客户端之间的接口。

class test{
    public static void main(String[] args) {
        Square square = new Square();
        Circle circle = new Circle();
        ShapeMaker  s = new ShapeMaker(square,circle);
        s.squareDraw();
        s.circleDraw();
    }
}

interface Shape{
    void draw();
}
 class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square::draw()");
    }
}
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}
//一个外观类
class ShapeMaker {
    private Square square;
    private Circle circle;

    public ShapeMaker(Square square, Circle circle) {
        this.square = square;
        this.circle = circle;
    }
    public void squareDraw(){
        square.draw();
    }
    public void circleDraw(){
        circle.draw();
    }
}

状态模式

类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。

//每一个类代表一种状态 会做出一种反应， 把一个类当成一种状态传递给Context类，Context类会去执行当前状态的方法
class waiguan{
    public static void main(String[] args) {
        Happy happy = new Happy();
        Context context = new Context(happy);
        context.doSomething();
    }
}
abstract class State {
    public abstract void doWork();
}
class Happy extends State {
    @Override
    public void doWork() {
        System.out.println("积极");
    }
}
class Sad extends State {
    @Override
    public void doWork() {
        System.out.println("难过懊恼");
    }
}
//状态类
class Context{
    //传递状态
    private State state;
    public Context(State state) {
        this.state = state;
    }
    public void doSomething (){
        state.doWork();
    }
}

代理模式

为其他对象提供一种代理以控制对这个对象的访问 这种类型的设计模式属于结构型模式。

//举个例子，员工需要找老板签字 但是不知道老板在哪儿，所以需要交给秘书，让秘书交给老板
class daili{
    public static void main(String[] args) {
        Boss realSubject = new Boss();
        Proxy p = new Proxy(realSubject);
        p.doSomething();
    }
}
//目标类接口
interface Subject{
    void doSomething ();
}
//老板
class Boss implements  Subject{
    @Override
    public void doSomething() {
        System.out.println("老板处理文件");
    }
}
//代理类  秘书
class Proxy implements Subject{
//  和老板建立关系
    private Boss boss;
    public Proxy(Boss realSubject) {
        this.boss = realSubject;
    }
    public void connect(){
        System.out.println("秘书找老板");
    }
    @Override
    public void doSomething() {
        connect();
        boss.doSomething();
    }
}

责任链模式

是一种处理请求的模式，为请求创建了一个接收者对象的链，处理不了给下一个处理者处理。这种类型的设计模式属于行为型模式。

举个例子，类似于请假，需要一级一级的向上审批

class zerenlian{
    public static void main(String[] args) {
        Leader leader = new Leader();
        Boss boss = new Boss();
        leader.setNextHandler(bosss);
        leader.process(10);
    }
}
abstract class Handler {
    //当当前处理者处理不了的时候发送给下一个处理者
    protected Handler nextHandler;
    //定义下一个处理者是谁
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }
    //能处理哪些
    public abstract void process(int i);
}
class Leader extends Handler {
    @Override
    public void process(int i) {
        if (i < 5) {
            System.out.println("leader 处理");
        } else {
            //发送给下一个处理者
            nextHandler.process(i);
        }
    }
}
class Boss extends Handler {
    @Override
    public void process(int i) {
        System.out.println("boss处理");
    }
}

模板模式

一个抽象类公开定义了执行它的方法的方式

子类不可以改变一个算法中的结构，但是可以重新定义该算法中的某些特定步骤 。这种类型的设计模式属于行为型模式。主要作用还是代码复用。

class moban{
    public static void main(String[] args) {
        LOL l = new LOL();
        l.play();
    }
}

abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
    //模板
    public final void play() {
        //初始化游戏
        initialize();
        //开始游戏
        startPlay();
        //结束游戏
        endPlay();
    }
}
//重新定义GAME中的某些特定步骤
class LOL extends Game {
    @Override
    void initialize() {
        System.out.println("LOL初始化");
    }
    @Override
    void startPlay() {
        System.out.println("LOL开始");
    }
    @Override
    void endPlay() {
        System.out.println("LOL结束");
    }
}
class DNF extends Game{
    @Override
    void initialize() {
        System.out.println("DNF初始化");
    }
    @Override
    void startPlay() {
        System.out.println("DNF开始");
    }
    @Override
    void endPlay() {
        System.out.println("DNF结束");
    }
}

-----推荐个B站UP主 子烁爱学习