java 设计模式 1

单例模式：保证一个类仅有一个实例，并且提供一个访问它的全局访问点。

实现方式：
a: 懒汉模式 （同步问题要注意）
public class Singleton{
private static Singleton instance =new Singleton();
private Singleton()
{}
public static Singleton getInstance()
{
return instance;
}
}
b: 饿汉模式
public class Singleton{
private static Singleton instance =null;
private Singleton()
{}
public static synchronized Singleton getInstance()
{
if(instance==null)
instance = new Singleton();
return instance;
}
}

工厂模式： 主要为创建对象提供过渡接口。

>简单工厂模式（静态工厂方法模式）：
组成部分：
a . 具体工厂角色： 正常商业逻辑及判断。
b . 抽象产品角色： 它是具体产品实现的接口。
c . 具体产品角色： 工厂类创建的对象就是此角色实例。
interface Car {
public void driver();
}

class Ben implements Car {

public void driver() {
System.out.println("Ben is Running!!!");
}

}

class Bwn implements Car {

public void driver() {
System.out.println("Bwn is Running!!!");
}
}
class Drive
{
public static Car DriverCar(String s) throws Exception
{
if(s.equals("ben"))
{
return new Ben();
}
if(s.equals("bwn"))
{
return new Bwn();
}
else
throw new Exception();
}
}
public class SimpleFactory {

public static void main(String[] args) {
try{
Car d=Drive.DriverCar("ben");
d.driver();
}catch(Exception e)
{
e.printStackTrace();
}
}
}

> 工厂方法模式：去掉简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。
a . 抽象工厂角色
b .具体工厂角色
c .抽象产品角色
d . 具体产品角色
使用工厂方法模式：
1> . 当客户程序不需要知道要使用对象的创建过程。
2> . 客户程序使用的对象存在变动的可能，或者根本就不知道使用哪一个具体的对象。
interface Car1
{
public void driver();
}
class Ben1 implements Car1
{
public void driver() {
System.out.println("Ben is Running !!!");
}
}
class Bwn1 implements Car1
{
public void driver()
{
System.out.println("Bwn is Running!!!!");
}
}
interface Drive1 {
public Car1 drivers();
}
class BenDrive1 implements Drive1
{
public Car1 drivers()
{
return new Ben1();
}
}
class BwnDrive1 implements Drive1
{
public Car1 drivers()
{
return new Bwn1();
}
}

public class FactoryMethod {

public static void main(String[] args) {
Drive1 d=new BenDrive1();
Car1 car=d.drivers();
car.driver();
}
}
> 抽象工厂模式： 给用户创建一个接口，可以创建多个产品族中的产品对象。
使用条件： 系统中有多个产品族，而且系统一次只能消费其中的一族产品。