Java学习之设计模式

设计模式 ------ 设计思想
大体分为三类：

1. 创建型模式 ----- 用于解决对象创建的过程
   单例模式 工厂方法模式 抽象工厂模式 建造者模式 原型模式
2. 结构型模式 ----- 把类和对象通过某种形式结合在一起，构成某种复杂或合理的结构
   适配器模式 装饰者模式 代理模式 外观模式 桥接模式 组合模式 享元模式
3. 行为型模式 ----- 用来解决类和对象之间的交互，更合理的优化类或对象之间的关系
   观察者模式 策略模式 模板模式 责任链模式 解析器模式 迭代子模式 命令模式 状态模式 备忘录模式 访问者模式 中介者模式

单例模式(Singleton)：

设计 ------>一个类只能创建一个对象 有效的减少内存占用空间
例子：百度是一个类，大家都要用他的搜索的方法，但是我们又不希望每个人都创建新的对象，因为这样要申请大量的空间，所以我们希望所有人申请的都是同一个对象。

class SingleTon{

	//让构造方法变成私有--->保证外面不可以随便创建对象
	//单例不是无例 --- 所以需要在本类中的某个成员位置上创建唯一的对象
	//1.属性 ------- ？
	//2.方法 ------- 无法保证唯一，每一次调用方法都会重新new一个对象
	//3.构造方法里 -- 不行，本身就是构建对象的过程
	//4.程序块 ------ 无返回值，没有办法将生成的对象返回给外部
	private static SingleTon(){}
	// 当前类中存在一个属性，是当前类类型的
	//private保证属性私有，对象无法被外部直接访问
	//static关键字 确保对象只加载一次
	//直接 = new SingleTon() 饿汉式
	private static SingleTon single = new SingleTon();

	//提供给用户获取单个对象的方法给用户
	//返回值 将对象返回出去
	//static 通过类名直接访问方法，不用创建对象
	public static SingleTon getSingleTon(){
		return single;
	}
	/*懒汉式
	public static SingleTon getSingleTon(){
		if (single == null){
			single = new SingleTon(); 
		}
		return single;
	}
	*/

	public static void main(String[] args){
		SingleTon s = SingleTon.getSingleTon();
	}
}

单例模式的实现

1. 私有的构造方法
2. 私有的静态的当前类对象作为属性
3. 公有的静态的方法返回当前类对象

单例模式的三种形式— 对象的加载
饿汉式(立即加载) — 对象在启动时立即加载，
　　优点：不会产生对象没有就拿来使用的问题(空指针异常)，
　　缺点：启动项目加载的对象过多，有些暂时还不需要使用，产生服务器承载压力问题
懒汉式(延迟加载) — 对象什么时候用到什么时候加载
　　优点：启动项目时只有需要的对象加载，不需要的暂时不创建，不会浪费空间
　　缺点：可能由于没有操作好，导致异常
*生命周期托管(单例对象别人帮我们处理) — 对象加载过程交给别人

适配器模式—类适配器，对象适配器模式，缺省适配器模式

缺省适配器模式
接口定义了一个规则，但是并不是所有的子类都需要实现接口中的所有方法，并且接口发生了改变，子类也要发生改变，例如接口中增加的新的方法，那么所有子类都要实现这个新的方法
例：

//定义Box接口,
public interface Box {
	public boolean add();//添加元素到尾部
	public void add(index,element);//添加元素到指定位置
	public void addAll(box);//添加另一个box的所有元素到当前box
	public int get(index);
	public int remove(index);
	public int size();
}
//适配器
public abstract AbstractBox{
	public abstract boolean add();//添加元素到尾部
	public void add(index,element){ // 具体化
		//抛出自定义异常
	}
	public void addAll(box){ // 具体化
		//抛出自定义异常
	}
	public abstract int get(index);
	public abstract int remove(index);
	public abstract abstractint size();
}
//ArrayBox 继承AbstractBox,这样即使没有完全实现Box的所有方法，也可以使用，
//如果要调用addAll等在抽象类中实现的方法，就会返回自定义异常，或者是进行重写
public void ArrayBox extends AbstractBox{
	public boolean add(){
	}
	public int get(index){
	}
	public int remove(index){
	}
	public int size(){
	}
} 
public void LinkedBox extends AbstractBox{
	public boolean add(){
	}
	public void add(index,element){
	}
	public int get(index){
	}
	public int remove(index){
	}
	public int size(){
	}
}

策略模式Strategy — 行为型模式

用来解决执行流程固定，执行结果由于提供了不同的策略而不同
例：

银行类：					//
	办理业务方法(人){ 	// 因为传递的人不一样，所以方法执行结果就不一样，
						//用来提供策略(采用抽象类或接口)，真实执行传递的是子类的对象---多态，
						//执行结果是子类重写之后的效果
	 // 对所有人都一样，流程固定
		欢迎用户
		叫号
		办理业务
		离开
	}
	人类 --- 抽象类 接口 （不能产生对象）
		提供策略 --- 抽象
	具体子类
		实现策略
// 定义一个抽象类
public abstract class Person {
	protected String name;
	public String getName() {
		return this.name;
	}
	// 定义抽象方法
	public abstract void callName();
	public abstract void transact();
	public abstract void leave();
}
// 继承父类，对父类抽象方法进行重写
public class OldMan extends Person {
	public OldMan() {}
	public OldMan(String name) {
		this.name = name;
	}
	public void callName() {
		System.out.println("年纪大了，不会取号，需要找大堂经理帮忙");
	}
	public void transact() {
		System.out.println("存养老金");
	}
	public void leave() {
		System.out.println("大堂经理送老人家出门");
	}
}
// 继承父类，对父类抽象方法进行重写
public class YoungMan extends Person{
	
	public YoungMan() {}
	public YoungMan(String name) {
		this.name = name;
	}
	public void callName() {
		System.out.println("年纪人，自己取号");
	}
	public void transact() {
		System.out.println("存工资");
	}
	public void leave() {
		System.out.println("自己出去");
	}
}
// 继承父类，对父类抽象方法进行重写
public class Toff extends Person{
	
	public Toff() {}
	public Toff(String name) {
			this.name = name;
	}
	
	public void callName() {
		System.out.println("土豪不用取号，进VIP通道");
	}
	public void transact() {
		System.out.println("转账一个亿");
	}
	public void leave() {
		System.out.println("大摇大摆出门");
	}
}

public class Bank{
	//父类作为参数传递
	public void profession(Person person) {
		System.out.println("欢迎"+person.getName()+"!");
		//因为每个子类对方法进行了重写，所以调用的是子类的方法
		person.callName();
		person.transact();
		person.leave();
	}	
	//这种方法避免了每出现一个新的子类就要在Bank中重新写一个方法
	/*
	public void profession(OldMan ol) {
		System.out.println("欢迎"+ol.getName()+"!");
		ol.callName();
		ol.transact();
		ol.leave();
	}
	*/
}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Bank bank = new Bank();
		
		Person p = new OldMan("老年人");
		bank.profession(p);
		
		Person p1 = new YoungMan("年轻人");
		bank.profession(p1);
		
		Person p2 = new Toff("土豪");
		bank.profession(p2);

	}
}
/*
欢迎老年人!
年纪大了，不会取号，需要找大堂经理帮忙
存养老金
大堂经理送老人家出门
欢迎年轻人!
年纪人，自己取号
存工资
自己出去
欢迎土豪!
土豪不用取号，进VIP通道
转账一个亿
大摇大摆出门
*/

================================= 待更新=======================================