23种设计模式

*********简单工厂模式*******

我们设计或者写出来的代码，要容易维护、容易扩展、并且容易复用

值需要改正要改的地方，这叫做可维护

以后出现类似的情况还可以用这一段代码，就叫做可复用

如若要添加其他东西，添加就好了，这叫做可扩展

要是能够随便移动项目中代码的位置，这叫做灵活性好

比如说写一个计算器的代码，就最好将业务层和界面进行分离，

**************策略模式*******************

案例：商场收银软件

对于算法经常变动的项目一般情况下建议使用。

 

*************单一职责原则***********************

就一个类而言，应该仅有一个引起他变化的原因。

*************开放封闭原则*********************

通俗的话讲，就是做两手准备

软件实体应该可以扩展，但是不能够进行修改。

***********************装饰模式 *********************

*******************代理模式***********************

 

迭代器设计模式：

创建容器

package com.bjsxt.dp.iterator;
import com.bjsxt.dp.iterator.Collection;

public class ArrayList implements Collection {
    // 创建一个对象的的数组，这样就能够放入任意类型的对象了
    Object[] objects = new Object[10];
    int index = 0;

    public void add(Object o) {
        //这样只要在自己内存允许的情况下，就可以 无限制的添加了
        if(index==objects.length){
            Object[] newObjects=new Object[objects.length*2];
            //将原来的数组存放到新数组中
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
           //将原来数组的引用指向新的数组
            objects=newObjects;
            
        }
        objects[index] = o;// 表示新加进来的对象
        index++;

    }
    //看看最后装了 多少个
    public int size(){
        return index;
    }
    
    public Iterator iterator(){
        
        
        
        return new ArrayListIterator();//现在不要官具体是怎样实现的
        
    }
//使用内部类的方式
    private class ArrayListIterator implements Iterator{
        private int currentIndex=0;
    @Override
    public Object next() {
        
        Object o= objects[currentIndex];
        currentIndex++;
        return o;
    
    }

    @Override
    public boolean hasNext() {
        
        if (currentIndex>=index) {
            return false;
            
        }else{
            return true;
        }
    }
        
    }

}

package com.bjsxt.dp.iterator;

public class Cat {
    private int id;

    public Cat() {
        super();
    }

    public Cat(int id) {
        super();
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Cat [id=" + id + "]";
    }

}

package com.bjsxt.dp.iterator;

//集合类中的顶级父类
public interface Collection {
    public void add(Object o);
    public int size();
    public  Iterator iterator();//定义这样的遍历接口
}

package com.bjsxt.dp.iterator;
//所有的容器提供一种统一的遍历方式
public interface Iterator {
    public  Object next();
    boolean hasNext();

}

package com.bjsxt.dp.iterator;
import com.bjsxt.dp.iterator.Collection;
//使用链表方式的容器
public class LinkedList implements Collection{
    Node head = null;
    Node tail = null;
    int size = 0;

    public void add(Object o) {
        Node n = new Node(o, null);
        if (head == null) {
            head = n;
            tail=n;
        }
        tail.setNext(n);
        tail=n;
        size++;
    }

    public int size() {
        return size;
    }

    @Override
    public Iterator iterator() {
        // TODO Auto-generated method stub
        return null;
    }
}

package com.bjsxt.dp.iterator;

//节点类
public class Node {
    private Object data;// 数据本身
    private Node next;// 那只拉住下一个节点的小手

    public Node() {
        super();
    }

    public Node(Object data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

}

package com.bjsxt.dp.iterator;

//注意这里我们引用自己定义的Arraylist类，而不是使用jdk自带的arraylist类
//这个容器比数组好用
import org.junit.Test;

import com.bjsxt.dp.iterator.ArrayList;;

public class TestMethod {
    @Test
    public void test01() {
        ArrayList al = new ArrayList();
        for (int i = 0; i < 15; i++) {
            al.add(new Cat(i));
        }
        System.out.println(al.size());
    }
    @Test
    public void test02() {
        LinkedList al = new LinkedList();
        for (int i = 0; i < 15; i++) {
            al.add(new Cat(i));
        }
        System.out.println(al.size());
    }
    @Test
    public void test03() {
        Collection al = new ArrayList();//这就是考虑到了容器的可替换性，面向接口编程
        for (int i = 0; i < 15; i++) {
            al.add(new Cat(i));
        }
        System.out.println(al.size());
        //容器的遍历
        Iterator it=al.iterator();
        while(it.hasNext()){
            Object o=it.next();
            System.out.println(o+"++");
        }
    }

}

package com.bjsxt.dp.iterator.generic;

import com.bjsxt.dp.iterator.ArrayList;

//支持泛型的
public class GenericArrayList<E> {//其中E表示的是具体的类型
    // 创建一个对象的的数组，这样就能够放入任意类型的对象了
        Object[] objects = new Object[10];
        int index = 0;

        public void add(E o) {
            //这样只要在自己内存允许的情况下，就可以 无限制的添加了
            if(index==objects.length){
                Object[] newObjects=new Object[objects.length*2];
                //将原来的数组存放到新数组中
                System.arraycopy(objects, 0, newObjects, 0, objects.length);
               //将原来数组的引用指向新的数组
                objects=newObjects;
                
            }
            objects[index] = o;// 表示新加进来的对象
            index++;

        }
        //看看最后装了 多少个
        public int size(){
            return index;
        }
        
        //测试方法
        public static void main(String[] args) {
            GenericArrayList<String> list=new GenericArrayList<>();
            list.add("aaa");
            list.add("bbb");
            /*for (int i = 0; i <list.size(); i++) {
                System.out.println("现在输出的是："+list.get(i));
                  system.out.println(list.get(i));
                
            }*///这种方式是遍历不出来的
        /*    for(String item:list){
                System.out.println(item);
            }*///这种方式是遍历不出来的
        }

}

 

变量私有的叫做字段，公有的叫做属性

使用protected修饰的成员对子类公开，对其他的类是不公开的

继承是有缺点的，父类变动，子类也得跟着做出相应的变动

同时，继承会破环包装，父类的实现细节暴漏给子类，这其实大大增加 两者之间的耦合性。

一个类是另外一个  类的特殊类

抽象方法没有方法体，抽象类中是可以有普通方法的

 

*******************桥接模式***********************

注意父类引用指向子类的具体实现，是在继承的情况下完成的

在子类向父类进行扩展的时候，有两个纬度上面的扩展，一个是具体类型的，另外一个是抽象类型上面的。

两个纬度之间会有交叉

在设计的时候一定要谨慎的使用继承

使用桥接模式：在两个维度进行排列组合

聚合就是一个类中有对其他类的引用

package com.bjsxt.dp.brige;
//桥接模式    男孩类型
public class Boy {
    private String name;
//MM mm;区别：这样写其实是让两者的关系变得更加的紧密了，但是处于java设计中，高内聚，低耦合的思想，建议两者之间还是保持一定的距离比较好
    
    public Boy() {
        super();
    }

    public Boy(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MM [name=" + name + "]";
    }
    //添加追的方法
    public   void    pursue(MM mm){
    Gift warmGift = new WarmGift(new Flower());//用到的多态
        give(warmGift, mm);
    }
    //送礼物的方法
    public  void   give(Gift gift,MM mm){
        
    }
    

}

package com.bjsxt.dp.brige;
//鲜花类
public class Flower extends GiftImpl {

}

package com.bjsxt.dp.brige;
//礼物类 
public class Gift {
 protected GiftImpl impl;//这是一种聚合的手段
//下面的set和get方法写不写都是可以的

public GiftImpl getImpl() {
    return impl;
}

public void setImpl(GiftImpl impl) {
    this.impl = impl;
}

}

package com.bjsxt.dp.brige;

//礼物的实现类
public class GiftImpl {

}

package com.bjsxt.dp.brige;
//桥接模式    美眉类
public class MM {
    private String name;

    public MM() {
        super();
    }

    public MM(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "MM [name=" + name + "]";
    }
    
    

}

package com.bjsxt.dp.brige;
//钻戒类
public class Ring extends GiftImpl {

}

package com.bjsxt.dp.brige;

public class Test {
public static void main(String[] args) {
    Boy boy=new Boy("小名");
        boy.give(new Gift(), new MM("小美"));
    
}
}


package com.bjsxt.dp.brige;
//追温柔类型的女孩用温柔类型的礼物
public class WarmGift extends Gift{
public   WarmGift(Flower flower){
        this.impl = impl;
    
}
}

package com.bjsxt.dp.brige;
//追狂野类型的女孩，用狂野类型的礼物
public class WildGift extends Gift{

}

**************适配器模式****************

比方说：类似与以前学过的变压器。

经典的面试题：java。io包中用到了什么设计模式：适配器模式    将inputstream转换成reader

 *************命令模式*********************

package com.bjsxt.dp.command;

import java.util.ArrayList;
import java.util.List;

public class Boy {
    private String name;
    private List<Command> commands=new ArrayList<Command>();

    public List<Command> getCommands() {
        return commands;
    }

    public void setCommands(List<Command> commands) {
        this.commands = commands;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 添加追的方法
    public void pursue(MM mm) {
        //Gift warmGift = new WarmGift(new Flower());// 用到的多态
        //give(warmGift, mm);
    }
   //美眉发布命令，男孩去做
    public void doSomeThing() {
        // TODO Auto-generated method stub
        Command command=new HugCommand();
        
    }
    public     void addCommand(Command c1){
        this.commands.add(c1);
    }

    public void excuteCommands() {
        for(Command item:commands){
            item.excute();
        }
        
    }
    public void undoCommand(){
        /*这里没有代码的实现，具体的思路是，要先将之前的所有操作保存到list集合中，
        然后通过遍历，先删除最近一次的操作，然后在删除第一次的操作就可以了*/
        
    }

}

package com.bjsxt.dp.command;
//在原来的23种设计模式中，command模式最主要是来实现undo的功能
public abstract class Command {
    public abstract void  excute();
    public abstract void  unDo();

}

package com.bjsxt.dp.command;

public class HugCommand extends Command{

    public void excute() {
        // TODO Auto-generated method stub
        System.out.println("拥抱");
    }

    public void unDo() {
        System.out.println("不拥抱");
        // TODO Auto-generated method stub
        
    }

}

package com.bjsxt.dp.command;

public class MM {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //命令方法
    public void order(Boy boy){
        Command c1=new ShoppingCommand();
        
        c1=new HugCommand();
        Command c2=new ShoppingCommand();
        c2=new ShoppingCommand();
        //赶紧让他去执行
        boy.excuteCommands();
    }
}

package com.bjsxt.dp.command;

public class ShoppingCommand extends Command {
//子类继承父类的时候，一定要实现父类中的所有的抽象方法
    public void excute() {
        System.out.println("去动物园");
        
    }

    public void unDo() {
        System.out.println("不去动物园");
        // TODO Auto-generated method stub
        
    }

}

****************状态模式**************

 java重构：指程序员对已有程序在尽量不改变接口的前提下，进行重新编写代码的工作，一般有以下几方面：
1、去除已知bug。
2、提高程序运行效率。
3、增加新的功能

package com.bjsxt.dp.state;

import java.util.ArrayList;
import java.util.List;

public class Boy {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


}


package com.bjsxt.dp.state;
//其实这就是简单状态下的多态的运用
public class MM {
    private String name;
    private MMState mmState = new MMHappyState();// 这是自己决定的

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 现在的女孩是一种善变的动物 在不同的条件下，这三种状态所表现出来的样子是不一样的
    public void smile() {
        mmState.smile();
    }

    public void cry() {
        mmState.cry();
    }

    public void saySomething() {
        mmState.saySomething();
    }

}


package com.bjsxt.dp.state;

//这是 在快乐的状态下面
public class MMHappyState extends MMState {

    @Override
    public void smile() {
        System.out.println("快乐的笑");

    }

    @Override
    public void cry() {
        System.out.println("快乐的哭");
    }

    @Override
    public void saySomething() {
        System.out.println("快乐的做事情");
    }

}


package com.bjsxt.dp.state;
//这是在悲伤的情况下
public class MMSadState extends MMState {

    @Override
    public void smile() {
        System.out.println("悲伤的笑");
    
        
    }

    @Override
    public void cry() {
        System.out.println("悲伤的哭");        
    }

    @Override
    public void saySomething() {
        System.out.println("悲伤的做事情");
        
    }

}

package com.bjsxt.dp.state;

//美美的状态
public abstract class MMState {
    public abstract void smile();

    public abstract void cry();

    public abstract void saySomething();
}

**************中介者模式 *******************

这种设计模式指的是当有-一堆对象，彼此之间的关系又错综复杂，而你又理不清楚，这时候，我们可以设计一个中间者，让所有的对象都不要和其他对象产生联系，先和这个中间者产生关系。

*************Facade(外观模式)*************

这个facade是是处理各个对象之间错综复杂关系的，用户在处理这些对象之间的关系的时候，只需要访问这个facade就可以了

 

 ******************动态代理**************

聚合要比继承好

让传接口，可以传她的实现类

 

 

****************工厂模式 *******************

简单工厂模式：

package com.bjsxt.dp.factory;

//飞天扫帚
public class Broom implements Moveable {

    @Override
    public void run() {
        System.out.println("骑着扫帚飞");
    }

}


package com.bjsxt.dp.factory;
//生产汽车的工厂
public class BroomFactory extends VehicleFactory {
public Broom createCar(){
    return new Broom();
}

@Override
public Moveable create() {
    // TODO Auto-generated method stub
    return new Broom();
}
}

package com.bjsxt.dp.factory;

import java.util.ArrayList;
import java.util.List;

//工厂模式
//车类
public class Car implements Moveable{
//    private Car(){} 将构造方法编程私有的，在测试类中就不能够new car（） 了
    public Car(){}
    private static Car car=new Car();//单例模式
    //有人把这种模式叫做多例模式
    private static List<Car> cars=new ArrayList<Car>();//当你需要其中的某一辆车的时候，直接拿一辆出来就行了，
    //这种方法Car类就能够控制自己的产生了
    public  static Car getInstance(){//静态工厂方法
        return car;
    }
public void run(){
    System.out.println("汽车正在冒着烟奔跑中》》》");
}
}

package com.bjsxt.dp.factory;
//生产汽车的工厂
public class CarFactory extends VehicleFactory {
public Car createCar(){
    return new Car();
}

@Override
public Moveable create() {
    // TODO Auto-generated method stub
    return new Car();
}
}

package com.bjsxt.dp.factory;

public interface Moveable {
    public void run();

}


package com.bjsxt.dp.factory;

public class Plane implements Moveable {

    @Override
    public void run() {
        System.out.println("飞机正在展翅飞翔");
    }

}

package com.bjsxt.dp.factory;
//生产飞机的工厂
public class PlaneFactory extends VehicleFactory{
public Plane createPlane(){
    return new Plane();
}

@Override
public Moveable create() {
    // TODO Auto-generated method stub
    return new Plane();
}
}


package com.bjsxt.dp.factory;

public class Test {
    public static void main(String[] args) {
        /*Car car = Car.getInstance();
        Car car2 = Car.getInstance();
        if (car == car2) {
            System.out.println("这是同一辆车");

        }
        car.run();*/
        
        /*Moveable ma=new Plane();
        ma.run();*/
        
        //通过工厂产生具体的飞机
        /*PlaneFactory pf=new PlaneFactory();
        Plane plane = pf.createPlane();
        plane.run();*/
        
        //使用工厂的方式
        /*VehicleFactory factory=new PlaneFactory();
        Moveable feiji = factory.create();
        feiji.run();*/
        
        VehicleFactory factory=new BroomFactory();
        Moveable feiji = factory.create();
        feiji.run();
    }
}

package com.bjsxt.dp.factory;
//生产交通工具的工厂
public abstract class VehicleFactory {
    public abstract Moveable create();

}