设计模式样例

以下为自用模板代码，没有很好的注释，可以用于记忆

FactoryMethod

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Car {
    private String carName;
    private int carPrice;

}

public class AudiCar extends Car{

}

public class BusCar extends Car{

}

public interface CarFactory {

    public abstract Car createCar();

}

public class BusCarFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new BusCar();
    }
}

public class AudiCarFactory implements CarFactory{

    @Override
    public Car createCar() {
        return new AudiCar();
    }
}

@Slf4j
public class Client {

    @Test
    public void test(){
        BusCarFactory busCarFactory = new BusCarFactory();
        BusCar bus = (BusCar) busCarFactory.createCar();
        bus.setCarName("我的大巴车");
        bus.setCarPrice(1000);
    }

}

AbstractFactory

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Phone {

    private String name;
    private int price;

}

public class HuaweiPhone extends Phone{

}

public class XiaomiPhone extends Phone{

}

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class Watch {

    private String name;
    private String price;

}

public class HuaweiWatch extends Watch{

}

public class XiaomiWatch extends Watch{

}

public interface Factory {

    public Phone createPhone();

    public Watch createWatch();

}

public class HuaweiFactory implements Factory{
    @Override
    public Phone createPhone() {
        return new HuaweiPhone();
    }

    @Override
    public Watch createWatch() {
        return new HuaweiWatch();
    }
}

public class XiaomiFactory implements Factory{
    @Override
    public Phone createPhone() {
        return new XiaomiPhone();
    }

    @Override
    public Watch createWatch() {
        return new XiaomiWatch();
    }
}

public class main {

    @Test
    public void test(){
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        Phone huaweiPhone = huaweiFactory.createPhone();
        Phone xiaomiPhone = xiaomiFactory.createPhone();
        Watch huaweiWatch = huaweiFactory.createWatch();
        Watch xiaomiWatch = xiaomiFactory.createWatch();
    }

}

Adapter

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Computer {

    private String name;
    private int count;

}

public abstract class Adapter {

    private Adaptee adaptee;

    public abstract void computerConnect(String name);

}

public class USBAdapter extends Adapter{

    private Adaptee adaptee;

    public USBAdapter(Adaptee adaptee){
        this.adaptee = adaptee;
    }

    public void computerConnect(String name){
        adaptee.Connect(name);
    }

}

public class Adaptee {

    public void Connect(String name){
        System.out.println(name+"已连接");
    }

}

public class main {

    @Test
    public void test(){
        Computer computer = new Computer();
        computer.setName("天河一号");
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new USBAdapter(adaptee);
        adapter.computerConnect(computer.getName());

    }

}

Bridge

public interface sea {

    void log();

}

public class Atlantic implements sea{
    @Override
    public void log() {
        log.info("大西洋");
    }
}

public class Pacific implements sea{
    @Override
    public void log() {
        log.info("太平洋");
    }
}

//抽象沙滩类
public abstract class Beach {

    protected sea sea;

    public Beach(sea sea){
        this.sea = sea;
    }

    public void info(){
        sea.log();
    }

}

public class BeachOne extends Beach{
    public BeachOne(sea sea) {
        super(sea);
    }

    @Override
    public void info() {
        super.info();
        log.info("连接沙滩1");
    }
}

public class BeachTwo extends Beach{

    public BeachTwo(sea sea){
        super(sea);
    }

    @Override
    public void info(){
        super.info();
        log.info("连接着沙滩2");
    }

}

//和抽象工厂有点像，可先不看，这里举了沙滩和海洋的例子，有点抽象
public class main {

    @Test
    public void test(){
        Pacific pacific = new Pacific();
        Atlantic atlantic = new Atlantic();
        BeachOne beachOne = new BeachOne(pacific);
        BeachTwo beachTwo = new BeachTwo(atlantic);
        beachOne.info();
        beachTwo.info();

    }

}

Combination

//Final
public abstract class Component {

    protected String name;
    protected int level;

    //增删查
    public void add(Component component){
        throw new UnsupportedOperationException();
    }

    public void remove(Component component){
        throw new UnsupportedOperationException();
    }

    //获取指定子层级
    public Component getChild(int level){
        throw new UnsupportedOperationException();
    }

    //获取组件名称
    public String getName(){
        return name;
    }

    public abstract void printName();

}

public class Manger extends Component{

    private List<Component> list = new ArrayList<Component>();

    public Manger(String name,int level){
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(Component component) {
        list.add(component);
    }

    @Override
    public void remove(Component component) {
        list.remove(component);
    }

    @Override
    public Component getChild(int level) {
        return list.get(level);
    }

    @Override
    public String getName() {
        return super.getName();
    }

    @Override
    public void printName() {

        System.out.println(name);
        for (Component i: list) {
            i.printName();
        }

    }
}

public class Employee extends Component{

    public Employee(String name,int level){
        this.name = name;
        this.level = level;
    }

    @Override
    public void printName() {
        System.out.println(name);
    }
}

public class main {
    @Test
    public void test(){
        Manger manger1 = new Manger("管理员1", 1);
        manger1.add(new Employee("员工1",2));
        manger1.add(new Employee("员工2",2));
        manger1.add(new Employee("员工3",2));
        Manger manger2 = new Manger("管理员2", 1);
        Manger manger3 = new Manger("管理员3", 1);

        manger1.printName();

    }
}

Comand

public interface Receiver {

    public void action1();
    public void action2();

}

public class TV implements Receiver{

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

    public void action2(){
        System.out.println("action2");
    }

}

public abstract class Command {

    public Receiver receiver;

    public Command(Receiver receiver){
        this.receiver = receiver;
    }

    public void execute(){
        System.out.println("已执行命令");
    }

}

public class Command1 extends Command{
    // private Receiver receiver;
    public Command1(Receiver receiver) {
        super(receiver);
        // this.receiver = receiver;
    }

    @Override
    public void execute() {
        receiver.action1();
        super.execute();
    }
}

public class Command2 extends Command{

    public Command2(Receiver receiver) {
        super(receiver);
    }

    @Override
    public void execute() {
        receiver.action2();
        super.execute();
    }
}

public class main {

    @Test
    public void test(){
        TV tv = new TV();
        Command1 command1 = new Command1(tv);
        command1.execute();
        Command2 command2 = new Command2(tv);
        command2.execute();
    }

}

Iterator

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Fruit {

    private String name;
    private int No;

}

public interface FruitIterator {

    boolean hasNext();

    Fruit next();

}

public class FruitIteratorImpl implements FruitIterator{

    private List<Fruit> list;
    private int position = 0;   //记录位置

    public FruitIteratorImpl(List list){
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return position < list.size();
    }

    @Override
    public Fruit next() {
        //获取指定位置元素
        Fruit fruit = list.get(position);
        position++;
        return fruit;
    }
}

public interface FruitAggregate {

    //增删
    void addFruit(Fruit fruit);

    void deleteFruit(Fruit fruit);

    //获取迭代器
    FruitIterator getFruitIterator();

}

public class FruitAggregateImpl implements FruitAggregate{

    private List<Fruit> list = new ArrayList<Fruit>();

    @Override
    public void addFruit(Fruit fruit) {
        list.add(fruit);
    }

    @Override
    public void deleteFruit(Fruit fruit) {
        list.remove(fruit);
    }

    @Override
    public FruitIterator getFruitIterator() {
        return new FruitIteratorImpl(list);
    }
}

public class main {

    @Test
    public void main(){
        FruitAggregateImpl fruitAggregate = new FruitAggregateImpl();
        Fruit fruit1 = new Fruit("水果1号", 12);
        Fruit fruit2 = new Fruit("水果2号", 24);
        Fruit fruit3 = new Fruit("水果3号", 50);

        fruitAggregate.addFruit(fruit1);
        fruitAggregate.addFruit(fruit2);
        fruitAggregate.addFruit(fruit3);
        FruitIterator fruitIterator = fruitAggregate.getFruitIterator();
        while (fruitIterator.hasNext()){
            Fruit fruit = fruitIterator.next();
            fruit.toString();
        }

    }

}

Listener

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private String name;
    private int age;
    private Double salary;

}

public interface PersonFactory {
    public Person createPerson();
}

public interface Observer {

    void update();
    void increase();

}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Boss implements Observer{

    private String name;

    @Override
    public void update() {
        System.out.println("员工增加了");
    }

    @Override
    public void increase() {
        System.out.println("员工工资增加了");
    }
}

public class AddPerson extends Boss implements PersonFactory{

    @Override
    public Person createPerson() {
        super.update();
        return new Person();
    }
}

public class SalaryIncrease extends Boss{

    private Person person;

    public SalaryIncrease(Person person){
        this.person = person;
    }

    public void increase(Double salary){
        System.out.print(person.getName());super.increase();
        person.setSalary(person.getSalary()+salary);
    }

}

public class main {

    @Test
    public void test(){
        Boss boss = new Boss("马化腾");
        AddPerson addPerson = new AddPerson();
        Person person = addPerson.createPerson();
        person.setName("麻花藤");
        person.setSalary(1000000.0);
        SalaryIncrease salaryIncrease = new SalaryIncrease(person);
        salaryIncrease.increase(1000.0);
    }

}

Strategy

public abstract class Strategy {

    public abstract String  strategy();

}

public class StrategyOne extends Strategy{
    @Override
    public String strategy() {
        return "策略一";
    }
}

public class StrategyTwo extends Strategy{
    @Override
    public String strategy() {
        return "StrategyTwo";
    }
}

public class Person {

    private Strategy strategy;

    public Person(Strategy strategy){
        this.strategy = strategy;
    }

    public String  doSth(){
        return strategy.strategy();
    }

}

public class main {

    @Test
    public void test(){
        Strategy strategyOne = new StrategyOne();
        Person person = new Person(strategyOne);
        log.info(""+person.doSth());
    }

}

Decorate

public abstract class Base {
    public abstract void test();
}

public class BaseImpl extends Base{

    @Override
    public void test() {
        System.out.println("我是业务方法");
    }
}

public abstract class Decorate extends Base{

    protected Base base;

    protected Decorate(Base base){
        this.base = base;
    }

    public void test(){
        base.test();
    }

}

public class DecorateImpl extends Decorate{

    protected DecorateImpl(Base base) {
        super(base);
    }

    @Override
    public void test() {
        super.test();
        System.out.println("装饰方法");
    }
}

public class main {

    @Test
    public void test(){
        BaseImpl base = new BaseImpl();
        DecorateImpl decorate = new DecorateImpl(base);
        decorate.test();
    }

}

Builder

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {

    private String name;
    private int age;
    private int gender;
    private String grade;
    private String college;
    private List<String> awards;

}

public abstract class StudentBuilder {

    protected Student student;

    public StudentBuilder(){
        this.student = new Student();
    }

    public Student getStu(){
        return student;
    }

    public abstract void buildName(String name);
    public abstract void buildAge(int age);
    public abstract void buildGender(int gender);
    public abstract void buildGrade(String grade);
    public abstract void buildCollege(String college);
    public abstract void buildAwards(List<String> list);

}

public class StudentBuilderImpl extends StudentBuilder{

    @Override
    public void buildName(String name) {
        student.setName(name);
    }

    @Override
    public void buildAge(int age) {
        student.setAge(age);
    }

    @Override
    public void buildGender(int gender) {
        student.setGender(gender);
    }

    @Override
    public void buildGrade(String grade) {
        student.setGrade(grade);
    }

    @Override
    public void buildCollege(String college) {
        student.setCollege(college);
    }

    @Override
    public void buildAwards(List<String> list) {
        student.setAwards(list);
    }
}

public class StudentDirector {

    private StudentBuilder studentBuilder;

    public StudentDirector(StudentBuilder studentBuilder){
        this.studentBuilder = studentBuilder;
    }

    public void buildStu(){
        studentBuilder.buildName("张三");
        studentBuilder.buildGender(1);
        studentBuilder.buildCollege("摩洛哥");
        studentBuilder.buildGrade("大三");
        studentBuilder.buildAge(20);
    }

    public Student getStu(){
        return studentBuilder.getStu();
    }

}

@Slf4j
public class main {

    @Test
    public void main(){
        StudentBuilderImpl studentBuilder = new StudentBuilderImpl();
        StudentDirector studentDirector = new StudentDirector(studentBuilder);
        studentDirector.buildStu();
        Student stu = studentDirector.getStu();
        log.info(stu.toString());
    }

}