类被加载时生成对象
• 直接定义一个静态变量指向类的引用

/*
* 单例模式-懒汉
*
*/
public class SingletonPattern01 {
// 私有的静态引用
private static SingletonPattern01 singletonPattern01 = null;

// 私有构造器
private SingletonPattern01() {
// TODO Auto-generated constructor stub
}

// 公共静态访问方式
public static SingletonPattern01 getSingletonPattern01() {
if (singletonPattern01 == null) {
singletonPattern01 = new SingletonPattern01();
}
return singletonPattern01;
}
}

/*
* 单例模式-饿汉
*/
public class SingletonPattern02 {
// 私有的静态引用
private static SingletonPattern02 singletonPattern01 = new SingletonPattern02();

// 私有构造器
private SingletonPattern02() {
// TODO Auto-generated constructor stub
}

// 公共静态访问方式
public static SingletonPattern02 getSingletonPattern02() {
return singletonPattern01;
}
}

工厂模式

组成

• 抽象产品角色：接口或抽象父类，定义方法
• 具体产品角色：抽象的具体子类实现
• 工厂角色：根据情况创建父类的具体产品角色(具体实例)，根据实际情况创建多态的父类，由于父类有重写，可以直接调用对应的子类实现

使用

import java.util.*;
/*
* 工厂模式-简单工厂模式
* 1.抽象产品角色：定义抽象的父类或接口
* 2.具体产品角色：具体实现的子类
* 3.工厂角色：产生父类，根据实际情况创建多态的父类，由于父类有重写，直接调用对应的子类实现
*/

public class FactoryMethodTest {
// 测试
public static void main(String[] args) {
FatherInterface car = null;
System.out.print("请输入想要造的车：");
Scanner input = new Scanner(System.in);
String carName = input.next();
car = Factory.creatRun(carName);
car.CarType();
}
}

class Factory {
public static FatherInterface creatRun(String carName) {
FatherInterface newCar = null;
if ("Benz".equals(carName)) {
newCar = new Benz();
}
if ("Audi".equals(carName)) {
newCar = new Audi();
}
if ("BMW".equals(carName)) {
newCar = new BMW();
}
return newCar;
}
}

interface FatherInterface {
void CarType();
}

class Benz implements FatherInterface {
@Override
public void CarType() {
// TODO Auto-generated method stub
System.out.println("奔驰有特征么？");
}
}

class Audi implements FatherInterface {
@Override
public void CarType() {
// TODO Auto-generated method stub
System.out.println("奥迪灯厂");
}
}

class BMW implements FatherInterface {
@Override
public void CarType() {
// TODO Auto-generated method stub
System.out.println("宝马板牙");
}
}

静态代理

组成

• 接口：定义方法
• 中间代理：实现接口，在实现过程中引用具体实现
• 具体角色：实现接口，被中间代理调用