理解每种设计模式的思想,以及使用场景.

设计模式就是基于面向对象,对一类具备相同特性的问题,总结出的处理方式;

面向对象七大原则:

1.开闭原则(OCP):对扩展开放,对修改关闭;

2.里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立;

3.依赖导致原则:要面向接口编程,不要面向实现编程;

4.单一职责原则:一个方法只做一件事,解耦合,提升内聚

5.接口隔离原则:各个类需要专用接口

6.迪米特法则:只与朋友交谈

7.合成复用原则:能组合尽量用组合;has A ,继承.is A

一.工厂模式

作用:实现了创建者和调用者分离

核心本质:实例化对象不用new ,统一管理控制创建对象,实现创建对象的过程与调用者解耦;

public interface Car {
    void name();
}

public class CarFactory {
    //静态工厂模式
    //方法一(没有满足开闭原则,当添加车种类时需要修改Factory)
    public static Car getCar(String carName){
        if(carName.equals("五菱宏光")){
            return new WuLing();
        }else if(carName.equals("奔驰")){
            return new BenChi();
        }else{
            return null;
        }
    }
    public static Car getWuLing(){
        return new WuLing();
    }
    public static Car getBenChi(){
        return new BenChi();
    }

}

工厂方法:

public interface FactoryCar {
    Car getCar();
}

//工厂方法
public class WulingFactory implements FactoryCar{
    @Override
    public Car getCar() {
        return new WuLing();
    }

    public static void main(String[] args) {
        Car car = new WulingFactory().getCar();
        car.name();
    }
}

对比:结构复杂度:简单工厂

　　代码复杂度:简单工厂

　　编程复杂度:简单工厂

　　管理上的复杂度:简单工厂

　　//根据设计原则:工厂方法;

　　//实际业务:简单工厂;

抽象工厂模式:

当需要生产的产品比较复杂,时将工厂变成接口,构建他的实现类

例如:不同的厂商,回生产很多不同的产品;用工厂控制不同的厂商,接口内的方法控制产品种类

 

二.建造者模式

将对象的构建 和使用分离,使用者不用考虑对象的创建过程;

指挥者,负责管理建造流程;

建造者:负责具体的创建;

三.原型模式

clone()

 

 

结构型模式

从程序结构上实现松耦合,从而可以扩大整体的类结构,用来解决更大的问题;

一.适配器模式

//1.继承被适配的类(属于类适配器)
//2.组合被适配的对象(对象适配器)
public class AdapterImpl extends Adapter implements NetToUsb{
    @Override
    public void requestHander() {
        super.request();
    }
    public static void main(String[] args) {
        AdapterImpl adapterInst = new AdapterImpl();
        Computer computer = new Computer(adapterInst);
        computer.net();
    }
}

//要被适配的类:网线
public class Adapter {
    public void request(){
        System.out.println("连接网线上网");
    }

}

//不能直接连接网线的电脑
public class Computer {
    NetToUsb abapter;

    public Computer(NetToUsb abapter) {
        this.abapter = abapter;
    }

    public void net(){
        abapter.requestHander();
    }
}

//抽象的转换器
public interface NetToUsb {
    void requestHander();
}

-

public class PingGou implements brand{
    @Override
    public void info() {
        System.out.print("苹果");
    }
}

 

 

 二.桥接模式

将抽象部分与它的实现部分分离,是他们都可以独立的变化.

抽象 好比品牌  实现好比品牌;

一个类有两个不维度的特性; 

public class Ts extends Computer {
    public Ts(brand b) {
        super(b);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("台式");
    }
    public static void main(String[] args) {
        LianXiang lianXiang = new LianXiang();
        Ts ts = new Ts(lianXiang);
        ts.info();
    }
}

public class LianXiang implements brand{
    @Override
    public void info() {
        System.out.print("联想");
    }
}

public abstract class Computer {
    protected brand b;

    public Computer(brand b) {
        this.b = b;
    }
    public void info(){
        b.info();
    };
}

public interface brand {
    void info();
}

public class Bjb extends Computer{
    public Bjb(brand b) {
        super(b);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("笔记本");
    }
}