java设计模式 (1) 工厂模式，抽象工厂模式，单子模式

《一》 工厂模式

工厂模式就是实例化对象，用工厂方法代替new操作的一种模式，会给你系统带来更大的可扩展性和尽量少的修改量。

Car.java

//创建接口

public interface Car {

public void Price();

public void race();

}
bmw.java

//接口实现

public class bmw implements Car {

@Override

public void Price() {

// TODO Auto-generated method stub

System.out.println(“100万元”);

}
@Override

public void race() {

// TODO Auto-generated method stub

System.out.println(“最高时速300km/h”);

}
}
Volkswagen.java

//接口实现

public class Volkswagen implements Car{

@Override

public void Price() {

// TODO Auto-generated method stub

System.out.println(“20万元”);

}
@Override

public void race() {

// TODO Auto-generated method stub

System.out.println(“最高时速150km/h”);

}
}
CarFactory.java

//创建工厂

public class CarFactory {

public Car style(String type){

if(“bmw”.equals(type))

{

return new bmw();

}
else if(“Volkswagen”.equals(type)){

return new Volkswagen();

}
else{

System.out.println(“没有要找的类型”);

return null;

}
}
}
CarTest.java

//测试工厂模式

public class CarTest {

public static void main(String[] args) {
// TODO Auto-generated method stub
CarFactory factory=new CarFactory();  //实例化
Car car=factory.style("bmw");
car.Price();
car.race();
}

}
UML–工厂模式

《二》 抽象工厂模式

一个抽象工厂类，可以派生出多个具体工厂类。每个抽象产品类可以派生出多个具体产品类，每个具体工厂类可以创建多个具体产品类。将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。

//car接口 Car.java

public interface Car {

public void price();

public void race();

}

bmw.java

public class bmw implements Car {

@Override
public void price() {
// TODO Auto-generated method stub
System.out.println("宝马的价格是300万元");
}

@Override
public void race() {
// TODO Auto-generated method stub
System.out.println("宝马的速度可达到300km/h");
}

}

Volkswagen.java

public class Volkswagen implements Car{

@Override

public void price() {

// TODO Auto-generated method stub

System.out.println(“大众的价格是100万元”);

}
@Override

public void race() {

// TODO Auto-generated method stub

System.out.println(“大众的速度为150km/h”);

}
}

CarFactory.java

//工厂接口

public interface CarFactory {

public Car produce();

}

OneFactory

public class OneFactory implements CarFactory{

@Override

public Car produce() {

// TODO Auto-generated method stub

return new bmw();

}
}

TwoFactory

public class TwoFactory implements CarFactory{

@Override

public Car produce() {

// TODO Auto-generated method stub

return new Volkswagen();

}
}

Test_car

public class Test_car {

public static void main(String[] args) {

// TODO Auto-generated method stub

CarFactory factory=new OneFactory(); //找到工厂

Car car=factory.produce();

car.pric

()

car.race();//生产产品

}

}

《三》 单子模式

保证单例类只能有一个实例，而且必须是自己创建自己的唯一实例，必须给所有其他对象提供这一实例。

//创建型模式，只能产生一个实例供外部使用，

public class Single{

private static final Single s=new Single();//私有化

private Single(){}

public static Single getInstance(){
return s;

}//定义一个静态方法并返回该类的实例

}
/**懒汉式是在类被主动调用时才会被实例化，

实现了类的延迟加载，此处通过两种方式来实现单例模式，

一种是通过双重校验锁的方式，

另一种是通过静态内部类的方式**/

//双重校验锁

public class Single1 {

private static Single1 s=null;

private Single1(){

 }public static Single1 getInstance(){

if(s==null){
synchronized (Single1.class){

if(s==null){

s=newSingle1();
}}}return s;
}

}