设计模式

1.工厂设计模式

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{
public static IFruit getClassName(String ClassName){
if("Apple".equals(ClassName)){
return new Apple();
}
if("Orange".equals(ClassName)){
return new Orange();
}
return null;
}
}
public class InterfaceDemo{
public static void main(String args[]){
//子类对象实例化父类接口，new是开发过程中最大的耦合，如果想进行解耦，就必须使用一个第三方Factory类来设计
//IFruit fruit=new Apple();
//fruit.eat();
if(args.length!=1){
System.out.println("没有正确输入格式，正确格式为：java InterfaceDemo 水果名字");
System.out.println(args.length);
System.exit(1);
}else{
System.out.println(args.length);
IFruit fruit=Factory.getClassName(args[0]);
fruit.eat();
}
}
}

改进版，接受多个类对象，不需要变更工厂类

package com.wjx.sayHello;
interface IFruit{
	public void eat();
}
class Apple implements IFruit{
	@Override
	public void eat() {
		System.out.println("吃苹果");
	}
}
class Orange implements IFruit{
	@Override
	public void eat() {
		System.out.println("吃橘子");
	}
}

interface IMessage{
	public void print();
	
}
class IMessageImpl implements IMessage{

	@Override
	public void print() {
		System.out.println("打印信息");
		
	}
	
}
class Factory{
	private Factory(){};
	//通过泛型接受多个接口
	public static <T> T getInstance(String className) {
		T obj=null;
		try {
			//通过反射获取类名称来动态实例化对象
			obj=(T)Class.forName(className).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		} 
		return obj;
	}
}
public class FactoryDesignPatternTestDemo {

	public static void main(String[] args) {
		IFruit fruit=Factory.getInstance("com.wjx.sayHello.Orange");
		fruit.eat();
		IMessage msg=Factory.getInstance("com.wjx.sayHello.IMessageImpl");
		msg.print();

	}

}

2.代理设计模式

所谓代理模式，即两个子类共同实现一个接口，其中一个子类负责真实业务逻辑的实现，另外一个子类辅助真实业务主体的实现；

// 代理设计模式
//业务场景，核心目的是救人（接口），核心业务实现救人，辅助业务类实现破门操作，表扬操作
//核心目的接口
interface CorePurpose{
public void save();
}
//核心业务
class CoreService implements CorePurpose{
public void save(){
System.out.println("王先生最终救人成功");
}
}
//辅助业务类
class ProxyService implements CorePurpose{
private CorePurpose corepurpose;
public ProxyService(CorePurpose corepurpose){
this.corepurpose=corepurpose;
}
public void unLock(){
System.out.println(" 王先生联系解锁公司救人成功");
}
public void praise(){
System.out.println(" 王先生受到媒体报道表扬");
}
public void save(){
this.unLock();
this.corepurpose.save();
this.praise();
} 
}
//工厂代理
class Factory{
public static CorePurpose getInstance(){
return new ProxyService(new CoreService());
}
}
public class InterfaceDemo{
public static void main(String args[]){
CorePurpose c=Factory.getInstance();
c.save();
}
}

3.单例设计模式
所谓单例设计模式指 的是一个类只允许产生一个实例化对象

//单例设计
//特点：构造方法私有化，外部无法产生实例化对象，只能通过static去调用访问
//饿汉式
class Singleton{
private final static Singleton instance=new Singleton();
private Singleton(){
}
public static Singleton getInstance(){
return instance;
}
public void print(){
System.out.println("Hello World!");
}
}
class TestSingleton {
public static void main(String[] args) {
Singleton s=null;
//s=new Singleton();
s=Singleton.getInstance();
s.print();
}
}

4.多例设计模式
所谓多例只是比单例追加了更多内部实例化对象的产生

class Sex{
private String title;
private static final Sex MALE=new Sex("男");
private static final Sex FEMALE=new Sex("女");// 实例化
public  static final int MALE_FLAG=1;
public  static final int FEMALE_FLAG=2;
private Sex(String title){
this.title=title;
}
public String toString(){
return this.title;
}
public static Sex getInstance(int ch){
switch(ch){
case MALE_FLAG:
return MALE;
case FEMALE_FLAG:
return FEMALE;
default:
return null;
}
}
}
class TestSingleton {
public static void main(String[] args) {
Sex a=Sex.getInstance(Sex.MALE_FLAG);
System.out.println(a);

}
}