２．Java设计模式－－＞观察者模式

这是根据别人文章，自己整理过来的．原文链接：

一：简单工厂模式

BMW.java
public interface BMW{
}

BMW320.java
public class BMW320 implements BMW{
    public BMW320(){
    System.out.println("BMW320 has been made already");
    }
}

BMW520.java
public class BMW520 implements BMW{
    public BMW520(){
    System.out.println("BMW520 has been made already");
    }
}

Factory.java
public class Factory {
    public BMW creatBMW(int type){//工厂只是提供一个方法
    swith(type){//根据选择进行实例化
    case 320:
        return new BMW320();
    case 520:
        return new BMW520();
    default:
        break;
        }
    return null;//确保返回规定返回值，否则编译不通过
    }
}

Test.java
public class Test{
    public static void main( string[] args){
    Factory factory = new Factory();
    BMW bmw320 = factory.createBMW( 320);
    BMW bmw520 = factory.createBMW( 520);
    }

二：工厂方法

BMW.java
public interface BMW{
}

BMW320.java
public class BMW320 implements BMW{
    public BMW320(){
    System.out.println("BMW320 has beed made already");
    }
}

BMW520.java
public class BMW520 implements BMW{
    public BMW520(){
    System.out.println("BMW520 has been made already");
    }
}

．．．．．．．．．．．．．．以上代码与简单工厂一致

Factory.java
public interface Factory{
    BMW creatBMW();//接口中方法默认修饰符：public abstract
    }

FactoryBMW320.java
public class FactoryBMW320 implements Factory{
    @Override //覆盖:１返回值　２．方法名　３．参数
    public BMW320 createBMW(){//关于此行的 public　修饰符．一般覆盖都是由子类完成．能继承的变量只要 protected 和 public.改写修饰符也是只能放低门槛，所以 protected的变量也会变成　public.一般情况下，需要覆盖的方法的修饰符是不进行调整的，基本是 public.
        return new BMW320();
        }
    }

FactoryBMW520.java
public class FactoryBMW520 implements Factory{
    @Override
    public BMW520 createBMW(){
        return new BMW520();
        }
    }

Test.java
public class Test{
    public static void main( String[] args){
    Factory factory320 = new FactoryBMW320();
    Factory factory520 = new FactoryBMW520();
    BMW bmw320 = factory320.createBMW();
    BMW bmw520 = factory520.createBMW();
    }

主要是进行工厂的解耦，让特定工厂生产特定产品．

三抽象工厂

Engine.java
public interface Engine{//interface 默认属性：public static final.此行的 pulic 可以省略．
}

EngineA.java
public class EngineA implements Engine{
    public EngineA(){
    System.out.println("equipped with EngineA");
    }
}

EngineB.java
public class EngineB implements Engine{
    public EngineB(){
    System.out.println("equipped with EngineB");
    }
}

引擎系列产品

Aircondition.java
interface Aircondition{
}

AirconditionA.java
public class AirconditionA implements Aircondition{
    public AirconditionA(){
    System.out.println("equipped with airconditon A ");
    }
}

AirconditionB.java
public class AirconditionB implements Aircondition{
    public AirconditionB(){
    System.out.println("equipped with airconditin B");
    }
}

空调系列产品的制造

AbstractFactory.java
interface AbstractFactory{
    Engine createEngine();
    Aircondition createAircondition();
    }//明显，我们也可以在其中建造BMW,工厂方法已实验过，不再添加

FactoryBMW320.java
public class FactoryBMW320 implements AbstractFactory{
    public EngineA createEngine(){//此行要加public,否则使用门槛升高到 default,编译不能通过．可以指定返回值的子类．
        return new EngineA();
        }
    public AirconditionA createAircondition(){
        return new AirconditionA();
        }

相同地：

FactoryBMW520.java
public class FactoryBMW520 implements AbstractFactory{
    public EngineB createEngine(){
        return new EngineB();
        }
    public AirconditionB createAircondition(){
        return new AirconditonB();
        }
    }

最后，测试．

Test.java
public class Test{
    public static void main ( String[] args ){
    FactoryBMW320 factory = new FactoryBMW320();
    factory.createEngine();
    factory.createAircondition();//生产出a型引擎，空调．