脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java一个接口多个实现类

java一个接口多个实现类的调用方式

 更新时间：2023年09月25日 16:25:48   作者：落弋V  
这篇文章主要给大家介绍了关于java一个接口多个实现类的调用方式的相关资料,经测试确认,当一个接口有多个实现时,调用时只会执行一个,有时候需要多个实现调用,需要的朋友可以参考下

在 Java 中，如果一个接口有多个实现类，可以通过以下几种方式来调用不同的实现类：

  • 根据具体实现类的类型进行调用：
InterfaceA objA = new ImplementationA();
InterfaceA objB = new ImplementationB();
objA.method(); // 调用 ImplementationA 的实现方法
objB.method(); // 调用 ImplementationB 的实现方法
  • 利用接口的引用，根据条件判断调用不同的实现类：
InterfaceA obj;
if (condition) {
    obj = new ImplementationA();
} else {
    obj = new ImplementationB();
}
obj.method(); // 根据条件调用不同的实现类方法
  • 在集合中存储不同的实现类对象，通过循环遍历调用：
List<InterfaceA> objects = new ArrayList<>();
objects.add(new ImplementationA());
objects.add(new ImplementationB());
for (InterfaceA obj : objects) {
    obj.method(); // 循环遍历调用不同实现类的方法
}
  • 使用工厂模式或依赖注入框架来动态获取不同的实现类对象：
InterfaceA obj = ObjectFactory.getInstance().createInterfaceA();
obj.method(); // 动态获取实现类对象并调用方法

需要根据具体的应用场景和需求选择适合的方式来调用不同的实现类。在代码中，根据接口类型、条件判断、集合遍历或动态获取实例等方式，可以灵活地调用不同的实现类的方法。

除了上述方案，还有以下一些方案可以实现在 Java 中调用多个实现类：

  • 使用注解：通过为实现类添加特定的注解，在需要调用的地方通过注解扫描来获取实现类，并进行调用。
  • 使用代理模式：通过动态代理机制，在运行时生成代理对象，并在代理对象中根据条件调用不同的实现类的方法。
  • 使用配置文件：将不同实现类的信息配置在文件中，通过读取配置文件来获取实现类，并进行调用。
  • 使用动态加载：使用 Java 的动态加载机制，根据类名或条件动态加载不同的实现类，并进行调用。

工厂模式得示例代码一

当涉及到工厂模式时，可以按照以下步骤实现：

创建接口：

public interface ProductService {
    void getProductInfo();
}

创建具体的实现类：

public class ProductAService implements ProductService {
    @Override
    public void getProductInfo() {
        System.out.println("Product A info");
    }
}
public class ProductBService implements ProductService {
    @Override
    public void getProductInfo() {
        System.out.println("Product B info");
    }
}

创建工厂类：

public class ProductServiceFactory {
    public static ProductService createProductService(String productType) {
        if (productType.equalsIgnoreCase("A")) {
            return new ProductAService();
        } else if (productType.equalsIgnoreCase("B")) {
            return new ProductBService();
        } else {
            throw new IllegalArgumentException("Invalid product type");
        }
    }
}

使用工厂类获取实例并调用方法：

public class Main {
    public static void main(String[] args) {
        ProductService productServiceA = ProductServiceFactory.createProductService("A");
        productServiceA.getProductInfo(); // 输出：Product A info
        ProductService productServiceB = ProductServiceFactory.createProductService("B");
        productServiceB.getProductInfo(); // 输出：Product B info
    }
}

在上述示例中，通过工厂类的静态方法 createProductService 根据传入的参数（产品类型）动态创建具体的实现类对象。根据不同的产品类型，工厂类返回不同的实例，并通过接口引用调用对应的方法。这样可以在运行时决定具体使用哪个实现类，而无需在代码中直接创建对象。

工厂模式得示例代码（Map实现）二

通过 Map 来实现工厂模式是一种常见的方式，可以将不同的产品类型与对应的实现类进行映射。以下是使用 Map 实现工厂模式的示例代码：

创建接口：

public interface ProductService {
    void getProductInfo();
}

创建具体的实现类：

public class ProductAService implements ProductService {
    @Override
    public void getProductInfo() {
        System.out.println("Product A info");
    }
}
public class ProductBService implements ProductService {
    @Override
    public void getProductInfo() {
        System.out.println("Product B info");
    }
}

创建工厂类：

import java.util.HashMap;
import java.util.Map;
public class ProductServiceFactory {
    private static final Map<String, ProductService> productMap = new HashMap<>();
    static {
        productMap.put("A", new ProductAService());
        productMap.put("B", new ProductBService());
    }
    public static ProductService createProductService(String productType) {
        ProductService productService = productMap.get(productType);
        if (productService == null) {
            throw new IllegalArgumentException("Invalid product type");
        }
        return productService;
    }
}

使用工厂类获取实例并调用方法：

public class Main {
    public static void main(String[] args) {
        ProductService productServiceA = ProductServiceFactory.createProductService("A");
        productServiceA.getProductInfo(); // 输出：Product A info
        ProductService productServiceB = ProductServiceFactory.createProductService("B");
        productServiceB.getProductInfo(); // 输出：Product B info
    }
}

在这个示例中，工厂类通过一个静态的 Map 对象将产品类型与对应的实现类进行映射。在工厂类的 createProductService 方法中，根据传入的产品类型从 Map 中获取对应的实现类实例，并返回给调用方。这样，在运行时可以根据不同的产品类型获取对应的实例对象。

工厂模式得示例代码（注解实现）三

以下是一个使用注解实现多个实现类调用的示例代码：

定义注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyImplementation {
    String value();
}

创建接口：

public interface MyInterface {
    void doSomething();
}

创建具体的实现类，并使用注解标记：

@MyImplementation("A")
public class ImplementationA implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Implementation A");
    }
}
@MyImplementation("B")
public class ImplementationB implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Implementation B");
    }
}

创建工厂类，使用注解扫描获取对应实现类：

import java.util.HashMap;
import java.util.Map;
public class MyFactory {
    private static final Map<String, MyInterface> implementations = new HashMap<>();
    static {
        // 扫描带有@MyImplementation注解的类，并将其实例化并放入implementations Map中
        Reflections reflections = new Reflections("com.example");
        Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(MyImplementation.class);
        for (Class<?> annotatedClass : annotatedClasses) {
            MyImplementation annotation = annotatedClass.getAnnotation(MyImplementation.class);
            String implementationKey = annotation.value();
            try {
                MyInterface implementation = (MyInterface) annotatedClass.newInstance();
                implementations.put(implementationKey, implementation);
            } catch (InstantiationException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }
    public static MyInterface getImplementation(String key) {
        return implementations.get(key);
    }
}

使用工厂类获取实例并调用方法：

public class Main {
    public static void main(String[] args) {
        MyInterface implementationA = MyFactory.getImplementation("A");
        implementationA.doSomething(); // 输出：Implementation A
        MyInterface implementationB = MyFactory.getImplementation("B");
        implementationB.doSomething(); // 输出：Implementation B
    }
}

在这个示例中，通过自定义的注解 @MyImplementation 标记具体的实现类，然后使用反射扫描带有该注解的类，并实例化放入工厂类的 implementations Map 中。通过工厂类的 getImplementation 方法，根据指定的实现类标识符获取对应的实现类实例。然后就可以通过实例调用接口定义的方法

工厂模式得示例代码（枚举实现）四

枚举也可以用于实现工厂模式，其中每个枚举常量都代表一个具体的实现类。以下是一个使用枚举实现工厂模式的示例代码：

public interface MyInterface {
    void doSomething();
}
public class ImplementationA implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Implementation A");
    }
}
public class ImplementationB implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Implementation B");
    }
}
public enum MyFactory {
    IMPLEMENTATION_A {
        @Override
        public MyInterface create() {
            return new ImplementationA();
        }
    },
    IMPLEMENTATION_B {
        @Override
        public MyInterface create() {
            return new ImplementationB();
        }
    };
    public abstract MyInterface create();
}
public class Main {
    public static void main(String[] args) {
        MyInterface implementationA = MyFactory.IMPLEMENTATION_A.create();
        implementationA.doSomething(); // 输出：Implementation A
        MyInterface implementationB = MyFactory.IMPLEMENTATION_B.create();
        implementationB.doSomething(); // 输出：Implementation B
    }
}

在这个示例中，枚举 MyFactory 表示工厂，每个枚举常量代表一个具体的实现类。每个枚举常量都实现了抽象方法 create()，该方法用于创建对应的实现类对象。在 Main 类中，通过枚举常量调用 create() 方法来创建具体的实现类对象，并调用接口方法

总结

到此这篇关于java一个接口多个实现类的调用方式的文章就介绍到这了,更多相关java一个接口多个实现类内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 浅谈使用Maven插件构建Docker镜像的方法

    浅谈使用Maven插件构建Docker镜像的方法

    本篇文章主要介绍了浅谈使用Maven插件构建Docker镜像的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-12-12
  • springboot中使用Hibernate-Validation校验参数详解

    springboot中使用Hibernate-Validation校验参数详解

    这篇文章主要为大家介绍了springboot中使用Hibernate-Validation校验参数详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-07-07
  • Java反射设置/获取对象属性值三种方式

    Java反射设置/获取对象属性值三种方式

    这篇文章主要给大家介绍了关于Java反射设置/获取对象属性值的三种方式,反射机制的用途非常多,比如获取方法,属性名和属性值等,甚至可以获取标签等标签属性,需要的朋友可以参考下
    2023-11-11
  • Java设置千分位分隔符的两种方法

    Java设置千分位分隔符的两种方法

    在 Java 中,有时候我们需要对数字进行千分位分隔,以提升数字的可读性,本文将介绍如何在 Java 中实现对数字设置千分位分隔符的方法,需要的朋友可以参考下
    2024-10-10
  • Java 敏感词检测工具的实现

    Java 敏感词检测工具的实现

    本文介绍了Java敏感词检测工具的使用方法,包括依赖引入、核心方法使用实例、常规用法、自定义替换检测策略等内容,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-11-11
  • Java中的原子性、可见性和有序性示例详解

    Java中的原子性、可见性和有序性示例详解

    原子性、可见性、有序性是多线程编程中最重要的几个知识点,由于多线程情况复杂,如何让每个线程能看到正确的结果,这是非常重要的,这篇文章主要介绍了Java中原子性、可见性和有序性的相关资料,需要的朋友可以参考下
    2026-01-01
  • java判读数组中是否有重复值的示例

    java判读数组中是否有重复值的示例

    这篇文章主要介绍了java判读数组中是否有重复值的示例,需要的朋友可以参考下
    2014-04-04
  • 一文详解Java中Integer是如何应用享元模式的

    一文详解Java中Integer是如何应用享元模式的

    在Java中,享元模式在Integer和String类中有显著的应用,下面这篇文章主要介绍了Java中Integer是如何应用享元模式的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下
    2025-10-10
  • SpringBoot实现WEB的常用功能案例详解

    SpringBoot实现WEB的常用功能案例详解

    这篇文章主要介绍了SpringBoot实现WEB的常用功能,本文将对Spring Boot实现Web开发中涉及的三大组件Servlet、Filter、Listener以及文件上传下载功能以及打包部署进行实现，需要的朋友可以参考下
    2022-04-04
  • 使用JavaMail发送邮件保证成功的方法

    使用JavaMail发送邮件保证成功的方法

    JavaMail是利用现有的邮件账户发送邮件的工具，使用过JavaMail的api发送邮件的人可能会有这样一个疑惑：我如何知道我调用该api发送的邮件是否成功呢？那么通过下面这篇文章大家一起来看看使用JavaMail保证邮件发送成功的方法，有需要的朋友们可以参考借鉴。
    2016-11-11

最新评论