设计模式——工厂、代理、适配器
工厂设计模式、代理设计模式、适配器设计模式
工厂设计模式
在同一个父类(一般是接口)下的子类有多个(通过父类创建子类对象),每想操作一个子类,就必须new一个子类的对象,这样 很容易造成子类的耦合,如果在操作子类、new一个子类 的时候,在他们之间写一个过渡的类,就是工厂设计模式
父类(接口)
//animal父类
public interface Animal {
public void run();
}
子类dog
//dog子类实现animal父类
public class Dog implements Animal{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("dog like run");
}
}
子类cat
//cat子类实现animal父类
public class Cat implements Animal{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("cat like run");
}
}
测试类
public class Test {
public static void main(String[] args) {
Animal a=new Dog();
a.run();
Animal b=new Cat();
b.run();
}
}
得到了
但是如果你想更换操作的子类,你就必须要在Test类更改new的对象,这样的操作在开发中是极其不提倡的一种操作,于是在他们之间加一个过渡类
过渡类
获取name来得知该创建哪一个对象
public class Factory {
public static Animal getAnimal(String name) {
if(name.equals("dog")) {
return new Dog();
}else if(name.equals("cat")) {
return new Cat();
}
return null;
}
}
加了过渡的Test测试类,通过name为dog来new Dog(),从而调用run()方法
public class Test {
public static void main(String[] args) {
Animal a=Factory.getAnimal("dog");
a.run();
}
}
假如添加一个子类Bird
public class Bird implements Animal{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("bird not like run");
}
}
更改过渡类
if(name.equals("dog")) {
return new Dog();
}else if(name.equals("cat")) {
return new Cat();
}else if(name.equals("bird")){
return new Bird();
}
测试类调用Bird方法
Animal a=Factory.getAnimal("bird");
a.run();
代理设计模式
什么是代理设计模式?例如:一个玩家想拿首胜,但是他不想自己打,于是他就在一个平台上招募人代他拿首胜,其中平台就是一个主题、一个接口,那个玩家和代练就是两个实现接口的对象,用官方的话就是:为其他对象提供一种代理以控制对这个对象的访问。
interface subject{//定义一个操作的主题
public void FirstWin();
}
class player implements subject{//玩家实现主题
@Override
public void FirstWin() {
// TODO Auto-generated method stub
System.out.println("我要拿首胜");
}
}
class GamePlayer implements subject{//代练实现主题
private subject sub=null;//subject的空实现对象,用来和player建立联系
public GamePlayer(subject subject) {
// TODO Auto-generated constructor stub
this.sub=subject;
}
public void brfore() {
System.out.println("接单,热身,找手感");
}
@Override
public void FirstWin() {
// TODO Auto-generated method stub
brfore();
this.sub.FirstWin();//代表玩家的想法
after();
}
public void after() {
System.out.println("收钱,欢迎下次光临");
}
}
测试类
public class Demo {
public static void main(String[] args) {
subject s=new player();
subject subject=new GamePlayer(s);
subject.FirstWin();
}
}
结果
适配器设计模式
让原本不能一起工作的两个接口可以一起工作
例如 一个十字螺丝刀是一个接口,它只能扭开十字的钉子,另一个一字的螺丝刀是一个接口,它可以扭开一字的钉子,适配器的作用就是让十字的螺丝刀可以扭开一字的钉子,反之亦然。
interface A{//十字螺丝刀
public void solve();
}
interface B{//一字螺丝刀
public void help();
}
class AImpl implements A {//我是十字螺丝刀
@Override
public void solve() {
// TODO Auto-generated method stub
System.out.println("我可以解决十字的钉子");
}
}
class BImpl implements B {//一字螺丝刀
@Override
public void help() {
// TODO Auto-generated method stub
System.out.println("我可以帮助处理一字的钉子");
}
}
class Adapter implements A,B{//适配器
private A a;
private B b;
public Adapter(A a) {
// TODO Auto-generated constructor stub
this.a=a;
}
public Adapter(B b) {
// TODO Auto-generated constructor stub
this.b=b;
}
@Override
public void help() {
// TODO Auto-generated method stub
a.solve();
}
@Override
public void solve() {
// TODO Auto-generated method stub
b.help();
}
}
测试类
public class Demo05 {
public static void main(String[] args) {
//把十字螺丝刀当成一字的使用
A a=new AImpl();//定义十字螺丝刀
Adapter adapterA=new Adapter(a);//实例化适配器 B,把十字螺丝刀当做一字螺丝刀去使用,当在适配器中调用help()的方法时,会执行 A 的方法
help(adapterA);//其实是调用到Adapter的help()
//solve(adapterA);
}
public static void solve(A a) {//静态方法
a.solve();
}
public static void help(B b) {//静态方法
b.help();
}
}
结果