NativeFactory。java

package com;
//定义 人有杀日本人 和 杀美国人两个方法
interface NativePerson{
 public void killAmeria();
 public void killJapan();
}
//中国人实现了人的接口
class NativeChinese implements NativePerson{
 //中国人杀美国人
 public void killAmeria() { 
  System.out.println("Chinese kill Ameria");
 }
 //中国人杀日本人
 public void killJapan() {
  System.out.println("Chinese kill Japan");
 }

}
//俄国人实现了人的接口
class NativeRussia implements NativePerson{
 public void killAmeria()
 {
  System.out.println("Russia kill Ameria");
 }
 public void killJapan()
 {
  System.out.println("Russia kill Japan");
 }
}
public class NativeFactory
{
 /**
  * 假如 我要添加朝鲜人 就不需要动前面的逻辑 只需要假如 i==2
   return new CX();就行了 我们不需要通过new 关键字去实例化了
   在整个就不涉及到Sample的具体子类,达到封装效果,也就减少错误修改的机会,
   这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.
   这每个做过具体工作的人都深有体会,相反,
   官做得越高,说出的话越抽象越笼统,范错误可能性就越少.
   **/
 public static NativePerson getPerson(int i)
 {
  if(i==0)
   return new NativeChinese();
  else
   return new NativeRussia();
 }
 public static void main(String[] args) {
  NativePerson person=NativeFactory.getPerson(0);
  person.killAmeria();
  person.killJapan();
 }
}

UFOFactory.java

package com;

//定义 人有杀日本人 和 杀美国人两个方法
interface UFOPerson{
 public void killAmeria();
 public void killJapan();
}
//中国人实现了人的接口
class UFOChinese implements UFOPerson{
 //中国人杀美国人
 public void killAmeria() { 
  System.out.println("UFOChinese kill Ameria");
 }
 //中国人杀日本人
 public void killJapan() {
  System.out.println("UFOChinese kill Japan");
 }

}
//俄国人实现了人的接口
class UFORussia implements UFOPerson{

public void killAmeria()
 {
  System.out.println("UFORussia kill Ameria");
 }

public void killJapan()
 {
  System.out.println("UFORussia kill Japan");
 }
}
public class UFOFactory
{

public static UFOPerson getPerson(int i)
 {
  if(i==0)
   return new UFOChinese();
  else
   return new UFORussia();
 }
 public static void main(String[] args) {
  UFOPerson person=UFOFactory.getPerson(0);
  person.killAmeria();
  person.killJapan();
 }
}

AbstractFactory.java

/**
 * 假如现在有一个nativ工厂 又多了个UFO工厂 现在要同时生产不能中国人和俄国人
 * 其实就是多个工厂模式的联合 就是抽象工厂模式

有几个工厂要磨合成一个抽象工厂模式其实就很简单

添加一个抽象类  该抽象类中添加方法   分别用于获取 每个工厂的接口方法

工厂类中有几个方法 就产生几个工厂 继承抽象工厂   就行了
 */
abstract class CommonFactory {
 public abstract NativePerson getNativePerson();
 public abstract UFOPerson getUFOPerson();
}
class ChineseFactory extends CommonFactory {
 public NativePerson getNativePerson() {
  return new NativeChinese();
 }

public UFOPerson getUFOPerson() {
  return new UFOChinese();
 }
}

class RussionFactory extends CommonFactory {
 public NativePerson getNativePerson() {
  return new NativeRussia();
 }

public UFOPerson getUFOPerson() {
  return new UFORussia();
 }
}

642 924 975
1372