常用java设计模式实例
单例模式
是确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
注意：
某个类只能有一个实例。
类必须自行创建这个实例。
以公共、统一的方式向整个系统提供这个实例。
饿汉式
//饿汉式，程序启动则立即加载
public class EagerSingleton {
private static EagerSingleton instanace=new EagerSingleton();
public EagerSingleton() {
}
public static EagerSingleton getInstance() {
return instanace;
}
}
懒汉式
//懒汉式，调用的时候才加载
public class LazySingleton {
private static LazySingleton instance;
public LazySingleton() {
}
public static synchronized LazySingleton getInstance() {
if(instance !=null) {
instance =new LazySingleton();
}
return instance;
}
}
优化后的懒汉式
//优化后的懒汉式，采用内部类，放弃加锁。节省时间和空间
public class GoodLazySingleton {
private static class inner{
private static GoodLazySingleton instance=new GoodLazySingleton();
}
public GoodLazySingleton() {}
public static GoodLazySingleton getInstance() {
return inner.instance;
}
}
测试
//只需要判断两个对象是否相等，即可得出每次产生的均为同一个对象
public class Test {
public static void main(String[] args) {
System.out.println(EagerSingleton.getInstance() == EagerSingleton.getInstance() );
System.out.println(LazySingleton.getInstance() == LazySingleton.getInstance());
System.out.println(GoodLazySingleton.getInstance() == GoodLazySingleton.getInstance());
}
}
策略模式
代码
public interface Action {
void start();
void run();
}
测试
public class Test {
public static void done(Action action) {
System.out.println("第一步：*************");
action.start();
System.out.println("第三步：*************");
action.run();
System.out.println("第五步：*************");
}
public static void main(String[] args) {
done(new Action() {
public void start() {
System.out.println("启动**********");
}
public void run() {
System.out.println("开始跑！************");
}
});
}
}
代理模式
代码
public interface 请客者 {
void 请客();
}
public class Boss implements 请客者 {
@Override
public void 请客() {
System.out.println("我是老板我请客");
}
}
public class MiShu implements 请客者 {
private 请客者 q;
public MiShu(请客者 q) {
this.q=q;
}
@Override
public void 请客() {
System.out.println("下班后请大家吃饭");
this.q.请客();
System.out.println("过后再聚");
}
}
测试
public class Test {
public static void main(String[] args) {
请客者 qk = new MiShu(new Boss());
qk.请客();
}
}
工厂模式
代码
public class FruitFactory {
public static final int FRUIT_TYPE_APPLE=1;
public static final int FRUIT_TYPE_BANANA=2;
public static final int FRUIT_TYPE_ORANGE=3;
public static Fruit createFruit(int type) {
switch (type) {
case 1:return new Apple();
case 2:return new Banana();
case 3:return new Orange();
default:throw new RuntimeException("本厂不生产该水果");
}
}
}
public interface Fruit {
void show();
}
public class Apple implements Fruit {
public void show() {
System.out.println("生产出了苹果");
}
}
public class Banana implements Fruit {
public void show() {
System.out.println("生产出了香蕉");
}
}
public class Orange implements Fruit {
public void show() {
System.out.println("生产出了橙子");
}
}
测试
public class Test {
public static void main(String[] args) {
Fruit f= FruitFactory.createFruit(FruitFactory.FRUIT_TYPE_APPLE);
Fruit f1= FruitFactory.createFruit(FruitFactory.FRUIT_TYPE_BANANA);
Fruit f2= FruitFactory.createFruit(FruitFactory.FRUIT_TYPE_ORANGE);
f.show();
f1.show();
f2.show();
}
}
适配器模式
代码
public class Adapter implements FN {
private Funner fun;
public Adapter(Funner fun) {
super();
this.fun = fun;
}
@Override
public void save(Object[] obj) {
for(Object o:obj) {
fun.insert(o);
}
}
@Override
public void delete(Object obj) {
fun.remove(obj);
}
}
public interface FN {
void save(Object [] obj);
void delete(Object obj);
}
public class Funner {
public void insert(Object obj) {
System.out.println("添加数据："+obj);
}
public void remove(Object obj) {
System.out.println("删除数据："+obj);
}
}
测试
public class Test {
static void test(FN fn) {
fn.save(new Object[] {1,2,3,4,5,6,9});
fn.delete(5);
}
public static void main(String[] args) {
test(new Adapter(new Funner()));
}
}
责任链模式
代码
public class Res {
private int days;
public Res(int days) {
super();
this.days = days;
}
public int getDays() {
return days;
}
public void setDays(int days) {
this.days = days;
}
}
public abstract class Hander {
private Hander nextHander;
public Hander(Hander nextHander) {
super();
this.nextHander = nextHander;
}
public abstract void handle(Res res);
public Hander getNextHander() {
return nextHander;
}
}
public class TeamLeader extends Hander{
public TeamLeader(Hander nextHander) {
super(nextHander);
}
@Override
public void handle(Res res) {
System.out.println("项目组长同意！");
if(res.getDays()>1) {
getNextHander().handle(res);;
}
}
}
public class PM extends Hander {
public PM(Hander nextHander) {
super(nextHander);
// TODO Auto-generated constructor stub
}
@Override
public void handle(Res res) {
System.out.println("项目经理同意");
if(res.getDays()>3) {
getNextHander().handle(res);
}
}
}
public class Boss extends Hander {
public Boss(Hander nextHander) {
super(nextHander);
// TODO Auto-generated constructor stub
}
@Override
public void handle(Res res) {
System.out.println("总经理同意！");
}
}
测试
public class Test {
public static void main(String[] args) {
Hander hd= new TeamLeader(new PM(new Boss(null)));
hd.handle(new Res(4));
}
}
装饰者模式
代码
public interface Animal {
abstract void run();
}
public abstract class Decorator implements Animal {
private Animal animal;
public Decorator(Animal animal) {
super();
this.animal = animal;
}
public Animal getAnimal() {
return animal;
}
}
public class Dancer extends Decorator {
public Dancer(Animal animal) {
super(animal);
// TODO Auto-generated constructor stub
}
@Override
public void run() {
System.out.print("会跳舞的");
getAnimal().run();
}
}
public class Tail extends Decorator {
public Tail(Animal animal) {
super(animal);
// TODO Auto-generated constructor stub
}
@Override
public void run() {
System.out.print("会摇尾巴的");
getAnimal().run();
}
}
public class Dog implements Animal {
@Override
public void run() {
System.out.println("狗用四条腿在陆地上跑");
}
}
public class Fish implements Animal{
@Override
public void run() {
System.out.println("鱼在水里游泳");
}
}
测试
public class Test {
public static void main(String[] args) {
Animal a = new Tail(new Dancer(new Dog()));
a.run();
}
}
