设计模式（二）工厂模式

与代理模式不同，生产模式隐藏过程，只关注结果

简单工厂，工厂方法，抽象工厂

一，简单工厂模式

public interface Car {
	String getName();
}

public class Aodi implements Car{
	public String getName() {
		return "Aodi";
	}
}


public class Baoma implements Car{
	public String getName() {
		return "Baoma";
	}
}

public class SimpleFactory {
	public Car getCar(String name) {
		if(name.equals("Baoma")) {
			return new Baoma();
		}else if (name.equals("Aodi")) {
			return new Aodi();
		}else {
			return null;
		}
	}
}

public class Main {
public static void main(String[] args) {
	Car car = new SimpleFactory().getCar("Baoma");
	System.out.println(car.getName());
}
}

二，工厂模式

public interface Factory {
	Car getCar();
}

public class AodiFactory implements Factory{
	public Car getCar() {
		return new Aodi();
	}
}

public class BaomaFactory implements Factory{
	public Car getCar() {
		return new Baoma();
	}
}

public class Main {
public static void main(String[] args) {
	 Factory factory=new AodiFactory();
	 System.out.println(factory.getCar());
}
}

三，抽象工厂模式

public abstract class AbstractFactory {
	protected abstract Car getCar();
	
	public Car getCar(String name) {
		if(name.equals("Baoma")) {
			return new BaomaFactory().getCar();
		}else if (name.equals("Aodi")) {
			return new AodiFactory().getCar();
		}else {
			return null;
		}
	}
}

public class AodiFactory extends AbstractFactory{
	public Car getCar() {
		return new Aodi();
	}
}

public class BaomaFactory extends AbstractFactory{
	public Car getCar() {
		return new Baoma();
	}
}

public class DefaultFactory extends AbstractFactory{
	
	private AodiFactory defaultFactory=new AodiFactory();

	@Override
	protected Car getCar() {
		return defaultFactory.getCar();
	}

}

public class Main {
public static void main(String[] args) {
	DefaultFactory factory=new DefaultFactory();
	System.out.println(factory.getCar().getName());
	System.out.println(factory.getCar("Baoma").getName());
}
}