JAVA设计模式

一.单例模式

定义：虚拟机中这个类只有一个实例（一个对象）
单例模式的构造方法必须私有。

1.饿汉式

一开始就创建好实例

public class Singleton1{
      //让构造方法私有，别人就无法再创建此类的实例
     private Singleton1(){
  }
      //自己创建实例
     private static final Singleton1 ME=new Singleton1();
      //获取唯一实例
     public static Singleton1 getInstance(){
          return ME;
  }
}

2.懒汉式

用到时才创建，用不到不创建

public class Singletons{
      private Singleton2(){
     }
      private static Singleton2 ME;

      public static synchronized Singleton2 getInstance(){

  //当第一次调用时ME==null为真，当后续调用时ME ==null 为假，就不会执行创建对象的操作
            if(ME == null){
              ME=new Singleton2();
            }
           return ME;
       }
}

3.使用枚举类实现（属于饿汉式

public enum Singleton3{
     ME;
     public void m1(){
     }
}

4.静态内部类（属于懒汉式

public class Singleton4{
     private Singleton4(){
    }
    //holder  拥有，由静态内部类创建了它的唯一实例
     private static class Holder{
       static Singleton4 ME= new Singleton4();
    }
     public static Singleton4 getInstance() {
        return Holder.ME;
    }
}

 

 

 

破坏单例的方法：

反射可以调用私有构造

反序列化可以破坏单例（可以阻止）

二.享元模式

 

提倡重用已有的对象，而不是创建新的对象

比如Integer中的valueOf()方法

pubic static Integer valueOf(int i){
       if(i>=IntegerCache.low && i<=IntegerCache.high)
           return IntegerCache.cache[i+(-IntegerCache.low)];
       return new Integer(i)
}

享元范围-127~128

三.原型模式

根据已有的对象来创建新的对象，克隆

适合当对象属性很多，希望新对象的属性和已有对象的属性相同的情况

public class User implements Cloneable{
      private String name;
      private int age;

      @Override
      protected Object clone() throws CloneNotSupportedException {
       return super.clone();

  }

}

浅拷贝和深拷贝

浅拷贝仅复制地址，里面的内容不是全新的，上面的Cloneable实现的就是浅拷贝

深拷贝指所有的内容都是全新的

使用序列化流来进行深拷贝

protected Object clone() throw CloneNotSupportedException{
          //内存操作流
      ByteArrayOutputStream os=new ByteArrayOutputStream();
      try{
         //把自己写入输出流
          new ObjectOutputStream(os).writeObject(this);
          //获取字节数组
          byte[] bytes=os.toByteArray();
          //内存操作流
          ByteArrayInputStream is=new ByteArrayInputStream(bytes);
          //对象输入流
          ObjectInputStream ois=new ObjectInputStream(is);
          return ois.readObject();
         }catch(IOException e){
           e.printStackTrace();
         }catch(ClassNotFoundException e){
            e.printStackTrace();
         }

          return null;

}
   

四.建造器模式

使创建对象更加灵活，适合一步一步构建一个较为复杂的对象

public class Person{
       private String name;
       private String sex;
       private Integer weight;
       private Integer height;
       @Override
       public String toString(){
         return "Person{"+"name='"=name+'\''+
                        ",sex='"+sex+'\''+
                        ",weight="+weight+
                        ",height="+height+
                        '}';
        }
        private Person(String name,String sex,Integer weight,Integer height){
        this.name=name;
        this.sex=sex;
        this.weight=weight;
        this.height=height;
        }

       //建造器
        public static class PersonBuilder{
          private String name;
          private String sex="男";
          private Integer weight=50;
          private Integer height;

       //返回值类型不再是void 而是建造器本身
        public PersonBuilder name(String name){
          this.name=name;
          return this;
        }

        public PersonBuilder sex(String sex){
          this.sex=sex;
           return this;
        }
  
        public PersonBuilder weight(Integer weight){
          this.weight=weight;
           return this;
        }
    
        public PersonBuilder weight(Integer height){
          this.height=height;
           return this;
        }

        public Person build(){
          //需要的信息收集齐了
         return new Person(this.name,this.sex,this.weight,this.height);
        }
}

        public String getName(){

        return name;
        }

        public String getSex(){
        return sex;
        }
       
        public Integer getWeight(){
        return weight;
        }

        public Integer getHeight(){
        return height;
        }
}

public class Test{
      public static void main(String[] args){
        Person person=new Person.PersonBulider()
                .sex("男")
                .name("大卫")
                .height(192)
                .weight(70)
                .build();
         System.out.println(person);
       }
}

五.迭代器模式

以一种一致的方式对集合内元素进行遍历，而不用在乎集合内的数据结构

实现方法

ArrayList  LinkedList  HashSet  TreeSet  都可以通过for(Object o: 集合)进行遍历

或

       Iterator iter =集合.iterator();
       while(iter.hasNext(){
        iter.next();
       }

六.策略模式

java 集合或数组的排序算法

Collections.sort

Arrays.sort

基本类型 双基点快速排序

对象类型 TimSort(早期使用归并排序

规模小 插入排序

排序的算法是固定的，但是排序的规则不是固定的。我们可以通过比较器来实现不同的排序规则

我们将不同的比较器接口的实现就称为排序策略(open close开闭原则)