精华内容
下载资源
问答
  • java 实现接口

    千次阅读 2018-06-30 10:11:19
    6.2 实现接口 1 类实现接口 在Java语言中,接口由来实现以便使用接口中的方法。 一个需要声明中使用关键字implements声明该实现个或多个接口。 如果实现多个接口,用逗号隔开接口名,例如A实现Pintable...

    6.2 实现接口

        1 类实现接口

          在Java语言中,接口由类来实现以便使用接口中的方法。 一个类需要类声明中使用关键字implements声明该类实现个或多个接口。 如果实现多个接口,用逗号隔开接口名,例如A类实现Pintable和Addable接口。

    classA implements Printable,Addable

          再如,Animal 的Dog子类实现Eatable和Sleepable接口。

    classDog extends Aninal implements Eatable,Sleepable

        2.重写接口中的方法

          如果一个非抽象类实现了某个接口,那么这个类必须重写这个接口中的所有方法。需要注意的是,由于接口中的方法定是public abstract 方法,所以类在重写接口方法时不仅要去掉abstract 修饰符、给出方法体,而且方法的访问权限一定要明显地用public来修饰(否则就降低了访问权限,这是不允许的).实现接口的非抽象类实现了该接口中的方法,即给出了方法的具体行为功能。用户也可以自定义接口,一个Java源文件可以由类和接口组成。

          下面的例子1中包含China类、Japan类和Compuable接口,而且China类和Japan类都实现了Computable接口。

    Computable.java

    public interface Computable{
    	int MAX=46;
    	int f(int x);
    }

    China.java

    class China implements Computable{ //China类实现Computable接口
    	int number;
    	public int f(int x){       //不要忘记publie关键宇
    		int sum=0;
    		for(int i=0;i<=x;i++){
    			sum=sum+i;
    		}
    		return  sum;
    	}
    }

    Japan.java

    class Japan implements Computable { //Japan 类实现Computable接口
    	int number;
    	public int f(int x){
    		return MAX+x; //直接使用接口中的常量
    	}
    }

    Example6_1.java

    public class Example6_1{
    	public static void main(String args[]){
    		China zhang;
    		Japan henlu;
    		zhang=new China();
    		henlu=new Japan();
    		zhang.number=32+Computable .MAX; //用接口名访问接口的常量
    		henlu.number=14+Computable.MAX;
    		System.out.println("zhang的学号"+zhang.number+",zhang 求和结果"+zhang.f(100));
    		System.out.println("henlu的学号"+henlu.number+",henlu 求和结果"+henlu.f(100));
    	}
    }

    如果一个类声明实现一个接口,但没有重写接口中的所有方法,那么这个类必须是抽象类,也就是说,抽象类既可以重写接口中的方法,也可以直接拥有接口中的方法,例如:

    interface Computable {
        final int MAX = 100;
        vo1d speak(String s);
        int f(int x);
        float g(float x,float y);
    }
    abstract classA implements Computable{
        public int f(int x){
            int sum 0:
            for(int i=1;i<=x;i++) {
                sum=sum+i;
            }
        return sum;
        }
    }

        4.接口的细节说明

          程序可以用接口名方问接口中的常量,但是如果个类实现了接口,那么该类可以直接在类体中使用该接口中的常量。

    定义接口时,如果关键字interface前面加上public关键字,就称这样的接口是一个public接口。public接口可以被任何一个类实现。如果一个接口不加public修饰,就称作友好接口,友好接口可以被与该接口在同一包中的类实现。

          如果父类实现了某个接口,那么子类也就自然实现了该接口,子类不必再显式地使用关键字implements声明实现这个接口,

          接口也可以被继承,即可以通过关键字extends声明个接口是另个接口的 子接口。由于接口中的方法和常量都是public的,子接口将继承父接口中的全部方法和常量。

    注: Java提供的接口都在相应的包中,通过import语向不仅可以引入包中的类,也可以引入包中的接口,例如:
    
        importJava.io.*;
    
    不仅引入了java.io包中的类,同时也引入了该包中的接口。
    
    

    展开全文
  • **抽象可以使用implements关键字实现接口,但又不用在该抽象实现接口里的具体方法(不实现接口的具体方法不会报错),那设计抽象可以使用implements来实现接口有什么意义啊?** 抽象: public ...
  • 实现功能的业务是这样的,动态的获取java接口的所有的实现类并且排除抽象接口本身。 代码实现 1.创建接口Animal package com.tcp.executor; public interface Animal { public void say(); } 2.创建抽象...

    实现的功能的业务是这样的,动态的获取java接口的所有的实现类并且排除抽象类和接口本身。

    代码实现

    1.创建接口Animal

    package com.tcp.executor;
    public interface Animal {
    
        public void say();
    
    }
    

    2.创建抽象类实现Animal

    package com.tcp.executor;
    public abstract class AbstractAnimal implements Animal {
    
        public void sleep(){
            System.out.println("睡觉了");
        }
    }
    

    3.创建实现类Cat继承抽象类

    package com.tcp.executor;
    public class Cat extends AbstractAnimal {
    
        @Override
        public void say() {
            System.out.println("我是猫");
        }
    }
    

    4.创建实现类Chicken继承抽象类

    package com.tcp.executor;
    public class Chicken extends AbstractAnimal {
        @Override
        public void say() {
            System.out.println("我是鸡");
        }
    }
    

    5.创建实现类Lion继承抽象类

    package com.tcp.executor;
    public class Lion extends AbstractAnimal {
        @Override
        public void say() {
            System.out.println("我是狮子");
        }
    }
    

    6.创建实现类Tiger继承抽象类

    package com.tcp.executor;
    public class Tiger extends AbstractAnimal {
        @Override
        public void say() {
            System.out.println("我是老虎");
        }
    }
    
    

    7.创建实现类Dog继承抽象类

    package com.tcp.executor;
    public class Dog extends AbstractAnimal {
    
        @Override
        public void say() {
            System.out.println("我是狗");
        }
    }
    

    测试代码

    package com.tcp.executor;
    import java.io.File;
    import java.io.IOException;
    import java.lang.reflect.Modifier;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.Enumeration;
    import java.util.List;
    public class Demo {
    
        public static void main(String[] args) throws Exception {
            List<Animal> animals = new ArrayList<>();
            List<Class> clazzs = getAllInterfaceAchieveClass(Animal.class);
            for(Class clazz : clazzs){
               animals.add((Animal)clazz.newInstance());
            }
            //打印Class对象
            for(Animal cla : animals){
                System.out.println("实现类:"+cla.getClass());
            }
        }
    
        /**
         * 获取所有接口的实现类
         * @return
         */
        public static List<Class> getAllInterfaceAchieveClass(Class clazz){
            ArrayList<Class> list = new ArrayList<>();
            //判断是否是接口
            if (clazz.isInterface()) {
                try {
                    ArrayList<Class> allClass = getAllClassByPath(clazz.getPackage().getName());
                    /**
                     * 循环判断路径下的所有类是否实现了指定的接口
                     * 并且排除接口类自己
                     */
                    for (int i = 0; i < allClass.size(); i++) {
    
                        //排除抽象类
                        if(Modifier.isAbstract(allClass.get(i).getModifiers())){
                            continue;
                        }
                        //判断是不是同一个接口
                        if (clazz.isAssignableFrom(allClass.get(i))) {
                            if (!clazz.equals(allClass.get(i))) {
                                list.add(allClass.get(i));
                            }
                        }
                    }
                } catch (Exception e) {
                    System.out.println("出现异常");
                }
            }
            return list;
        }
    
        /**
         * 从指定路径下获取所有类
         * @return
         */
        public static ArrayList<Class> getAllClassByPath(String packagename){
            ArrayList<Class> list = new ArrayList<>();
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            String path = packagename.replace('.', '/');
            try {
                ArrayList<File> fileList = new ArrayList<>();
                Enumeration<URL> enumeration = classLoader.getResources(path);
                while (enumeration.hasMoreElements()) {
                    URL url = enumeration.nextElement();
                    fileList.add(new File(url.getFile()));
                }
                for (int i = 0; i < fileList.size(); i++) {
                    list.addAll(findClass(fileList.get(i),packagename));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return list;
        }
    
        /**
         * 如果file是文件夹,则递归调用findClass方法,或者文件夹下的类
         * 如果file本身是类文件,则加入list中进行保存,并返回
         * @param file
         * @param packagename
         * @return
         */
        private static ArrayList<Class> findClass(File file,String packagename) {
            ArrayList<Class> list = new ArrayList<>();
            if (!file.exists()) {
                return list;
            }
            File[] files = file.listFiles();
            for (File file2 : files) {
                if (file2.isDirectory()) {
                    assert !file2.getName().contains(".");//添加断言用于判断
                    ArrayList<Class> arrayList = findClass(file2, packagename+"."+file2.getName());
                    list.addAll(arrayList);
                }else if(file2.getName().endsWith(".class")){
                    try {
                        //保存的类文件不需要后缀.class
                        list.add(Class.forName(packagename + '.' + file2.getName().substring(0,
                                file2.getName().length()-6)));
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                }
            }
            return list;
        }
    }
    

    运行结果

    在这里插入图片描述
    以上代码都测试过。

    展开全文
  • JAVA案例之使用接口实现手机功能

    千次阅读 2020-06-28 23:42:27
    JAVA案例之使用接口实现手机功能 这次小星星说一下接口案例之实现手机功能,话不多说,上案例 这是案例的效果图 案例大致类图 由上图类图中可以看出,我们需要3个接口,2个实现类,以及1个 抽象大致的案例创建如下...

    JAVA案例之使用接口实现手机功能

    这次小星星说一下接口案例之实现手机功能,话不多说,上案例

    这是案例的效果图在这里插入图片描述

    案例大致类图在这里插入图片描述

    由上图类图中可以看出,我们需要3个接口,2个实现类,以及1个
    抽象类大致的案例创建如下图所示:在这里插入图片描述

    所有接口类中的代码:

    //连接网络接口
    package dao;

    public interface Network {

    public void netWorkConn();
    

    }
    播放音频接口:
    package dao;

    public interface PlayWiring {

    public void play(String content);
    

    }
    //拍照实现接口:
    package dao;

    public interface TheakePictures {

    public void takePictures();
    

    }

    抽象类中的代码:

    package entity;

    public abstract class Handset {

    private String brand;
    private String type;
    
    //构造方法
    //无参方法
    public Handset() {}
    //带参方法
    public Handset(String brand,String type) {
    	this.brand=brand;
    	this.type=type;
    }
    //手机的自白
    public void info() {
    	System.out.println("这是一款型号为"+type+"的"+brand+"手机~~~");
    }
    //发送信息
    public void sendInfo() {
    	System.out.println("发送文字信息~~~");
    }
    //打电话
    public void call() {
    	System.out.println("正在打电话~~~");
    }
    

    }

    虽然两个实现类(子类可以使用父类(抽象类)中 的方法,但由于效果图中方法输出的效果有些许的差异, 所以在两个实现类(子类)中都需要重写父类方法.在这里就直接将两个实现类(子类)的代码实现拿来:

    实现类:智能手机类

    <
    package impl;

    import dao.Network;
    import dao.PlayWiring;
    import dao.TheakePictures;
    import entity.Handset;

    public class AptitudeHandset extends Handset implements Network,PlayWiring,TheakePictures{

    //构造方法
    public AptitudeHandset() {}
    public AptitudeHandset(String brand,String type) {
    	super(brand, type);
    }
    @Override
    public void takePictures() {
    	System.out.println("咔嚓。。。拍照成功~~~");
    }
    @Override
    public void play(String content) {
    	System.out.println("正在播放视频《"+content+"》~~~~");
    }
    @Override
    public void netWorkConn() {
    	System.out.println("已经启动移动网络~~~");
    }
    @Override
    public void sendInfo() {
    	System.out.println("正在发送带图片与文字的信息~~~");
    }
    @Override
    public void call() {
    	System.out.println("开始视频通话~~~");
    }
    

    }
    />

    实现类:普通手机类

    <
    package impl;

    import dao.PlayWiring;
    import entity.Handset;

    public class CommonHandset extends Handset implements PlayWiring{

    public CommonHandset(String brand,String type) {
    	super(brand, type);
    }
    @Override
    public void play(String content) {
    	System.out.println("正在播放音乐《"+content+"》~~~");
    }
    @Override
    public void sendInfo() {
    	System.out.println("发送文字信息~~~");
    }
    @Override
    public void call() {
    	System.out.println("开始语音通话~~~");
    }
    

    }
    />

    大致工作已完成,接下来写个测试类测试一下功效

    <
    package test;

    import impl.AptitudeHandset;
    import impl.CommonHandset;

    public class testTel {

    public static void main(String[] args) {
    	CommonHandset comm=new CommonHandset("索尼爱立信", "G502c");
    	comm.info();
    	comm.play("热血");
    	comm.sendInfo();
    	comm.call();
    	
    	System.out.println();
    
    	AptitudeHandset apt=new AptitudeHandset("I9100", "HTC");
    	apt.info();
    	apt.netWorkConn();
    	apt.play("小时代");
    	apt.takePictures();
    	apt.sendInfo();
    	apt.call();
    	
    }
    

    }
    />

    效果图如下:在这里插入图片描述

    至此,全部功能已实现,圆满完成,如果有更好的方法,欢迎和小星星评论探讨哇~~~

    展开全文
  • Java获取接口所有实现类的方式详解

    千次阅读 2020-03-12 09:03:45
    有时候,根据业务逻辑的需求,我们想要获取到某个接口的所有实现类。在这里大致介绍两种方式: 1.借助Spring容器实现 Spring作为一个容器,管理着一个项目中所有经过配置的Java类(xml配置文件或Annotation方式)...

    有时候,根据业务逻辑的需求,我们想要获取到某个接口的所有实现类。在这里大致介绍两种方式:

    1.借助Spring容器实现

    Spring作为一个容器,管理着一个项目中所有经过配置的Java类(xml配置文件或Annotation方式)。如果某个接口的所有实现类均被Spring托管了,那么通过Spring就可以很简单的返回这些实现类。

    import org.springframework.beans.BeansException;
    
    import org.springframework.context.ApplicationContext;
    
    import org.springframework.context.ApplicationContextAware;
    
    import org.springframework.stereotype.Component;
    
    
    @Component
    
    public class ServiceLocator implements ApplicationContextAware{
    
      /**
    
       * 用于保存接口实现类名及对应的类
    
       */
    
      private Map<String, IService> map;
    
    
      /**
    
       * 获取应用上下文并获取相应的接口实现类
    
       * @param applicationContext
    
       * @throws BeansException
    
       */
    
      @Override
    
      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    
        //根据接口类型返回相应的所有bean
    
        Map<String, IService> map = applicationContext.getBeansOfType(IService.class);
    
      }
    
    
      public Map<String, IService> getMap() {
    
        return map;
    
      }
    
    }

    2.借助ServiceLoader类

    ServiceLoader是JDK自带的一个类加载器,位于java.util包当中,作为 A simple service-provider loading facility. 具体使用方式如下:

    1.在META-INF/services/目录下用你的接口全路径名称命名一个文件(不加后缀),然后在该文件中一行一个添加你的接口实现类的全路径名。

    2.通过load方法来加载出所有的接口实现类

    ServiceLoader<MyInterface> loader = ServiceLoader.load(MyInterface.class);

    在这里load方法的返回值是一个迭代器,用这个迭代器可以遍历出所有的接口实现类。

    总结

    以上两种方式,实现的功能都是一样的,实现方式不同,底层用的技术一样的,都是反射。至于选择哪一种,我建议如果项目中的接口实现类都被Spring托管了,那当然是直接用Spring了。如果没有用到Spring的话,那就用ServiceLoader,这个肯定是没有问题的。

    展开全文
  • Java 使用接口实现手机功能-- 练习接口的使用

    千次阅读 多人点赞 2019-07-16 23:36:00
    |--需求说明 |--实现思路 1.根据....is......a.......就用接口的逻辑,确定需要四个---相机接口、移动网络接口、音频播放接口、视频播放接口 3.分别创建索尼和HTC手机,继承手机,按照需求...
  • Java中List接口实现类

    千次阅读 2018-09-19 11:46:43
    实现类ArrayList ArrayList相当于一个容量可变的动态数组,当超过了他的大小时,集自动增加,当对象被删除后,数组就可以缩小。 import java.util.*; public class ListDemo { public static void main...
  • python实现类似java接口类功能

    千次阅读 2018-06-13 16:31:57
    java一样继承了接口类,必须实现
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • Java实现接口与继承的区别

    千次阅读 2020-10-09 00:16:57
    ** Java中接口与继承的区别 ** 在Java中,接口的实现和继承的实现很类似的,写法上是几乎是一致的,就是关键字这一部分...//实现接口一定要实现(重写)接口中所有的抽象方法 //实现接口(继承):implements //public cla
  • Java 接口实现(详细版)】

    千次阅读 多人点赞 2021-03-31 09:00:37
    接口与实现1 接口二级目录三级目录2 实现接口3 理解接口 1 接口 二级目录 三级目录 2 实现接口 3 理解接口
  • java 接口 三种实现方式

    万次阅读 2018-09-29 09:42:15
    无论第一种还是第二种还是,如果我们想要从接口中拿到数据,我们就必须得调用HttpClient或者其他的方式从接口获取信息,这个项目中我使用到的是HttpClient。 HttpClient特性以及使用方法 ...
  • 实际编程过程中,我们可能遇到这样的问题,就是获取实现了指定接口类的所有实现类。 本工具就提供了这样的功能。下面是工具的详细解析: /** * 查找指定路径下面实现指定接口的全部 * @author longyin * ...
  • Java接口的声明和实现

    千次阅读 2020-04-16 15:39:30
    1.接口:用于声明一组的公共操作的接口,Java中把对接口功能的继承称为实现(implement),接口只是声明了功能是什么,而并没有定义如何实现该功能,功能的实现是在继承这个接口的各个子类中完成的 2.组成:接口往往...
  • 以下就是生活中两种多态的实例,**抽象是模板,接口功能。 **描述: Door.java 抽象 package com.dialogd.polymorphic; //抽象,抽象是一种模板 public abstract class Door { //开门的...
  • java实现发送短信验证码功能

    千次下载 热门讨论 2015-04-17 19:44:36
    使用的是信易通的短信平台接口,然后在Java中使用HttpClient模拟POST请求或者GET请求(看短信平台要求,一般的情况下都是POST请求),调用短信平台提供的接口(遵循短信平台的接口规范即可)发送短信验证码
  • java 接口实现防盗门功能

    千次阅读 2019-04-02 21:06:00
    Door; package locker; public abstract class Door { public abstract void open(); public abstract void close(); } View Code Lock: package locker;...public interface Lo...
  • java实现支付宝接口-支付流程

    万次阅读 多人点赞 2018-08-03 14:59:04
    备注1:相关注意事项 1、注意下载lombok插件和依赖lombokjar 2、其中service可以不要的,直接接口调用util文件也可以,当然你也可以直接在接口写连接加载都可以 备注2:支付宝相关资料链接 1、实现支付宝支付功能 ...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • //implA 为接口 ClassB为其实现类 implA A=new ClassB();//接口类型的引用变量A 去接收对象地址 or ClassB A=new ClassB();//类型的引用变量A 去接收对象地址 先附上有关接口的相关知识 知乎 Java 中的接口有...
  • java程序设计语言提供了两种机制,可以用来定义允许多个实现的类型:接口和抽象。这两种机制之间最明显的区别在于,抽象允许包含某些方法的实现,但是接口不允许,一个更重要的区别在于,为了实现抽象定义的类型...
  • java接口

    千次阅读 2018-06-15 09:00:07
    是具有相同属性和服务的...接口功能:(1) 通过接口可以实现不相干的相同行为而不需考虑这些之间的层次关系。(2) 通过接口可以实现多继承机制。(3) 通过接口可以了解对象的交互界面而不需了解对象所对应...
  • Java中抽象接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    Java中,可以通过两种形式来体现OOP的抽象:接口和抽象。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口...
  • Java类的继承、接口的继承和实现

    千次阅读 2017-04-23 17:08:47
    Java的接口有继承和实现两个概念,接口可以继承另一个接口,并获得其父接口里的所有方法和成员变量,接口也可以被一个实现,实现接口需要实现接口及其父接口里的所有抽象方法,怎么理解呢? (1)如果...
  • &...Vector实现了List接口,与ArrayList一样可以维护一个插入顺序,d但ArrayList比Vector快,它是非同步的,若涉及到多线程,用户Vector回比较好一些,在非多线程环境中,Vector对于元素的查询、
  • java:抽象的两种实现方式(抽象接口)及其比较

    千次阅读 多人点赞 2018-02-23 20:57:38
    Java中,可以通过两种形式来体现面向对象的编程(OOP)的抽象:接口和抽象。这两者有太多相似的地方,又有太多不同的地方。下面我们就一起来学习一下Java中的接口和抽象。 一.抽象  在了解抽象之前,先...
  • java实现接口回调数据

    2017-09-05 08:45:47
    求教各位大神, 如何写接口给别人调用 。 最后保存别人返回的数据
  • 排序的算法,大家都不陌生,有冒泡排序、选择排序、插入排序,快速排序等等。如果现在有学生,学校添加了很多学生,要你给学生按照学号... 咱们java功能很强大,库里自带给数组排序的方法Arrays.sort(); 来看看...
  • JAVA基础——接口(全网最详细教程)

    万次阅读 多人点赞 2018-05-10 09:46:42
    官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。 我的解释:接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 954,966
精华内容 381,986
关键字:

java实现接口功能的类

java 订阅