技術標籤：Java基礎java設計模式

簡單工廠模式：

建立一個工廠類，對某一個介面的實現類，或這某一父類的子類建立例項。
基類：Animal.java

package entity;

public class Animal {
	public void eat() {
		System.out.println("吃");
	}
}

子類: Cat.java

package entity;

public class Cat extends Animal{
	public void eat() {
		System.out.println("貓吃魚"
 
);
	}
}

子類：Dog.java

package entity;

public class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃肉");
	}
}

工廠類：Factory.java

package factory;

import entity.Animal;
import entity.Cat;
import entity.Dog;

public class Factory {
	
	public static Animal createAnimal() {
		return
 
 new Animal();
	}
	
	public static Cat createCat() {
		return new Cat();
	}
	
	public static Dog createDog() {
		return new Dog();
	}
	
	/**
	 * 0代表貓
	 * 1代表狗
	 * else  動物
	 * @param type
	 * @return
	 */
	public static Animal create(int type) {
		if(type==0) {
			return new Cat();
		}else if(type==1) {
 

			return new Dog();
		}else {
			return new Animal();
		}
	}
}

這裡使用靜態工廠方法，上面有兩種寫法，第一種寫法是單獨建立每個例項。第二種寫法是通過一個方法，傳入不同引數統一建立。

執行：

	/**
	 * 簡單工廠模式
	 */
	private static void  demo1() {
		Animal a=Factory.createAnimal();
		a.eat();
		Animal b=Factory.createCat();
		b.eat();
		Animal c=Factory.createDog();
		c.eat();
		System.out.println("-----------------------------------\n按照type進行建立：");
		Animal d=Factory.create(0);
		d.eat();
	}

工廠方法模式：

對每個類分別建立工廠

工廠類介面：

package factory;

import entity.Animal;

/**
 * 工廠方法模式
 * @author jack
 *
 */
public interface IFactory {
	public Animal getAnimal();
}

子類：AnimalFactory.java

package factory;

import entity.Animal;

public class AnimalFactory implements IFactory{


	@Override
	public Animal getAnimal() {
		return new Animal();
	}

}

子類：CatFactory.java

package factory;

import entity.Animal;
import entity.Cat;

public class CatFactory implements IFactory {


	@Override
	public Animal getAnimal() {
		return new Cat();
	}

}

子類：DogFactory.java

package factory;

import entity.Animal;
import entity.Dog;

public class DogFactory implements IFactory{


	@Override
	public Animal getAnimal() {
		return new Dog();
	}

}

執行：

	/**
	 * 工廠方法模式
	 */
	private static void demo2() {
		IFactory factory=new AnimalFactory();
		factory.getAnimal().eat();
		IFactory factory2=new CatFactory();
		factory2.getAnimal().eat();
		IFactory factory3=new DogFactory();
		factory3.getAnimal().eat();
	}

抽象工廠模式

與工廠方法模式不同，一個工廠也可以建立多個產品，這裡我們新增‘主人類’
IOwner.java

package entity;

public interface IOwner {
	public void feed();
}

CatOwner.java

package entity;

public class CatOwner implements IOwner {

	@Override
	public void feed() {
		System.out.println("喂貓");
	}

}

DogOwner.java

package entity;

public class DogOwner implements IOwner {

	@Override
	public void feed() {
		System.out.println("喂狗");
	}

}

工廠介面：

package factory;

import entity.Animal;
import entity.IOwner;

public interface IAbstractFactory {
	public Animal getAnimal();
	public IOwner getOwner();
}

實現類：

package factory;

import entity.Animal;
import entity.Cat;
import entity.CatOwner;
import entity.IOwner;

public class AbstractCatFactory implements IAbstractFactory {

	@Override
	public Animal getAnimal() {
		return new Cat();
	}

	@Override
	public IOwner getOwner() {
		return new CatOwner();
	}

}

package factory;

import entity.Animal;
import entity.Dog;
import entity.DogOwner;
import entity.IOwner;

public class AbstractDogFactory implements IAbstractFactory {

	@Override
	public Animal getAnimal() {
		return new Dog();
	}

	@Override
	public IOwner getOwner() {
		return new DogOwner();
	}

}

執行：

	/**
	 * 抽象工廠模式   此模式可以實現多個介面，一個工廠可以有多個產品
	 */
	private static void demo3() {
		IAbstractFactory factory=new AbstractCatFactory();
		factory.getAnimal().eat();
		factory.getOwner().feed();
		System.out.println("----------------------");
		IAbstractFactory factory2=new AbstractDogFactory();
		factory2.getAnimal().eat();
		factory2.getOwner().feed();
		System.out.println("----------------------");
	}