单例设计模式
饿汉式模式
class Person{
//1.私有化构造器
private Person(){
//dosomething
}
//2.类内创建 该对象,同时要求该对象是static
private static Person personInstance = new Person();
//3. 提供公共的静态方法
public static Person getInstance(){
return personInstance ;
}
}
懒汉式模式
class Person{
//1.私有化构造器
private Person(){
//dosomething
}
//2.声明当前 类对象为null,同时要求该对象是static
private static Person personInstance = null;
//3. 提供公共的静态方法
public static Person getInstance(){ //多线程时，懒汉式不安全
if(personInstance == null){
personInstance = new Person();
}
return personInstance
}
}
饿汉式：好处--->线程安全；坏处---> 对象加载时间过长，不论用不用直接new了
懒汉式：好处--->延迟对象的加载；坏处--->线程不安全
懒汉式-线程安全
// 1.
class Person1{
private Person1(){
//doSomething
}
private static Person1 p= null;
public static synchronized Person1 getInstance(){ //同步方法
if (p== null){
p= new Person1();
}
return p;
}
}
// 2.
public static Person1 getInstance(){
//耗时，当第一个线程进来后，对象已经造好，后来线程不需要再判断
synchronized (Person1.class){
if (p == null)
p = new Person1();
return p;
}
// 效率高
/*if (p == null)
synchronized (Person1.class)
if (p == null)
p = new Person1();
return p;*/
}
代理模式
静态代理
/**
* 主人委托中介卖房子
* */
//卖房子的接口
interface House1{
void sellHouse1();
}
//代理类（中介）
class ProxyHouse implements House1{
private Host1 host1; //真正的主人
public ProxyHouse(Host1 host1){
this.host1 = host1;
}
@Override
public void sellHouse1() {
seeHouse();
host1.sellHouse1();
money();
}
public void seeHouse(){
System.out.println("中介带看房");
}
public void money(){
System.out.println("收中介费");
}
}
//被代理类（主人 ）
class Host1 implements House1{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void sellHouse1() {
System.out.println("我是主人"+getName()+"我要卖房子");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
Host1 host1 = new Host1();
host1.setName("Jack");
ProxyHouse proxyHouse = new ProxyHouse(host1);
proxyHouse.sellHouse1();
}
}
/**结果：
中介带看房
我是主人Jack我要卖房子
收中介费
*/
动态代理
//接口
interface House{
void rent(); //出租房子
}
//被代理类,真实类
class Host implements House{
@Override
public void rent() {
System.out.println("主人要租房子");
}
}
class ProxyInvocationHandler implements InvocationHandler{
//被代理的类，即真实类
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
//获取代理对象
public Object getProxyInstance(){
//newProxyInstance(ClassLoader loader, 参数1：代理的那个类的类加载，也即真实类(被代理类)
// Class<?>[] interfaces, 中介 或者 被代理类实现的接口
// InvocationHandler h) //调度处理器
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
//Object invoke(Object obj, Object... args)
//参数1-obj：被代理类的对象，参数2-args：该方法形参
Object invoke = method.invoke(obj, args);//通过反射调用方法
after();
return invoke;
}
public void before(){
System.out.println("卖房子--前");
}
public void after(){
System.out.println("卖房子--后");
}
}
public class DynamicProxyTest {
public static void main(String[] args) {
Host host = new Host(); //真实对象
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setObject(host);
House proxyInstance = (House) pih.getProxyInstance(); //这才是代理对象
proxyInstance.rent();
}
}
/** 结果
卖房子--前
主人要租房子
卖房子--后
*/
工厂模式
① 实例化对象不使用new ，用工厂方法代替 ② 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们实现的类解耦。
静态(简单)工厂模式
编写Car接口，ACar类，BCar类，CarFactory
//Car接口
public interface Car {
void name();
}
//ACar 类实现Car接口
public class ACar implements Car{
@Override
public void name() {
System.out.println("我是A车");
}
}
//BCar 类实现Car接口
public class BCar implements Car{
@Override
public void name() {
System.out.println("我是B车");
}
}
//CarFactory 工厂类
public class CarFactory {
public static Car getCar(String car){
if (car.equals("A车")){
return new ACar();
}else if(car.equals("B车")){
return new BCar();
}else return null;
}
}
编写测试类
public void test(){
/** 原始写法
Car car2 = new ACar();
car2.name();
Car car3 = new BCar();
car3.name();
*/
//工厂模式的写法 在这里不用new car()对象，也就是不用知道内部造车的细节。只需要通过工厂拿到车即可
Car car = CarFactory.getCar("A车");
car.name();
Car car1 = CarFactory.getCar("B车");
car1.name();
}
该简单工厂模式存在的问题：不遵循开闭原则(开闭原则：不修改原来的代码，同时可以增加模块功能)，若：此时在 加一个CCar类，则工厂CarFactory里面的代码逻辑就要修改，违法了开闭原则。
工厂方法模式
编写Car接口和CarFactory
//Car
public interface Car {
void name();
}
//CarFactory
public interface CarFactory {
Car getCar();
}
编写ACar类，AcarFactory类 让AcarFactory实现CarFactory
public class ACar implements Car {
@Override
public void name() {
System.out.println("我是A车");
}
}
public class ACarFactory implements CarFactory{
@Override
public Car getCar() {
return new ACar();
}
}
编写BCar类，BcarFactory类 让BcarFactory实现CarFactory
public class BCar implements Car {
@Override
public void name() {
System.out.println("我是B车");
}
}
public class BCarFactory implements CarFactory{
@Override
public Car getCar() {
return new BCar();
}
}
编写测试类：
public void test(){
Car car = new ACarFactory().getCar(); //造A车
car.name();
Car car1 = new BCarFactory().getCar(); ／／造B车
car1.name();
}
当继续扩展C车时，只需要编写CCar类和CCarFactory，实现了开闭原则，但是类增多了
原型模式
其实就是克隆对象。