精华内容
下载资源
问答
  • Java 适配器模式

    2017-02-06 17:23:53
    Java 适配器模式

    1. 什么是适配器模式

    适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。
    这种设计模式属于结构型模式,它结合了两个独立接口的功能。这种模式涉及到一个单一的类,该类负责加入独立的或不兼容的接口功能。
    通过下面的实例来演示适配器模式的使用。其中,音频播放器设备只能播放 mp3 文件,通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。

    2. 简单介绍

    2.1 意图

    将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

    2.2 主要解决问题

    主要解决在软件系统中,常常要将一些”现存的对象”放到新的环境中,而新环境要求的接口是现对象不能满足的。

    2.3 何时使用

    1. 系统需要使用现有的类,而此类的接口不符合系统的需要。
    2. 想要建立一个可以重复使用的类,用于与一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作,这些源类不一定有一致的接口。
    3. 通过接口转换,将一个类插入另一个类系中。(比如老虎和飞禽,现在多了一个飞虎,在不增加实体的需求下,增加一个适配器,在里面包容一个虎对象,实现飞的接口。)

    2.4 如何解决

    继承或依赖(推荐)。

    2.5 关键代码

    适配器继承或依赖已有的对象,实现想要的目标接口。

    2.6 应用实例

    1. 美国电器 110V,中国 220V,就要有一个适配器将 110V 转化为 220V。
    2. JAVA JDK 1.1 提供了 Enumeration 接口,而在 1.2 中提供了 Iterator 接口,想要使用 1.2 的 JDK,则要将以前系统的Enumeration 接口转化为 Iterator 接口,这时就需要适配器模式。
    3. 在 LINUX 上运行 WINDOWS 程序。
    4. JAVA 中的 jdbc。

    2.7 优点

    1. 可以让任何两个没有关联的类一起运行。
    2. 提高了类的复用。
    3. 增加了类的透明度。
    4. 灵活性好。

    2.8 缺点

    1. 过多地使用适配器,会让系统非常零乱,不易整体进行把握。比如,明明看到调用的是 A 接口,其实内部被适配成了 B 接口的实现,一个系统如果太多出现这种情况,无异于一场灾难。因此如果不是很有必要,可以不使用适配器,而是直接对系统进行重构。
    2. 由于 JAVA 至多继承一个类,所以至多只能适配一个适配者类,而且目标类必须是抽象类。

    2.9 使用场景

    有动机地修改一个正常运行的系统的接口,这时应该考虑使用适配器模式。

    2.10 注意事项

    适配器不是在详细设计时添加的,而是解决正在服役的项目的问题。

    3. 代码实现

    有一个 MediaPlayer 接口和一个实现了 MediaPlayer 接口的实体类 AudioPlayer。默认情况下,AudioPlayer 可以播放 mp3 格式的音频文件。
    还有另一个接口 AdvancedMediaPlayer 和实现了AdvancedMediaPlayer 接口的实体类。该类可以播放 vlc 和 mp4 格式的文件。
    想要让 AudioPlayer 播放其他格式的音频文件。为了实现这个功能,需要创建一个实现了 MediaPlayer 接口的适配器类 MediaAdapter,并使用 AdvancedMediaPlayer 对象来播放所需的格式。
    AudioPlayer 使用适配器类 MediaAdapter 传递所需的音频类型,不需要知道能播放所需格式音频的实际类。AdapterPatternDemo,演示类使用 AudioPlayer 类来播放各种格式。

    3.1 步骤 1

    为媒体播放器和更高级的媒体播放器创建接口。

    MediaPlayer.java

    public interface MediaPlayer {
       public void play(String audioType, String fileName);
    }

    AdvancedMediaPlayer.java

    public interface AdvancedMediaPlayer {  
       public void playVlc(String fileName);
       public void playMp4(String fileName);
    }

    3.2 步骤 2

    创建实现了 AdvancedMediaPlayer 接口的实体类。

    VlcPlayer.java

    public class VlcPlayer implements AdvancedMediaPlayer{
       @Override
       public void playVlc(String fileName) {
          System.out.println("播放vlc文件名称: "+ fileName);      
       }
    
       @Override
       public void playMp4(String fileName) {
          //什么也不做
       }
    }

    Mp4Player.java

    public class Mp4Player implements AdvancedMediaPlayer{
    
       @Override
       public void playVlc(String fileName) {
          //什么也不做
       }
    
       @Override
       public void playMp4(String fileName) {
          System.out.println("播放mp4文件名称: "+ fileName);      
       }
    }

    3.3 步骤 3

    创建实现了 MediaPlayer 接口的适配器类。

    MediaAdapter.java

    public class MediaAdapter implements MediaPlayer {
    
       AdvancedMediaPlayer advancedMusicPlayer;
    
       public MediaAdapter(String audioType){
          if(audioType.equalsIgnoreCase("vlc") ){
             advancedMusicPlayer = new VlcPlayer();         
          } else if (audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer = new Mp4Player();
          } 
       }
    
       @Override
       public void play(String audioType, String fileName) {
          if(audioType.equalsIgnoreCase("vlc")){
             advancedMusicPlayer.playVlc(fileName);
          }else if(audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer.playMp4(fileName);
          }
       }
    }

    3.4 步骤 4

    创建实现了 MediaPlayer 接口的实体类。

    AudioPlayer.java

    public class AudioPlayer implements MediaPlayer {
       MediaAdapter mediaAdapter; 
    
       @Override
       public void play(String audioType, String fileName) {        
    
          //播放 mp3 音乐文件的内置支持
          if(audioType.equalsIgnoreCase("mp3")){
             System.out.println("播放mp3文件名称: "+ fileName);           
          } 
          //mediaAdapter 提供了播放其他文件格式的支持
          else if(audioType.equalsIgnoreCase("vlc") 
             || audioType.equalsIgnoreCase("mp4")){
             mediaAdapter = new MediaAdapter(audioType);
             mediaAdapter.play(audioType, fileName);
          }
          else{
             System.out.println("无效的媒体文件 "+
                audioType + "格式不支持");
          }
       }   
    }

    3.5 步骤 5

    使用 AudioPlayer 来播放不同类型的音频格式。

    AdapterPatternDemo.java

    public class AdapterPatternDemo {
       public static void main(String[] args) {
          AudioPlayer audioPlayer = new AudioPlayer();
    
          audioPlayer.play("mp3", "爱情告白.mp3");
          audioPlayer.play("mp4", "西游降魔2.mp4");
          audioPlayer.play("vlc", "功夫.vlc");
          audioPlayer.play("avi", "功夫瑜伽.avi");
       }
    }

    3.6 步骤 6

    验证输出。

    播放mp3文件名称: 爱情告白.mp3
    播放mp4文件名称: 西游降魔2.mp4
    播放vlc文件名称: 功夫.vlc
    无效的媒体文件 avi格式不支持

    展开全文
  • java适配器模式

    2018-01-03 22:00:45
    java适配器模式 java外观模式 适配器模式:将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 适配器模式有两种:类的适配器模式和对象...

    其他设计模式
    java单例模式
    java建造者模式
    java策略模式
    java代理模式
    java观察者模式
    java适配器模式
    java外观模式
    适配器模式:将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
    适配器模式有两种:类的适配器模式和对象的适配器模式

    1.对象适配器

    对象适配器结构图.png

    Target(这是客户所期待的接口。目标可以是具体的或抽象的类,也可以是接口)代码如下:

    public interface Target {
        public void request();
    }

    Adaptee(需要适配的类)代码如下:

    public class Adaptee {
        public void specificRequest(){
        }
    }

    Adapter(通过在内部包装一个Adaptee对象,把源对象接口转换成目标接口)代码如下:

    public class Adapter implements Target{
        private Adaptee adaptee=new Adaptee();
        @Override
        public void request() {
            adaptee.specificRequest();
        }
    }

    客户端代码如下:

    public class TestAdapter {
        public static void main(String[] args) {
            Target target = new Adapter();
            target.request();
        }
    }
    2.类适配器

    与对象适配器模式不同的是,类适配器模式是使用继承关系连接到Adaptee类,而不是使用委派关系连接到Adaptee类。

    只需改变对象适配器的Adapter代码, Target和Adaptee保持一致,Adapter代码如下:

    public class Adapter extends Adaptee implements Target{
        @Override
        public void request() {
            this.specificRequest();
        }
    }
    3.实例讲解

    火箭队比赛,教练暂停时给中国球员Zhou分配进攻和防守任务。但是Zhou刚去NBA,没学过英语,听不懂教练分配的任务,所以这时候需要翻译,此时翻译就相当于适配器。

    NBA球员抽象类,都有进攻(attack)和防守(defense)的方法。

    public interface Player {
        public void attack();
        public void defense();
    }

    Zhou类(Adaptee),听不懂attack和defense,只知道进攻和防守

    public class Zhou {
        public void 进攻() {
            System.out.print("进攻");
        }
    
        public void 防守() {
            System.out.print("防守");
        }
    }

    翻译类(Adapter)此处采用对象适配器

    public class Translator implements Player{
        private Zhou zhou=new Zhou();
        @Override
        public void attack() {
           zhou.进攻();
        }
    
        @Override
        public void defense() {
            zhou.防守();
        }
    }

    客户端调用:打印出攻击防守

    public class TestAdapter {
        public static void main(String[] args) {
            Player player=new Translator();
            player.attack();
            player.defense();
        }
    }

    如果上述要改成类适配器,只需改变Translator类

    public class Translator extends Zhou implements Player{
        @Override
        public void attack() {
           this.进攻();
        }
    
        @Override
        public void defense() {
            this.防守();
        }
    }
    优点:
    • 更好的复用性
    • 更好的扩展性
    缺点:
    • 过多的使用适配器,会让系统非常零乱,不容易整体进行把握。
    何时选用适配器模式:
    • 如果你想要使用一个已经存在的类,但是它的接口不符合你的需求,这种情况可以使用适配器模式,来把已有的实现转换成你需要的接口。
    • 如果你想创建一个可以复用的类,这个类可能和一些不兼容的类一起工作,这种情况可以使用适配器模式,到时候需要什么就适配什么。
    • 如果你想使用一些已经存在的子类,但是不可能对每一个子类都进行适配,这种情况可以选用对象适配器,直接适配这些子类的父类就可以了。
    展开全文
  • Java适配器模式

    2017-07-05 14:04:56
    Java适配器模式 适配器模式作为两个不兼容接口之间的桥梁。 这种类型的设计模式属于结构模式,因为该模式组合了两个独立接口。 这种模式涉及一个单独的类,它负责连接独立或不兼容接口的功能。 现实生活的...
    Java适配器模式


    适配器模式作为两个不兼容接口之间的桥梁。 这种类型的设计模式属于结构模式,因为该模式组合了两个独立接口。


    这种模式涉及一个单独的类,它负责连接独立或不兼容接口的功能。 现实生活的例子- 读卡器的,其用作为存储卡和笔记本电脑之间的适配器。将存储卡插入读卡器并将读卡器插入笔记本电脑接口,以便可以通过笔记本电脑读取存储卡。


    我们通过以下示例演示适配器模式的使用。音频播放器设备只能播放mp3文件,但希望能够实现一个可播放vlc和mp4文件的高级音频播放器。


    实现实例


    有一个MediaPlayer接口和一个具体的类-AudioPlayer它实现了MediaPlayer接口。 默认情况下,音频播放器(AudioPlayer )可以播放mp3格式的音频文件。


    还有另一个接口AdvancedMediaPlayer 和实现AdvancedMediaPlayer 接口的具体类。 这些类可以播放vlc和mp4格式的文件。


    想让AudioPlayer播放其他格式。要实现这一点,需要创建了一个适配器类MediaAdapter,它实现了MediaPlayer接口并使用AdvancedMediaPlayer对象来播放所需的格式。


    AudioPlayer使用适配器类MediaAdapter传递它所需的音频类型,而不知道可以播放所需格式的实际类。 AdapterPatternDemo这是一个演示类,它将使用AudioPlayer类来播放各种格式。


    实现结构如下图所示 -






    第1步


    分别创建媒体播放器和高级媒体播放器接口。代码如下所示 -


    MediaPlayer.java




     
    public interface MediaPlayer {
       public void play(String audioType, String fileName);
    }
    Java
    AdvancedMediaPlayer.java


    public interface AdvancedMediaPlayer {    
       public void playVlc(String fileName);
       public void playMp4(String fileName);
    }
    Java
    第2步


    创建实现AdvancedMediaPlayer接口的具体类。


    VlcPlayer.java


    public class VlcPlayer implements AdvancedMediaPlayer{
       @Override
       public void playVlc(String fileName) {
          System.out.println("Playing vlc file. Name: "+ fileName);
       }


       @Override
       public void playMp4(String fileName) {
          //do nothing
       }
    }
    Java
    Mp4Player.java




    public class Mp4Player implements AdvancedMediaPlayer{


       @Override
       public void playVlc(String fileName) {
          //do nothing
       }


       @Override
       public void playMp4(String fileName) {
          System.out.println("Playing mp4 file. Name: "+ fileName);        
       }
    }
    Java
    第3步


    创建实现MediaPlayer接口的适配器类。


    MediaAdapter.java


    public class MediaAdapter implements MediaPlayer {


       AdvancedMediaPlayer advancedMusicPlayer;


       public MediaAdapter(String audioType){


          if(audioType.equalsIgnoreCase("vlc") ){
             advancedMusicPlayer = new VlcPlayer();            


          }else if (audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer = new Mp4Player();
          }    
       }


       @Override
       public void play(String audioType, String fileName) {


          if(audioType.equalsIgnoreCase("vlc")){
             advancedMusicPlayer.playVlc(fileName);
          }
          else if(audioType.equalsIgnoreCase("mp4")){
             advancedMusicPlayer.playMp4(fileName);
          }
       }
    }
    Java
    第4步


    创建一个实现MediaPlayer接口的具体类。


    AudioPlayer.java


    public class AudioPlayer implements MediaPlayer {
       MediaAdapter mediaAdapter; 


       @Override
       public void play(String audioType, String fileName) {        


          //inbuilt support to play mp3 music files
          if(audioType.equalsIgnoreCase("mp3")){
             System.out.println("Playing mp3 file. Name: " + fileName);            
          } 


          //mediaAdapter is providing support to play other file formats
          else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
             mediaAdapter = new MediaAdapter(audioType);
             mediaAdapter.play(audioType, fileName);
          }


          else{
             System.out.println("Invalid media. " + audioType + " format not supported");
          }
       }   
    }
    Java
    第5步


    使用AudioPlayer播放不同类型的音频格式。


    AdapterPatternDemo.java




    public class AdapterPatternDemo {
       public static void main(String[] args) {
          AudioPlayer audioPlayer = new AudioPlayer();


          audioPlayer.play("mp3", "beyond the horizon.mp3");
          audioPlayer.play("mp4", "alone.mp4");
          audioPlayer.play("vlc", "far far away.vlc");
          audioPlayer.play("avi", "mind me.avi");
       }
    }
    Java
    第6步


    验证输出结果,执行上面的代码得到以下结果 -


    Playing mp3 file. Name: beyond the horizon.mp3
    Playing mp4 file. Name: alone.mp4
    Playing vlc file. Name: far far away.vlc
    Invalid media. avi format not supported
    展开全文
  • 本文实例讲述了Java适配器模式应用之电源适配器功能。分享给大家供大家参考,具体如下:一、模式定义存在两种适配器模式1 对象适配器模式,在这种适配器模式中,适配器容纳一个它包裹的类对象的物理实体。2 类适配器...

    本文实例讲述了Java适配器模式应用之电源适配器功能。分享给大家供大家参考,具体如下:

    一、模式定义

    存在两种适配器模式

    1 对象适配器模式,在这种适配器模式中,适配器容纳一个它包裹的类对象的物理实体。

    2 类适配器模式,在这种适配器模式中,适配器继承自已实现的类。

    二、模式举例

    1 模式分析

    我们借用笔计本电源适配器来说明这一模式。

    已经存在的交流电源

    笔记本电脑

    电源适配器

    b9c39f364ff644855524f2da23867ac6.png

    2 适配器模式的静态建模

    0d7e1fe204ae478d6a486964f7756e04.png

    3 代码举例

    3.1 抽象电源建立

    package com.demo.power;

    /**

    * 电源基类

    *

    * @author

    *

    */

    public abstract class AbsBasePower

    {

    // 电压值

    private float power;

    // 单位

    private String unit = "V";

    // 构造方法

    public AbsBasePower(float power)

    {

    this.power = power;

    }

    public float getPower()

    {

    return power;

    }

    public void setPower(float power)

    {

    this.power = power;

    }

    public String getUnit()

    {

    return unit;

    }

    public void setUnit(String unit)

    {

    this.unit = unit;

    }

    }

    3.2 220v电源接口

    package com.demo.power.v220;

    /**

    * 220V 电源接口

    *

    * @author

    *

    */

    public interface IPower220 {

    // 220V交流电源打印

    public void output220v();

    }

    3.3 220v电源实现类

    package com.demo.power.v220;

    import com.demo.power.AbsBasePower;

    /**

    * 220V电源

    *

    * @author

    *

    */

    public class Power220 extends AbsBasePower implements IPower220

    {

    // 构造方法

    public Power220()

    {

    super(220);

    }

    // 220V电源输出

    public void output220v()

    {

    System.out.println("----这是[" + this.getPower() + this.getUnit() + "]电源!...");

    }

    }

    3.4 12v电源接口

    package com.demo.power.v12;

    /**

    * 12V 电源接口

    *

    * @author

    *

    */

    public interface IPower12 {

    // 12V电源打印

    public void output12v();

    }

    3.5 12v电源实现类

    package com.demo.power.v12;

    import com.demo.power.AbsBasePower;

    /**

    * 正常的12V电源

    *

    * @author

    *

    */

    public class Power12 extends AbsBasePower implements IPower12 {

    // 12V电源构造方法

    public Power12() {

    super(12);

    }

    // 12V电源输出

    public void output12v() {

    System.out.println("----这是[" + this.getPower() + this.getUnit()

    + "]电源!...");

    }

    }

    3.6  12v电源对象适配器

    package com.demo.adapter;

    import com.demo.power.AbsBasePower;

    import com.demo.power.v12.IPower12;

    /**

    * 电源适配器 (实现目标对象接口 即:12V电源接口)

    *

    * @author

    *

    */

    public class AdapterPower12 implements IPower12 {

    // 待转换的对象

    private final AbsBasePower absBasePower;

    // 适配器构造方法 将待转换对象传入

    public AdapterPower12(AbsBasePower absBasePower) {

    this.absBasePower = absBasePower;

    }

    // 实现目标对象方法

    public void output12v() {

    // 获得外部电源值

    float powerFloat = this.absBasePower.getPower();

    // 进行电源转换

    if (powerFloat == 380) {

    // 380V电源转换

    powerFloat = powerFloat / 31.67f;

    } else if (powerFloat == 220) {

    // 220V电源转换

    powerFloat = powerFloat / 18.33f;

    } else if (powerFloat == 110) {

    // 110V电源转换

    powerFloat = powerFloat / 9.17f;

    } else {

    System.out.println("----不能适配电源!...");

    return;

    }

    // 处理转换结果

    powerFloat = (int) (powerFloat * 10) / 10.0f;

    System.out.println("----这是[" + powerFloat + this.absBasePower.getUnit()

    + "]电源!...");

    }

    }

    3.7  12v电源类适配器

    package com.demo.adapter;

    import com.demo.power.AbsBasePower;

    import com.demo.power.v12.IPower12;

    /**

    * 电源适配器 (实现目标对象接口 即:12V电源接口) 类适配器 模式

    *

    * @author

    *

    */

    public class AdapterPower12Ext extends AbsBasePower implements IPower12 {

    // 适配器构造方法 将待转换对象传入

    public AdapterPower12Ext(AbsBasePower absBasePower) {

    super(absBasePower.getPower());

    }

    // 实现目标对象方法

    @Override

    public void output12v() {

    // 获得外部电源值

    float powerFloat = this.getPower();

    // 进行电源转换

    if (powerFloat == 380) {

    // 380V电源转换

    powerFloat = powerFloat / 31.67f;

    } else if (powerFloat == 220) {

    // 220V电源转换

    powerFloat = powerFloat / 18.33f;

    } else if (powerFloat == 110) {

    // 110V电源转换

    powerFloat = powerFloat / 9.17f;

    } else {

    System.out.println("----不能适配电源!...");

    return;

    }

    // 处理转换结果

    powerFloat = (int) (powerFloat * 10) / 10.0f;

    System.out.println("----这是[" + powerFloat + this.getUnit() + "]电源!...");

    }

    }

    3.8  测试适配器

    package com.demo;

    import com.demo.adapter.AdapterPower12;

    import com.demo.adapter.AdapterPower12Ext;

    import com.demo.power.v12.IPower12;

    import com.demo.power.v12.Power12;

    import com.demo.power.v220.Power220;

    /**

    * 客户端程序调用

    *

    * @author

    *

    */

    public class Client {

    /**

    * @param args

    */

    public static void main(String[] args) {

    // 我们首先 生成一个220V电源对象!

    Power220 power220 = new Power220();

    power220.output220v();

    // 接下来,我们在生成一个12V电源对象!

    IPower12 power12 = new Power12();

    power12.output12v();

    // 最后,我们使用电源适配器 将220V电源转换为12V电源!

    System.out.println("\n----电源适配器转换中...");

    IPower12 adapterPower12 = new AdapterPower12(power220);

    adapterPower12.output12v();

    System.out.println("----电源适配器转换结束!");

    // 类适配器实现

    System.out.println("\n----类适配器 电源适配器转换中...");

    IPower12 adapterPower12Ext = new AdapterPower12Ext(power220);

    adapterPower12Ext.output12v();

    System.out.println("----类适配器 电源适配器转换结束!");

    }

    }

    3.9 运行结果

    ----这是[220.0V]电源!...

    ----这是[12.0V]电源!...

    ----电源适配器转换中...

    ----这是[12.0V]电源!...

    ----电源适配器转换结束!

    ----类适配器 电源适配器转换中...

    ----这是[12.0V]电源!...

    ----类适配器 电源适配器转换结束!

    三、设计原则

    1使用对象组合,面向接口和抽象编程

    2“开一闭”原则

    四、使用场合

    1 软件系统结构需要升级或扩展,又不想影响原有系统稳定运行的时候

    2 转换类之间的差別不是很大的时候

    3 想创建一个可以复用的类,该类可以与其他不相关类或不可预见类协同工作的时候

    五、类适配器模式和对象适配器模式的静态类图

    e401351348daab912a56c92984314edb.png

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • java 适配器模式

    2011-12-25 19:44:58
    java 设计模式 适配器模式,希望对大家理解设计模式有帮助
  • JAVA 适配器模式

    2020-05-11 21:33:03
    适配器模式设计模式属于结构型模式,是作为两个不兼容的接口之间的桥梁,即将一个现存的接口适配为期待的另一个接口。 特点 优点:适配器模式可以让两个没有任何关系得类在一起运行、提高了类的复用、增加了类的...
  • 在阎宏博士的《JAVA与模式》一书中开头是这样描述适配器(Adapter)模式的:适配器模式把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。作用类似于...
  • 本文实例讲述了Java适配器模式定义与用法。分享给大家供大家参考,具体如下:将一个类的接口转换成客户想要的另一个接口,适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作适配器一共包括3种...
  • JAVA适配器模式

    2019-05-28 10:01:41
    适配器模式 转载:http://www.cnblogs.com/V1haoge/p/6479118.html 类适配器模式 原理:继承 应用场景: 实现的接口A中不存在想要的方法,而另一个接口B中有。接口A的实现类继承接口B,调用接口B来实现接口A的方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,744
精华内容 2,697
关键字:

java适配器模式

java 订阅