所谓单例模式,就是确保一个类仅有一个实例,并提供一个访问它的全局访问点。单例模式又分为饿汉式单例和懒汉式单例。
第一次引用该类的时候就创建对象实例,而不管实际是否需要创建。
public class Test {
private static final Test instance=new Test();
private Test(){}
public static Test getInstance(){
return instance;
}
}
什么时候用就什么时候创建实例,存在线程安全问题。实例在开始时为空,第一次加载后才实例化。
public class Test {
private volatile static Test instance=null;
private Test(){}
public static Test getInstance(){
if(instance==null) {
instance=new Test();
}
return instance;
}
}
双重锁模式,是对饱汉模式的优化,进行双重判断,当已经创建过实例对象后就无需加锁。
public class Test {
private volatile static Test instance=null;
private Test(){}
public static Test getInstance(){
if(instance==null) {
synchronized (Test.class){
if(instance==null) {
instance=new Test();
}
}
}
return instance;
}
}
工厂模式将创建对象的具体过程屏蔽隔离起来。工厂模式可以分为三类:简单工厂模式、工厂方法模式、抽象工厂模式。
简单工厂模式最重要的就是定义一个创建对象的接口。
Pizza类:
abstract class Pizza {
public Pizza(){}
}
public class FruitPizza extends Pizza{
public FruitPizza() {
System.out.println("水果披萨");
}
}
public class MeatPizza extends Pizza{
public MeatPizza(){
System.out.println("肉披萨");
}
}
工厂类:
public class PizzaFactory {
public Pizza createPizza(int type) {
switch (type) {
case 1:
return new FruitPizza();
case 2:
return new MeatPizza();
default:
break;
}
return null;
}
}
承接上例中的Pizza类。
工厂类:
interface FactoryPizza {
Pizza createPizza();
}
public class FactoryFruitPizza implements FactoryPizza{
@Override
public FruitPizza createPizza() {
return new FruitPizza();
}
}
public class FactoryMeatPizza implements FactoryPizza {
@Override
public MeatPizza createPizza() {
return new MeatPizza();
}
}
相机相关类:
//镜头
public interface Lens {}
public class LensA implements Lens{
public LensA(){
System.out.println("索尼镜头");
}
}
public class LensB implements Lens{
public LensB(){
System.out.println("佳能镜头");
}
}
//机身
public interface CameraBody {}
public class CameraBodyA implements CameraBody{
public CameraBodyA(){
System.out.println("索尼机身");
}
}
public class CameraBodyB implements CameraBody{
public CameraBodyB(){
System.out.println("佳能机身");
}
}
相机代理商类:
public interface CameraFactory {
public Lens createLens();
public CameraBody createCameraBody();
}
//生产索尼相机
public class FactorySONY implements CameraFactory{
@Override
public Lens createLens() {
return new LensA();
}
@Override
public CameraBody createCameraBody() {
return new CameraBodyA();
}
}
//佳能相机
public class FactoryCanon implements CameraFactory{ {
@Override
public Lens createLens() {
return new LensB();
}
@Override
public CameraBody createCameraBody() {
return new CameraBodyB();
}
}
建造者模式旨在把一个流程分解到不同的方法中,避免某个方法过于繁重,每个方法相互独立。
穿搭类:
public class Dressing {
private String clothes;
private String shoes;
public String getClothes() {
return clothes;
}
public void setClothes(String clothes) {
this.clothes = clothes;
}
public String getShoes() {
return shoes;
}
public void setShoes(String shoes) {
this.shoes = shoes;
}
}
穿搭构造类:
public abstract class DressingBuilder {
Dressing dressing= new Dressing();
public abstract void buildClothes();
public abstract void buildShoes();
public Dressing getDressing(){
return dressing;
}
}
穿搭A、穿搭B。
public class DressingA extends DressingBuilder{
public void buildClothes() {
dressing.setClothes("衣服A");
}
public void buildShoes() {
dressing.setShoes("鞋子A");
}
}
public class DressingB extends DressingBuilder{
public void buildClothes() {
dressing.setClothes("衣服B");
}
public void buildShoes() {
dressing.setShoes("鞋子B");
}
}
最后由构建人员搭配衣服
public class DressingPerson{
private DressingBuilder dressingBuilder;
public void setDressingBuilder(DressingBuilder dressingBuilder) {
this.dressingBuilder = dressingBuilder ;
}
public Dressing construct(){
dressingBuilder.buildClothes();
dressingBuilder.buildShoes();
return dressingBuilder.getDressing();
}
}