java中常用设计模式

一.java的设计模式大体上分为三大类：
创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
二.常用设计模式：

1. 工厂模式（Factory Method）
   　　常用的工厂模式是静态工厂，利用static方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。

   在这里插入代码片
   interface food{}
   class A implements food{}
   class B implements food{}
   class C implements food{}
   public class StaticFactory {
       private StaticFactory(){}
       public static food getA(){  return new A(); }
       public static food getB(){  return new B(); }
       public static food getC(){  return new C(); }
   }
   class Client{
       //客户端代码只需要将相应的参数传入即可得到对象
       //用户不需要了解工厂类内部的逻辑。
       public void get(String name){
           food x = null ;
           if ( name.equals("A")) {
               x = StaticFactory.getA();
           }else if ( name.equals("B")){
               x = StaticFactory.getB();
           }else {
               x = StaticFactory.getC();
           }
       }
   }
   

2. 抽象工厂模式（Abstract Factory）
   一个基础接口定义了功能，每个实现接口的子类就是产品，然后定义一个工厂接口，实现了工厂接口的就是工厂，这时候，接口编程的优点就出现了，我们可以新增产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用新产品的代码。
   抽象工厂的灵活性就体现在这里，无需改动原有的代码，毕竟对于客户端来说，静态工厂模式在不改动StaticFactory类的代码时无法新增产品，如果采用了抽象工厂模式，就可以轻松的新增拓展类。

   interface food{}
   class A implements food{}
   class B implements food{}
   interface produce{ food get();}
   class FactoryForA implements produce{
       @Override
       public food get() {
           return new A();
       }
   }
   class FactoryForB implements produce{
       @Override
       public food get() {
           return new B();
       }
   }
   public class AbstractFactory {
       public void ClientCode(String name){
           food x= new FactoryForA().get();
           x = new FactoryForB().get();
       }
   }
   

   3. 单例模式（Singleton）
      　　在内部创建一个实例，构造器全部设置为private，所有方法均在该实例上改动，在创建上要注意类的实例化只能执行一次，可以采用许多种方法来实现，如Synchronized关键字，或者利用内部类等机制来实现。

public class Singleton {
    private Singleton(){}
    private static class SingletonBuild{
        private static Singleton value = new Singleton();
    }
    public Singleton getInstance(){  return  SingletonBuild.value ;}
    
}

4.代理模式（Proxy）
客户端通过代理类访问，代理类实现具体的实现细节，客户只需要使用代理类即可实现操作。
这种模式可以对旧功能进行代理，用一个代理类调用原有的方法，且对产生的结果进行控制。

interface Source{ void method();}
class OldClass implements Source{
    @Override
    public void method() {
    }
}
class Proxy implements Source{
    private Source source = new OldClass();
    void doSomething(){}
    @Override
    public void method() {
        new Class1().Func1();
        source.method();
        new Class2().Func2();
        doSomething();
    }
}

5.适配器模式（Adapter）
适配器模式的作用就是在原来的类上提供新功能。主要可分为3种：
类适配：创建新类，继承源类，并实现新接口，例如

class  adapter extends oldClass  implements newFunc{}

对象适配：创建新类持源类的实例，并实现新接口，例如

class adapter implements newFunc { private oldClass oldInstance ;}

接口适配：创建新的抽象类实现旧接口方法。例如

abstract class adapter implements oldClassFunc { void newFunc();}

6.建造者模式（Builder）
　　在了解之前，先假设有一个问题，我们需要创建一个学生对象，属性有name,number,class,sex,age,school等属性，如果每一个属性都可以为空，也就是说我们可以只用一个name,也可以用一个school,name,或者一个class,number，或者其他任意的赋值来创建一个学生对象，这时该怎么构造？

难道我们写6个1个输入的构造函数，15个2个输入的构造函数…吗？这个时候就需要用到Builder模式了。给个例子，大家肯定一看就懂：

public class Builder {

    static class Student{
        String name = null ;
        int number = -1 ;
        String sex = null ;
        int age = -1 ;
        String school = null ;

　　　　　//构建器，利用构建器作为参数来构建Student对象
        static class StudentBuilder{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
            public StudentBuilder setName(String name) {
                this.name = name;
                return  this ;
            }

            public StudentBuilder setNumber(int number) {
                this.number = number;
                return  this ;
            }

            public StudentBuilder setSex(String sex) {
                this.sex = sex;
                return  this ;
            }

            public StudentBuilder setAge(int age) {
                this.age = age;
                return  this ;
            }

            public StudentBuilder setSchool(String school) {
                this.school = school;
                return  this ;
            }
            public Student build() {
                return new Student(this);
            }
        }

        public Student(StudentBuilder builder){
            this.age = builder.age;
            this.name = builder.name;
            this.number = builder.number;
            this.school = builder.school ;
            this.sex = builder.sex ;
        }
    }

    public static void main( String[] args ){
        Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
        Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
    }
}