Java内部类，枚举

模式:
模板模式:
简单工厂模式:
适配器模式:
  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对象;

秒客网

Java内部类，枚举

相关文章