单例模式
- 某个类只能有一个实例
- 它必须自行创建这一个实例
- 它必须自行向整个系统提供这个实例
饿汉式(由于调用时 对象已经在构造方法之前加载 耗资源)
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;
}
}
}
}
