面向工作编程
学了几个设计模式
- 工厂模式(Factory)
工厂模式包含以下几个组成结构
1. 接口定义
2. 子类
3. Factory子类,定义了一个static方法用于获取子类对象,之所以定义为static是因为Factory类不需要实例化
4. Factory用于获取子类对象
代码示例:
操作步骤:
1. 定义一个接口:目的是吃水果,不同的水果有不同的吃法,此处定义一个方法,具体实现由不同的子类完成
2. 定义第一个子类:实现接口的方法,为吃苹果
3. 定义第二个子类:实现接口的方法,为吃橘子
4. 定义Factory类:根据传入的字符串,返回子类对象
5. 定义测试主类:根据传入的第一个字符串,返回不同子类的eat()函数
代码:
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
public void eat() {
System.out.println("吃苹果");
}
}
class Orange implements IFruit {
public void eat() {
System.out.println("吃橘子");
}
}
class Factory {
//不需要factory产生实例化对象
public static IFruit getInstance(String cmd) {
if ("apple".equals(cmd)) {
return new Apple();
}
if ("orange".equals(cmd)) {
return new Orange();
}
return null;
}
}
public class TestDemo {
public static void main(String[] args) {
if (args.length != 1) {
System.exit(1);
}
IFruit fruit = Factory.getInstance(args[0]);
fruit.eat();
}
}
总结:
1. Factory的好处在于,每次改动子类的代码的时候,主方法(客户端)不需要改动任何东西
2. 现阶段要求记住结构
- 代理模式(Proxy)
代理模式的形式,一个接口定义实现目标功能,2个子类继承接口,1个实现真实的目标需求,另外一个实现辅助功能,
比如真实目的为吃饭(接口),第一个子类实现真实需求(吃饭),第二个子类实现辅助功能(准备菜品,收拾桌子)
第一个子类是核心实现,第二个子类就是代理子类
代码示例:
操作步骤:
1. 定义1个接口,核心目的为吃饭
2. 定义1个子类,覆写接口的吃饭方法,实现吃饭
3. 定义1个子类,覆写接口的吃饭方法,实现辅助功能(重点)
3.1 定义私有对象,为接口对象
3.2 定义构造函数,为3.1的对象赋值
3.3 定义辅助函数,比如准备碗筷,收拾餐桌
3.4 覆写接口方法
4. 定义1个Factory类,返回接口对象
5. 定义主方法,实现整个过程
代码如下:
interface ISubject {
public void eat(); //核心目的是吃饭
}
class RealSubject implements ISubject {
public void eat() {
System.out.println("2. 开始吃饭");
}
}
class ProxySubject implements ISubject {
private ISubject subject; //实际上要操作的对象
public ProxySubject(ISubject subject) {
this.subject = subject;
}
public void prepare() {
System.out.println("1. 准备饭菜和碗筷");
}
public void finish() {
System.out.println("3. 收拾剩菜和碗筷");
}
public void eat() {
this.prepare();
this.subject.eat();
this.finish();
}
}
class Factory {
public static ISubject getInstance() {
return new ProxySubject(new RealSubject());
}
}
public class TestDemo {
public static void main(String args[]) {
ISubject subject = Factory.getInstance();
subject.eat();
}
}
总结:
代理模式一般要和工厂模式结合使用。
- 单例设计模式
问题来源:
类的实例化由类完成,定义为:
private final static Singleton instance = new Singleton();
final:只要加载该类,就会自动创建1个共享对象
构造函数使用private定义
提供getter方法用于获取类中创建的对象
代码示例:
class Singleton {
private final static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance ;
}
private Singleton() {}
public void print() {
System.out.println("Hello World");
}
}
public class TestDemo {
public static void main(String[] args) {
Singleton s = null;
s = Singleton.getInstance();
s.print();
}
}
总结:
单例设计的概念很重要,开发过程写的很少
- 多例设计模式
比如1周只有7个对象天
性别只有2个对象,男或者女
代码结构:(以性别为例)
1. 定义2个常量,代表男性或者女生
2. 定义2个常量对象,代表不同性别实例
3. 定义1个私有的构造函数
4. 定义1个getter方法,根据传入的值返回男性或者女生对象,默认值为null
代码示例:
class Sex {
public static final int FEMALE_CMD = 0 ;
public static final int MALE_CMD = 1 ;
private static final Sex MALE = new Sex("male") ;
private static final Sex FEMALE = new Sex("female") ;
private String title ;
private Sex(String title) {
this.title = title ;
}
public static Sex getInstance(int ch) {
switch (ch) {
case MALE_CMD:
return MALE;
case FEMALE_CMD:
return FEMALE;
default:
return null;
}
}
public String toString() {
return this.title;
}
}
public class TestDemo {
public static void main(String[] args) {
Sex a = Sex.getInstance(Sex.MALE_CMD);
System.out.println(a);
}
}
总结:
多例设计模式已经被枚举取代,此处只要了解结构即可。