模式:
 模板模式:
 简单工厂模式:
 适配器模式:
  interface ICellPhone
  {
   void sendMsg();
  }

class Android implements ICellPhone
  {
   public void sendMsg()
   {
    System.out.println("我爱你");
   }
  }

class ITCAST implements ICellPhone
  {
   public void sendMsg()
   {
    System.out.println("I Love You");
   }
  }

class CellPhoneFactory
  {
   public static ICellPhone getInstance(String type)
   {
    ICellPhone p=null;
    if("Android".equals(type))
    {
     p=new Android();
    }
    if("ITCAST".equals(type))
    {
     p= new ITCAST();
    }
    return p;
   }
  }

class FactoryDemo
  {
   public static void main(String[] args)
   {
    ICellPhone p=new Android();
    p=CellPhoneFactory.getInstance("ITCAST");
    p.sendMsg();
    p=CellPhoneFactory.getInstance("Android");
    p.sendMsg();
   }
  }
接口:  一种规范,一种标准

interface 接口名 {}
 接口里的成员: 
  1. 全局变量  :  这里定义的变量,默认是使用  public  static final 修饰的
  2. 公共的抽象方法 :    默认使用 abstract public 修饰的
  3.  内部类   
 特点:
   没有构造方法,不能实例化
   接口和接口之间可以多继承,  接口里全是抽象方法,不能有普通方法
 
 使用接口: 
  interface IPCI
  {
   void usePCI();
  }

interface IUSB  //接口
  {
   void swapData();
  }

class MouseUSBImpl implements IUSB,IPCI
  {
   public void swapData()
   {
    System.out.println("鼠标在移动");
   }

public void usePCI()
   {
    System.out.println("PCI鼠标");
   }
  }

class USBDemo2
  {
   public static void main(String[] args)
   {
    //IUSB mouse=new MouseUSBImpl();
    MouseUSBImpl mouse=new MouseUSBImpl();
    mouse.swapData();
    mouse.usePCI();
   }
 内部类:
  外部类: 宿主类
  内部类: 嵌套类
  1. 非静态内部类  :  内部类没有使用 static 修饰,  此时 内部类属于 外部类的一个对象,也就是说创建内部类对象之前应该先创建外部类对象
    外部类 out = new 外部类();
    外部类.内部类 in = out.new 内部类();
  2. 静态内部类 : 内部类使用了 static 修饰,此时内部类属于 外部类,也就说,外部类可以直接调用内部类
    外部类.内部类 in  = new 外部类.内部类();
  3. 局部内部类,  在方法里创建类
  4. 局部内部类的一个特殊,  匿名内部类:
     没有名字的局部内部类,只能用一次
     
     1. 不能是抽象类
     2. 没有构造方法
   创建格式: 
   
      new 父类(参数){
       //覆写父类的方法
      }
      new 接口()
      {
       //覆写接口里的方法
      }
     一旦一个方法需要一个对象的时候,而该对象有父类或接口的时候
     
     void  useUSB(IUSB usb){
      usb.use();
     }
     
     useUSB(new  IUSB(){
      public void  use(){
      }
     });
     
    
    创建线程的时候,AWT添加事件的时候,Android添加事件
    
   
   枚举:
    声明: 
     enum 枚举名
     {
      对象名(),对象2;//对象必须写在第一行,并且和其他成员使用 分号隔开
      构造方法,默认是   private 修饰的无参构造方法
      对象,默认都是 全局常量  public  static  final  枚举名 对象 = new 枚举名();
     }
     
     枚举的直接父类:  java.lang.Enum类,抽象类
    
     访问枚举对象: 枚举名.对象 == 枚举名.对象; ?//相等
     
     对象后面带():
     对象后带{}: 表示该对象是枚举类的匿名内部类对象;
     
     每个枚举类都有一个静态方法 values().将返回一个枚举类型的一维数组,里面装的是该枚举类的全部对象
     enum  Gender{
      MAN,WOMAN;
     }
     Gedner[] gs = Gender.values();
     每个枚举类都有一个静态的方法  valueOf(String name);//name严格区分大小写
     Gender man = Gender.valueOf("MAN");//
     打印枚举对象的时候,打印出来的是 对象的名;这是因为 java.lang.Enum类覆写了toString方法
     enum Gender
     {
      MAN(),WOMAN{},NONE;

//MAN等价于 public static final MAN=new Gender();
      private Gender()
      {

}
     }

class  EnumDemo extends Object
     {
      public EnumDemo()
      {

}

public static void main(String[] args)
      {
       Gender man=Gender.MAN;

Gender man1=Gender.MAN;
       System.out.println(man);
       System.out.println(man==man1);

Gender[]gs=Gender.values();
       for(Gender g:gs)
       {
        System.out.println(g);
       }
       //Gender women = Gender.valueof("woman");
       //System.out.println(women);
      }
     }
     
     public  String toString()
     {
     
      String ret = super.toString();
      switch(this){
       case MAN:
        ret = "男";break;
       case WOMAN:
        ret = "女";break;
       default:
        ret="保密";
      }
      return ret;
     }
     
  枚举的构造方法:
  
  enum Gender{
   MAN("男"),WOMAN("女"),NONE("保密");
   
   //默认: private Gender(){};
   
   private String ObjValue;
   privte Gender(String value)
   {
    objValue = value;
   }
   
   public String toString()
   {
    return  this.objValue;
   }
  }
  
  枚举实现接口:
   有两种写法:
    1. 直接在枚举类里覆写方法
    2. 在枚举类的匿名内部类里覆写;
    
  枚举实现单例模式:
  
  enum Singleton
  {
   INSTANCE;
   
   public static Singleton getInstance(){
    return INSTANCE;
   }
   
   //private Singleton(){}, 默认的
  }
  //使用反射,都不能在外界创建SIngleton对象;