模式:
模板模式:
简单工厂模式:
适配器模式:
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内部类，枚举