黑马程序员技术交流社区

标题: 设计模式之结构型模式 [打印本页]

作者: hehedada 时间: 2019-8-9 14:57
标题: 设计模式之结构型模式
适配器模式：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
个人总结：衔接两个不兼容、独立的接口的功能，使得它们能够一起工作。适配器起中介作用。

public class Adapter {

public static void main(String[] args) {
      //兼容了高级功能的普通播放器
      Player player = new Player();
      player.play();
}
}
//普通的播放器
interface MediaPlayer {
public void play();
}
//高级的播放器
interface AdvanceMediaPlayer {
public void playVideo();
}
//视频播放器（高级的播放器）
class VideoPlayer implements AdvanceMediaPlayer {
@Override
public void playVideo(){
      System.out.println("play video!");
}
}
//适配器(衔接了普通播放器与高级播放器这两个独立接口的功能)
class MediaAdapter implements MediaPlayer {
AdvanceMediaPlayer advanceMediaPlayer;
public MediaAdapter() {
      advanceMediaPlayer = new VideoPlayer();
}
@Override
public void play() {
      advanceMediaPlayer.playVideo();
}
}
//普通播放器
class Player implements MediaPlayer {
//兼容高级播放器的适配器
MediaAdapter mediaAdapter = new MediaAdapter();

@Override
public void play() {
      mediaAdapter.play();
}
}

装饰器模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
个人总结：创建类的装饰类，对被装饰类增强功能。装饰模式是继承的一个替代模式。

public class Decorator {

public static void main(String[] args) {
      Animals dog = new AnimalsDecorator(new Dog());
      dog.run();
}
}
interface Animals {
public void run();
}
//被装饰类
class Dog implements Animals{
@Override
public void run() {
      System.out.println("dog run!");
}
}
//装饰类
class AnimalsDecorator implements Animals {
private Animals animals;
//动态装饰，参数为Animals接口，传入什么实现就装饰什么实现
//继承不能做到这一点，继承的功能是静态的，不能动态增删。
public AnimalsDecorator(Animals animals) {
      this.animals = animals;
}
@Override
//装饰run()方法
public void run() {
      animals.run();
      System.out.println("fast!");
}
}

代理模式：为其他对象提供一种代理以控制对这个对象的访问。
个人总结：创建类的代理类，间接访问被代理类的过程中对其功能加以控制，例如在某个函数执行前后添加额外功能。（代理例子：买火车票不一定在火车站买，也可以去代售点）。和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制，"形式"虽然相似，"语义"却截然不同"。起中介作用

public class Proxy {

public static void main(String[] args) {
      Animals dog = new DogProxy(new Dog());
      dog.run();
}
}
interface Animals {
public void run();
}
class Dog implements Animals {
@Override
public void run() {
      System.out.println("run!");
}
}
//通过代理类，在被代理类的run()方法执行前后添加额外的功能
class DogProxy implements Animals {
private Animals animals;
public DogProxy(Animals animals){
      super();
      this.animals = animals;
}
@Override
public void run() {
      before();
      animals.run();
      atfer();
}
private void atfer() {
      System.out.println("after run!");
}
private void before() {
      System.out.println("before run!");
}
}

外观模式：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
个人总结：在客户端和复杂系统之间再加一层，在这一层中将调用顺序、依赖关系等处理好。提供一个容易使用的外观层。

public class Facade {

public static void main(String[] args) {
      Computer computer = new Computer();
      computer.put();
}
}
class CPU {
public void work(){
      //复杂的操作
      System.out.println("CPU is working!");
}
}
class Disk {
public void put(){
      //复杂的操作
      System.out.println("put in disk!");
}
}
//外观类,隐藏了系统的复杂性，提供简化的方法（访问系统的接口）
//客户端不需要知道系统内部的复杂联系
class Computer {
private CPU cpu;
private Disk disk;

public Computer(){
      cpu = new CPU();
      disk = new Disk();
}
public void work(){
      cpu.work();
}
public void put(){
      disk.put();
}
}

桥接模式：将抽象部分与实现部分分离，使它们都可以独立的变化。
个人总结：通过对Bridge类的调用，实现了对同一接口下不同实现类的调用；建立一个继承于同一抽象的不同实现类之间的关联关系，这个关系由Bridge类桥接起来。

public class Bridge {

public static void main(String[] args) {
      AnimalsBridge bridge = new AnimalsBridge(new Dog());
      bridge.method();
}
}
//接口
interface Animals {
public void method();
}
//实现1
class Cat implements Animals {
@Override
public void method() {
      System.out.println("this is cat!");
}
}
//实现2
class Dog implements Animals {
@Override
public void method() {
      System.out.println("this is dog!");
}
}
//将Animals接口下的不同实现，
//通过桥接模式使它们在抽象层建立一个关联关系。
//实现之间独立变化，减少耦合
class AnimalsBridge {
private Animals animals;
public AnimalsBridge(Animals animals) {
      this.animals = animals;
}
public void method(){
      animals.method();
}
}

组合模式：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
个人总结：创建了一个包含自己对象组的类，并提供修改对象组的方法。应用场景，如树形菜单，文件、文件夹的管理。

public class Composite {

public static void main(String[] args) {
      Person person = new Person("小明");
      person.addFriends(new Person("小红"));
      person.addFriends(new Person("小白"));
      System.out.println(person.getFriends());
}
}
class Person {
private String name;
//包含自己的对象组
private List<Person> friends = new ArrayList<Person>();

public Person(String name){
      this.name = name;
}
public Person addFriends(Person p){
      friends.add(p);
      return this;
}
public String getName(){
      return this.name;
}
public List<Person> getFriends(){
      return this.friends;
}
public String toString(){
      return this.name;
}
}

享元模式：运用共享技术有效地支持大量细粒度的对象。
个人总结：重用现有的同类对象，若未找到匹配的对象，则创建新对象。例如，数据库的连接池。减少对象的创建，降低系统内存，提高效率。

public class Flyweight {

public static void main(String[] args) {
      //red Circle默认存在，所以拿的时候不用new
      Circle circle = CircleFactory.getCircle("red");
      circle.draw();
      for(int i=0;i<2;i++) {
         //第一次拿的时候需要new green Circle，第二次拿的时候不用new
         circle = CircleFactory.getCircle("green");
         circle.draw();
      }
}
}
class Circle {
private String color;
public Circle(String color){
      this.color = color;
}
public void draw(){
      System.out.println(color+" Circle!");
}
}
class CircleFactory {
private static final HashMap<String, Circle> circleMap = new HashMap<String, Circle>();
static {
      //初始化，存放red Circle
      circleMap.put("red", new Circle("red"));
}
public static Circle getCircle(String color) {
      Circle circle = (Circle)circleMap.get(color);
      //Map如果不存在该颜色的Circle，则新建
      if(circle == null) {
         circle = new Circle(color);
         circleMap.put(color, circle);
         System.out.println("new a circle of color: "+color);
      }
      //如果存在，则返回Map中的对象
      return circle;
}
}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2