基本的几个设计模式

• 简单工厂模式
• 单例模式
• 建造者模式（Builder）
• 原型模式(prototype)—克隆
• 中介者模式(Mediator)
• 代理模式
• 观察者模式（Observe）
• 策略模式（strategy)
• 状态模式
• 享元模式(Flyweight)
• 装饰器模式

简单工厂模式

public interface Car(){
   
    public void run();
}
public class Audi implements Car(){
   
    @Override
    public void run(){
        System.out.println("奥迪在跑!");
    }
}
public class Benz implements Car{
   
    @Override
    public void run(){
        System.out.println("奔驰在跑!");
    }
}
public class CarFactory{
   
    public static Car createCar(String type){
    Car c=null;
    if("奥迪".equals(type)){
        c=new Audi();
        }else if("奔驰".equals(type)){
            c=new Benz();
        }
        return c;
    }
}
public class Client{
   
    public static void main(String []){
        Car c1 =CarFactory.createCar("奥迪");
        Car ce =CarFactory.createCar("奔驰");
        c1.run();
        c2.run();
    }
}

思考问题：
1.公司里，办公用品的领取过程？
2.sun公司设计java时，为解决操作系统之间的差异采用什么手段？
3.Spring的ioc容器的作用，跟我们工厂模式的关系？
（BeanFactory,bean class=”” ..可以通过反射来new 对象。可以把每个new 对象放在map里提高效率。）Factory一般用单例来做。
本质：将实现类、创建类对象统一管理控制，从而将客户端程序跟我们的实现类解耦。

单例模式

保证一个类只有一个实现对象。(如serlvet)
思考如下场景：
1.项目中，读取配置文件的类，一般也只有一个对象。有无必要每次使用配置文件数据，每次new一个对象去读取?
懒汉式单例模式代码：

public class singletonDemo{
    private static SingletonDemo s;
    private SingletonDemo(){}； //私有化构造器
    public static synchronized SingletonDemo getInstance(){
    if(s==null){
        s=new SingletonDemo();
        }
        return s;
    }
}
public class Client(
    public static void main(String[] args){
        SingletonDemo s=singletonDemo.getInstance();
        SingletonDemo s2=singletongDemo.getInstance();
        System.out.println(s==s2);//结果为true

 饿汉式单例模式代码：

 public class SingletonDemo2{
        private statice SingletonDemo2 s=new SingletonDemo2();//第一次加载就被创建，不会发生线程冲突
        private SingletonDemo2(){} //私有化构造器
        public static singletonDemo2 getInstance(){
        return s;
        }
       }
    public class Client{
    public  statice void main(String [] args){
        SingletonDemo s=SingletonDemo.getInstance();
        SingletonDemo s1=SingletonDemo.getInstance();
        System.out.prinln(s==s2);//结果为true
        }
    }

    比如sessionfactory servlet都是单例

建造者模式（Builder）

场景：
1.我们要建造一个复杂的产品，比如：神舟飞船。这个复杂的产品的创建。有这样一个问题需要处理：
装配这些子组建是不是有个步骤问题。
2.实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理。

    public class Airship{
   
        private String orbitalModule;//轨道舱
        private String engine;//发动机
        private String escapeTower;//逃逸塔
        public String getOrbitalModule(){
            return orbitalModule;
        }
        public void setOrbitalModule(String orbitalModule){
            this.orbitalModule=orbitalModule;
            }
        public String getEngine(){
            return engine;
            }
        public void setEngine(String engine){
            this.engine=engine;
            }
        public String getEscaperTower(){
            return escapeTower;
            }
        public void setEscapeTower(StringescapeTower){
            this.escapeTower=escapeTower;
        }
    }
    public interface AirshipBuilder{
   
        public void builderEngine();
        public void builderOrbitalModule();