单例模式/工厂方法模式/抽象工厂模式

单例模式：

public class Person2 {

// 饿汉模式
// private static Person2 person = new Person2();
// private Person2(){}
// public static Person2 getInstacne(){
// return person;
// }

// 静态 内部类-->外部类才能调用
// 静态-->随着类的加载而产生
private static class PersonHolder{
private static final Person2 INSTANCE = new Person2();
}
private Person2(){}
public static Person2 getInstance2(){
return PersonHolder.INSTANCE;
}
// 懒汉模式
// private static Person2 person2;
// private Person2(){}
// public static synchronized Person2 getInstace(){
// if(person==null){
// person = new Person2();
// }
// return person;
// }

}


工厂方法采用的是类继承机制，生成一个子类，重写该工厂方法，在方法内生成一个对象。

抽象工厂采用的是对象组合机制，专门定义”工厂“对象来负责对象的创建

简单用例:

interface icar {
void docar();
}
class bwm implements icar{
@Override
public void docar() {
System.out.println("bwm");
}
}
class bk implements icar{
@Override
//工厂方法采用的是类继承机制（生成一个子类，重写该工厂方法，在该方法中生产一个对象）
public void docar() {
System.out.println("bk");
}
}

interface icarFac{
icar createCar();
}
class bwmFac implements icarFac{

@Override
//抽象工厂采用的是对象组合机制，专门定义“工厂”对象来负责对象的创建
public bwm createCar() {
return new bwm();
}
}
class bkFac implements icarFac{
@Override
public bk createCar() {
return new bk();
}
}
//抽象工厂针对多个产品等级结果
public class test{
public static void main(String[] args) {

icarFac mfac = new bwmFac();
icar m = mfac.createCar();//工厂类负责创建抽象产品的具体子类的实例
m.docar();

mfac = new bkFac();
icar k = mfac.createCar();
k.docar();
}
}