设计模式

单例模式

1. 某个类只能有一个实例
2. 它必须自行创建这一个实例
3. 它必须自行向整个系统提供这个实例

饿汉式(由于调用时 对象已经在构造方法之前加载   耗资源)

class SignleTon{
	private static SignleTon s1=new SignleTon();
	private SignleTon() {
		System.out.println("SignleTon");
	}
	
	public static SignleTon getSignleTon() {
		return s1;
	}
}

　懒汉式

 

class SignleTon{
	private static SignleTon s1=null;
	private SignleTon() {
		System.out.println("SignleTon");
	}
	
	public static SignleTon getSignleTon() {
		if (s1==null) {
		    s1=new SignleTon();	
		}
		return s1;
	}
}

　　

模板方法模式

 定义:一个模板方法用一些抽象的操作定义一个算法,而子类将重定义这些操作以提供具体行为

package com.tanlei.newer;

public class TemplateDemo {
    public static void main(String[] args) {
		Template t=new pteacher();
		t.work();
		Template o=new oteacher();
		o.work();
	}
}

abstract class Template {
	// 老师工作方法 流程
	// 模板方法
	public void work() {
		// 1.授课前准备
		prepared();
		// 2.讲课
		teaching();
		// 3.结束
		end();
	}

	public void prepared() {
        System.out.println("准备");
	}

	public void end() {
        System.out.println("结束");
	}
	
	public abstract void teaching();

}

class   pteacher extends Template{

	//对抽象父类的抽象方法实现
	@Override
	public void teaching() {
		System.out.println("数据库老师开始讲课");
		
	}
	
}

class   oteacher extends Template{

	
	@Override
	public void teaching() {
		System.out.println("java老师开始讲课");
		
	}
	
}　　

简单工厂设计模式

 定义:专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类或接口

意图:提供一个类,有它负责根据一定的条件创建某一具体类的实例

 

package com.tanlei.newer;

public class FactoryDemo {
   public static void main(String[] args) {
	  IFrite ifFrite=Factory.getFrite("苹果");
	  if(ifFrite!=null) {
		 System.out.println(ifFrite.get()); 
	  }else {
		  System.out.println("error");
	  }
}
}

interface  IFrite{
	public  String  get();
}


//工厂类
class Factory{
	public static  IFrite getFrite(String name) {
		
		if (name.equals("苹果")) {
			return new APPle();
		}else if(name.equals("橘子")){
			return  new Orage();
		}else {
			return null;
		}
	}
}

class  APPle  implements IFrite{

	@Override
	public String get() {
		
		return "采摘苹果";
	}
	
}

class  Orage  implements IFrite{

	@Override
	public String get() {
		
		return "采摘橘子";
	}
	
}

 

　策略模式

定义:是对算法的包装,把使用算法的责任和算法本身分割开,委派给不同的对象管理

package com.tanlei.newer;

public class StrategyDemo {
   public static void main(String[] args) {
	 int [] array= {2,10,30,4,6,7,8};
	 ISort  sort=new Maopao();
	 Context context=new Context(sort);
	 context.sort(array);
	 context.printArray(array);
	 
	 System.out.println("*************");
	 ISort  sort1=new Xz();
	 Context context2=new Context(sort1);
	 context2.sort(array);
	 context2.printArray(array);
	 }
}
class Context{
	private ISort isort=null;
	public Context(ISort isort) {
		this.isort=isort;
	}
	 public void  sort(int [] array) {
		//交给具体接收到的策略类对象来帮帮忙排序
		 isort.sort(array);
	 }
	 
	 //打印数组中的内容
	 public  void printArray(int []array) {
		 for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+"  ");
		}
	 }
}


interface  ISort{
	public void sort(int [] array);
}

//封装了冒泡排序法
class Maopao implements ISort{

	@Override
	public void sort(int[] array) {
		System.out.println("冒泡排序法");
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-i-1; j++) {
				if (array[j]>array[j+1]) {
					int temp=array[j];
					array[j]=array[j+1];
					array[j+1]=temp;
				}
			}
		}
	}
	
}

//封装了选择排序法
class Xz implements ISort{

	@Override
	public void sort(int[] array) {
		System.out.println("选择排序法");
		int min=0;
		for (int i = 0; i < array.length; i++) {
			min=i;
			for (int j =i+1; j < array.length; j++) {
			   if(array[min]>array[j]) {
				   min=j;
			   }
			}
			if (i!=min) {
				int temp=array[i];
				array[i]=array[min];
				array[min]=temp;
			}
		}
	}
	
}