01_5_Java设计模式

单例设计模式

保证整个软件系统种，对某个类只能存在一个对象实例。

①饿汉式

饿汉式的单例模式：线程安全的，但是会提前创建对象，浪费内存资源

class Singleton { // 1.私有化构造器 
    private Singleton() { }
	// 2.内部提供一个当前类的实例 
    // 4.此实例也必须静态化 
    private static Singleton single = new Singleton();
	// 3.提供公共的静态的方法，返回当前类的对象 
    public static Singleton getInstance() { 
        return single; 
    }
}

②懒汉式

懒汉式的单例模式：等用到对象的适合，再创建对象，节约内存资源，但是线程是不安全的。

class Singleton { 
    // 1.私有化构造器 
    private Singleton() { } 
    // 2.内部提供一个当前类的实例 
    // 4.此实例也必须静态化 
    private static Singleton single; 
    // 3.提供公共的静态的方法，返回当前类的对象 
    public static Singleton getInstance() { 
        if(single == null) { 
            single = new Singleton(); 
        } 
        return single; 
    } 
}

解决懒汉式单例模式的线程安全问题

//第一种方式直接判断bank==null，如果null那么就用synchronized包起来，用一个类锁去锁起来。
//这种方式效率差，因为都想调用getBank方法，如果一个线程进入了，其他再调用getBank的线程也得排在后面等着。
class Bank(){
    private Bank(){}
    private static Bank bank = null;
    
    public static Bank getBank(){
        synchronized(Bank.class){
        	if(bank == null){
            	bank = new Bank();
        }
        return bank;
        }
    }
}
//第二种方式，在进入之前加一个if判断，如果一个线程进入了，其他的通过这一层if就知道里面有人了，就直接跳出来就好啦，就不对去排着等了。效率就高一些。
class Bank(){
    private Bank(){}
    private static Bank bank = null;
    public static Bank getBank(){
        if(bank == null){
            synchronized(Bank.class){
                if(bank == null){
                    bank = new Bank();
                }
            }
        }
        return bank;
    }
}

模板方法设计模式

在软件开发中，整体步骤很固定、通用，这些步骤在父类中已经写好了，但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是模板模式。

public class TemplateTest {
    public static void main(String[] args) {
        Template subTemplate = new SubTemplate();
        subTemplate.code();
        subTemplate.getTime();
    }
}

public abstract class Template {
    public final void getTime(){
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println("执行时间是："+(end - start));
    }

    public abstract void code();
}

class SubTemplate extends Template{
    @Override
    public void code() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
    }
}

代理模式

代理设计是为其他对象提供一种代理以控制对这个对象的访问

package com.atguigu.java1;


public class StaticProxyTest {

	public static void main(String[] args) {
		Proxy s = new Proxy(new RealStar());
		s.confer();
		s.signContract();
		s.bookTicket();
		s.sing();
		s.collectMoney();
	}
}

interface Star {
	void confer();// 面谈

	void signContract();// 签合同

	void bookTicket();// 订票

	void sing();// 唱歌

	void collectMoney();// 收钱
}
//被代理类
class RealStar implements Star {

	public void confer() {
	}

	public void signContract() {
	}

	public void bookTicket() {
	}

	public void sing() {
		System.out.println("明星：歌唱~~~");
	}

	public void collectMoney() {
	}
}

//代理类
class Proxy implements Star {
	private Star real;

	public Proxy(Star real) {
		this.real = real;
	}

	public void confer() {
		System.out.println("经纪人面谈");
	}

	public void signContract() {
		System.out.println("经纪人签合同");
	}

	public void bookTicket() {
		System.out.println("经纪人订票");
	}

	public void sing() {
		real.sing();
	}

	public void collectMoney() {
		System.out.println("经纪人收钱");
	}
}

工厂模式

工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维护，解决方式就是一个“分工”。