设计模式1

1.creational patterns对象的创建
2.structral patterns 类与对象的关系
3.behavioral patterns 对象之间的通信
4.j2ee特别关注表示层

1.将创建实例的能力交给factory类，而不再用new();
不对客户端暴露创建对象的逻辑
2.例子：生产某种手机，先定义手机类接口，再对手机进行分类，如苹果，
三星。创建手机工厂类，在主函数中调用手机工厂类来创建对象。

   //通用手机类接口
  public interface phone(){}
  
   //苹果手机类
   public class Ipone implements phone{
      public success(){
      System.out.println("succesIphone");
      }
   }
   //三星手机类
   public clss samsung implements phone{
       public success(){
      System.out.println("succesSamsung");
      }
   }
   //工厂类
   public class FactoryPhone{
   //static方法
       public static Phone makePhone(string phoneType){
            if(phoneType.equals(Iphone){
             return  new Iphone();
             }
             if(phoneType.equals(samsung){
             return  new samsung();
             }
      }
   }
 }
    //使用工厂类对象来创建手机类的对象，不再需要直接new()
  public class usePhoneFactory{
      public void main(){
         FactoryPhone factoryPhone = new FactoryPhone();
    
         Phone iphone = factoryphone.makePhone(Iphone);
         iphone.success();
    
         Phone samsung = factoryphone.makePhone(samsung);
         samsung.success();
    }
 }
 //当然工厂模式也可以把工厂类抽象化，创建多个不同的具体工厂类再在主函数中调用。
public interface AbstractPhone(){//Phone,Iphone,samsung不变。
     Phone makePhone();
 }

1.和工厂模式类似，但是工厂模式只能生产手机这种产品，那么如果我们要生产另一种产品，比如电脑。多个产品簇就可以使用抽象工厂模式。
2.使用abstractFactory，因此需要有n个实体化ConcreteabstractFactory的类，我们可以在主函数调用前创建一个FactoryProducer类来封装这些实体化ConcreteAbstractFactory。

//创建一个pc类
public interface Pc(){
     void makePc();
}
//创建一个mac类
public class Mac() implements Pc{
   void successpc(){
    System.out.println("succesMac");
   }
}
创建一个notepad类
public class Notepad() implements Pc{
   void successpc(){
    System.out.println("succesNotepad");
   }
}
//创建一个抽象工厂类
public interface AbstractFactory{
      //创建手机类
      Phone makePhone(String phone);
      //创建pc类
      Pc makePc(String pc);
}

//创建抽象工厂类的实例化,but这么写是不对的。。要分别创建具体工厂类的实体类，如：创建一个phone的工厂实体类，再创建一个pc的工厂实体类
public class Concetefactory implements AbstractFactory{
       public makePhone(String phone){
           if(phone.equals(iphone){
           return  new Iphone()
           }
       }
       public makePc(String pc){
           if(pc.equals(mac){
           return  new mac()
           }
       } 
}

//创建一个pc的工厂实体类
public class ConcreteFactory implements AbstractFactory{
      Phone makePhone(){
      return null;
      }
      //实现pc对象的创建
      public Pc makePc(string pc){
          if(pc.equals(mac){
             return  new Mac();
           }else if(pc.equals(notepad){
             return  new NotePad();
           }else{
           return null;
           }     
      }
//创建一个pc的工厂实体类
public class ConcretePhone implements AbstractFactory{
      //实现phone对象的创建
      public Phone makePhone(String phone){
          if(){
          // ...懒得写了，跟ConcretePc差不多
          }
      }
      public Pc makePc(String pc){
      return null;
      }
}

//创建一个FactoryProducer
public class FactoryProducer {
   public static AbstractFactory chooseFactory(string factory){
       if(factory.equals("pc")){
       return new ConcretePc();
       }
       //if....手机类懒得写了
   }
}

//主函数调用Concrete后的抽象工厂
public void main(){
  psvm(){
    FactoryProducer fp = new FactoryProducer();
    
    AbstractFactory pcFactory = fp.chooseFactory("pc");
    Pc mac = pcFactory .makePc("mac");
    mac.success();
    
    AbstractFactory phonefactory = fp.chooseFactory("phone");
    Phone samsung = phoneFactory .makephone();
    samsung.success();
  }
}

三、单例模式
1.懒汉、饿汉、classLoader、枚举
2.枚举好简单。

public User{
   //私有化User的构造方法
   private user(){};

   //枚举类
   static emum SingleToEnum{
      //创建枚举类对象Instance
      Instance;
      //枚举类里可以有变量，有构造方法，有getter/setter方法
      private User use;
      private User(){};
      public void setUser(){
         this.user = user;
       };
      public User getUser(){
         return user;
     }
 
   //一个对外的getUser()的接口方法
   public static User getUser(){
       return SingleToEnum.Instance.getUser();   
   }
}


//创建一个测试类
public class Test{
    psvm{
     //??你在干啥，User构造函数是private的 User user = new User();
      sout(User.getUser());
      sout(User.getUser());//跟上边的打印结果的地址一致
      sout(User.getUser()==User.getUser());//返回true
}
}