精华内容
下载资源
问答
  • 抽象类实现一个接口为什么可以不用都实现接口中的方法 [问题点数:60分,结帖人ZPH2254]   不显示删除回复 显示所有回复  显示星级回复 显示得分回复  只显示楼主 收藏 关注 ...

    抽象类实现一个接口为什么可以不用都实现接口中的方法 [问题点数:60分,结帖人ZPH2254]

     收藏
    回复次数:9
    展开全文
  • 接口或服务 public interface CacheServiceextends Serializable, K extends Serializable> { ...实现类1 @Service("redisCacheService") public class RedisCacheServiceImpl implements CacheService {

    接口或服务

    public interface CacheService<T extends Serializable, K extends Serializable> {    
    }
    实现类1

    @Service("redisCacheService")
    public class RedisCacheServiceImpl implements CacheService {
        public RedisCacheServiceImpl() { }  
    }
    
    实现类2

    @Service("ehCacheService")
    public class EhCacheServiceImpl<T extends Serializable, K extends Serializable> implements CacheService<T, K> {
         public EhCacheServiceImpl() { }  
    }

    调用:

    /**
     * The wrapped Jedis instance.
     */
    @Autowired
    @Qualifier("redisCacheService")
    private CacheService cacheService;
    @Qualifier指定了别名为redisCacheService的服务










    展开全文
  • 接口接口实现类接口与抽象

    千次阅读 2019-02-07 16:34:56
    为了弥补这个不足,Java中的接口可以实现多重继承,一个类可以实现多个接口。 定义和实现接口 接口的定义包括接口声明和接口体两部分。接口体包括属性常量和抽象方法。 [public] interface 接口名 { 属性常量 ...

    Java不支持多重继承,即一个子类只允许拥有一个父类。为了弥补这个不足,Java中的接口可以实现多重继承,一个类可以实现多个接口。

    定义和实现接口

    接口的定义包括接口声明和接口体两部分。接口体包括属性常量抽象方法。

    [public] interface 接口名 {
    	属性常量
    	...
    	抽象方法
    	...
    	
    }
    

    interface是声明一个接口的关键字,在Java中,接口的属性只允许为静态常量,即static或者final类型,接口中的方法都是未定义的抽象方法。接口中无论是属性还是方法都默认为public类型。
    用implements表示实现一个接口,在实现类中要必须实现接口中定义的所有方法并且可以使用接口里面定义的属性常量。此外,一个类可以实现多个接口。
    来一个例子:

    package Liu;
    interface Action {
    	String name = "Liu Yankee";		//默认是public static final类型的属性常量
    	public void walk();
    	public void run();
    }
    class Person implements Action {
    	public Person() {
    		
    	}
    	private int age;		//定义自己的私有属性
    	private int birthDate;
    	//实现接口的抽象方法walk()
    	public void walk() {
    		System.out.println(name + " is walking!");
    	}
    	//实现接口的抽象方法run()
    	public void run() {
    		System.out.println(name + " is running!");
    	}
    	//定义与接口无关的与类相关的方法
    	public void love() {
    		System.out.println(name + "can fall in love with a beautiful girl!");
    	}
    }
    //测试类
    public class text5 {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Action  man = new Person();
    		man.run();
    		man.walk();
    	}
    
    }
    
    

    1)接口是一个引用类型
    2)接口是某种特征的约定
    3)接口里面的所有方法自动为public abstract类型
    4)通过接口可以实现不相关类的相同行为而不需要考虑这些类之间的层次关系,从而在一定意义上实现了多重继承
    5)通过接口可以指明多个类需要实现的方法
    6)通过接口可以了解对象的交互界面,而不需要了解对象所对应的类

    接口的特性

    首先必须要了解接口不同于类的一些特性
    1)接口中的方法可以有参数列表和返回类型,但是不能有任何方法体实现
    2)接口中可以包含属性,但是会被隐式声明为static 和final类型,存储在该接口的静态存储区里面,而不属于该接口
    3)接口中的方法被声明为public或者不声明,但结果都会按照public类型处理
    4)如果没有实现接口中的所有方法那么创建的仍然是一个接口,即接口可以继承接口(使用extends关键字),在继承时,父接口传递给子接口只是方法说明,而不是具体实现
    5)一个接口可以有一个以上的父接口,一个类可以在继承父类的同时实现多个接口,即实现多重继承

    接口与抽象类的区别

    抽象类作为所有子类的标准有点类似于模板,所有子类只能在其格式范围内修改并补充。Java接口和Java抽象类代表的是抽象类型,是抽象层的具体实现。面向对象编程,如果要提高程序的复用率,增加程序的可维护性,可扩展性,就必须正确的使用接口和抽象类作为系统结构层次上的顶层,进行面向对象或者面向接口的编程。
    (1)接口和抽象类的最大一个区别是:抽象类可以提供部分已经实现的方法,但是接口所有的方法都是抽象的

    //使用接口计算长方体的面积
    package Liu;
    //定义一个接口
    interface Fiure {
    	double calculateArea();	//抽象方法calculateArea()
    	void showArea();			//抽象方法showArea()
    }
    class Rectangular implements Fiure {
    	private double length;		//私有属性
    	private double width;		//私有属性
    	//带参数的构造方法
    	public Rectangular(double length, double width) {
    		this.length = length;
    		this.width = width;
    	}
    	//接口抽象方法实现
    	public double calculateArea() {
    		double area = this.length * this.width;
    		return area;
    	}
    	//接口抽象方法实现
    	public void showArea() {
    		double Area = calculateArea();
    		System.out.println("此图形的面积为:" + Area);
    	}
    }
    //测试类
    public class text6 {
    
    	public static void main(String[] args) {
    		//实现接口
    		Fiure pFiure = new Rectangular(5.6, 6.9);
    		pFiure.showArea();
    	}
    
    }
    此图形的面积为:38.64
    

    由程序可以知道,接口的方法在其实现类中必须全部被实现,否则无法成功通过编译

    (2)抽象类作为公共的父类,为子类的扩展提供基础,包括属性和行为上的扩展。而接口不重视属性,只重视方法,使得子类可以自由的填补或者扩展接口所定义的方法
    (3)一个抽象类的实现只能由这个抽象类的子类给出,实现抽象类以继承为基础,而一个类可以实现任意多个接口

    package Liu;
    //接口Useleg
    interface Useleg {
    	void run();
    	void walk();
    	
    }
    //接口Usemouth
    interface Usemouth {
    	void speak();
    	void eat();
    	
    }
    //接口Useear
    interface Useear {
    	void hearMusic();
    	
    }
    //接口USeeye
    interface Useeye {
    	void seeFilm();
    	
    }
    //Person类实现多个接口
    class Person implements Useleg, Usemouth, Useear, Useeye {
    	String name;
    	int age;
    	String address;
    	String ID;
    	public void run() {
    		System.out.println("I am running!");
    		
    	}
    	public void walk() {
    		System.out.println("I am walking!");
    		
    	}
    	public void speak() {
    		System.out.println("I am speaking!");
    		
    	}
    	public void eat() {
    		System.out.println("I am eating!");
    		
    	}
    	public void hearMusic() {
    		System.out.println("I am listening to music!");
    		
    	}
    	public void seeFilm() {
    		System.out.println("I am seeing a film!");
    		
    	}
    	
    }
    //测试类
    public class text7 {
    
    	public static void main(String[] args) {
    		//实现Usemouth接口
    		Usemouth person = new Person();
    		person.eat();
    		person.speak();
    
    	}
    
    }
    I am eating!
    I am speaking!
    
    

    实现多个接口,每个接口名在implements关键字后面用逗号隔开,同时具有多个接口所定义的行为,而且必须实现所有抽象方法。
    技巧:抽象类侧重属性,接口侧重方法,在实际编程中,可以将接口放在最底层,在抽象类中实现接口的各个方法,进而让子类继承实现。

    定义接口interface
    ...
    //抽象类实现接口
    abstract class [类名] implements [接口名] {
    	...
    	
    }
    //子类继承抽象类
    class [类名] extends [抽象类]
    
    展开全文
  • 接口、抽象实现类

    千次阅读 2019-04-13 10:49:25
    2. 接口能被(抽象和具体实现,区别在于抽象类实现接口可以实现接口的方法,也可以实现接口的方法;具体必须实现接口的所有方法 3. 接口可以接口继承,但不允许被继承 4. 之间可以相互继承...

    接口、抽象类和实现类

    1. 接口是最抽象的一层,不需要进行任何实现;抽象层可以实现部分接口方法,也可以自定义方法;实现类必须实现所有方法。
    2. 接口能被类(抽象类和具体类)实现,区别在于抽象类实现接口,可以实现该接口的方法,也可以不实现该接口的方法;具体类必须实现接口的所有方法
    3. 接口可以被接口继承,但不允许被类继承
    4. 类之间可以相互继承,而且只能单继承
    5. abstract是抽象的意思,在java中,规定只能修饰类或者方法,所以不能修饰属性。被abstract修饰的内容都是暂未被实现的,比如类、方法。属性之所以不能被abstract修饰,是因为属性不存在"尚未被实现"的状态。比如你可能会联想到int age; 或是String name; 但可惜的是,在申明变量时,int会默认给age赋予初始值0,String会默认给name赋予初始值""。因此属性达不到"尚未被实现的状态",从而不能被abstract修饰。
    6. 抽象类和普通类在于:抽象类不能进行实例化,一方面抽象方法类似于接口的方法;另一方面,非抽象方法又和普通类方法相同,所以它兼备接口和普通类两种特型。
    7. 由于抽象类不能实例化,因此一般是作为父类,由子类进行扩充和实例化,因此,在抽象类的所有protected级别以上的方法或变量,均可以在子类中调用。

    1. 新建2个接口Context和Invocation
      Context
    package com.whc.abs;
    
    /**
     * 接口是最抽象的一层,只定义需要实现的接口函数及功能
     *
     * @author Administrator
     * @date 2019/4/11
     */
    public interface Context {
    
        // 接口中定义的成员变量默认为static
        String name = "admin";
        int age = 18;
        
        Object getName();
        Object getAge();
        void set();
    }
    
    

    另一个接口Invocation

    package com.whc.abs;
    
    /**
     * @author Administrator
     * @date 2019/4/11
     */
    public interface Invocation {
        Object getSrc();
        Object getTar();
        Object getCreateTime();
        Object getCreator();
    }
    
    

    新建一个抽象类AbstractContext

    package com.whc.abs;
    
    import java.util.Date;
    
    /**
     * 抽象类实现接口,可以有抽象方法也可以具体实现
     *
     * @author Administrator
     * @date 2019/4/11
     */
    public abstract class AbstractContext implements Context, Invocation {
    
       /**
         * 覆盖接口类的属性name
         */
        public String name = "admin1";
    
        /**
         * 抽象类可以写新定义的方法
         *
         * @return
         */
        protected String getAccount(){
            return "100";
        }
    
        /**
         * 可以在抽象类实现接口的方法
         *
         * @return
         */
        @Override
        public Object getName(){
            return "admin";
        }
    
        /**
         * 抽象类中可以定义类似接口函数,但必须加上abstract字段
         *
         * @return
         */
        abstract Object getEmail();
    
        /**
         * 抽象类实现接口的方法
         *
         * @return
         */
        @Override
        public Object getCreateTime() {
            return new Date();
        }
    
        /**
         * 抽象类实现接口的方法
         *
         * @return
         */
        @Override
        public Object getCreator() {
            return "administrator";
        }
    }
    
    

    抽象类实现类AbstractContextImpl

    package com.whc.abs;
    
    /**
     * @author Administrator
     * @date 2019/4/11
     */
    public class AbstractContextImpl extends AbstractContext {
    
        /**
         * 可以在实现类中覆盖抽象类已有的方法
         *
         * @return
         */
        @Override
        public Object getName() {
            return "guest";
        }
    
        /**
         * 接口中的方法需要实现
         *
         * @return
         */
        @Override
        public Object getAge() {
            return "25";
        }
    
        /**
         * 接口中的方法需要实现
         */
        @Override
        public void set() {
    
        }
    
        /**
         * 接口中的方法需要实现
         *
         * @return
         */
        @Override
        Object getEmail() {
            return null;
        }
    
        /**
         * 接口中的方法需要实现
         *
         * @return
         */
        @Override
        public Object getSrc() {
            return null;
        }
    
        /**
         * 接口中的方法需要实现
         *
         * @return
         */
        @Override
        public Object getTar() {
            return null;
        }
    
        public static void main(String[] args) {
            AbstractContext context = new AbstractContextImpl();
            System.out.println(context.name);//访问的是AbstractContext的name成员,它覆盖了接口类的静态成员name
            System.out.println(context.age);//访问的是接口定义静态变量age
            System.out.println(context.getAccount());//访问的是抽象类自定义实现的方法
            System.out.println(context.getName());//访问的是本实现类的方法,因为实现类对抽象类的方法进行了覆盖
            System.out.println(context.getAge());//访问的是本实现类的方法,实现了Context接口的方法
        }
    
    }
    
    

    输出结果:

    admin1
    18
    100
    guest
    25
    

    github地址:

    https://github.com/wuhc2006/springboot-practice/tree/master/springboot-thread/src/main/java/com/whc/abs

    展开全文
  • 一、首先来看一个例子 package net.println.kotlin.chapter4 /** * @author:wangdong * @description:类实现接口的冲突问题 */ ... fun x(): Int = 0 .../**一个类实现了两个接口,两个接口中...
  • Java中 一个类实现了某接口 则必须实现接口中的所有方法么?  编程语言编程java 专业回答 JAVA时空 团队 woshidaniel 2015-09-23 22:28 不一定,抽象类实现某个接口可以实现所有接口...
  • 一个类可以继承自一个普通,继承它的成员变量和方法;也可同时继承自 一个接口,继承接口的方法并完成定义。有一个神奇的魔法:同一种对象,都是IAct对象,调用同一种方法Act() 。但是执行的情况却完全不一样。...
  • 现在我们有一个接口,两个实现类,可能很多同学都是按照下面的方式去实现的 public interface CalculateService { public double calculate(double fee); public String userType(); } 第一个实现类 @Service("A...
  • 编写一个Book,该至少有name和price两个属性。该实现Comparable接口
  • 一、简单例子: 1. 直接new一个实例,这样肯定知道用的哪个实例 ...举个例子:A接口,A1,A2,A3实现A接口,有一个eat方法,A1:吃饭,A2:吃鱼,A3:吃肉 需要得到"吃肉",那么 A a = n
  • 4主要的map实现类介绍

    万次阅读 多人点赞 2019-07-31 18:36:57
    map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍): HashMap:我们最常用的Map,HashMap的值是没有顺序的,他是按照key的HashCode来...
  • 接口实现类

    千次阅读 2020-09-15 16:39:21
    2、接口中的方法都是抽象方法(public abstract 系统自带的,不需要写),但是 jdk1.8之后,还提供了默认方法:default(这实现类中重不重写都可以) 3、接口中的属性默认添加 public static final; 常量 即,...
  • 设计一个形状(接口)Shape,方法:求周长和求面积形状(接口)的子类(实现类);:Rect(矩形),Circle(圆形)Rect的子类:Square(正方形)不同的子类会有不同的计算周长和面积的方法。 创建三个不同的形状对象,放在Shape...
  • java 的接口可以实现接口吗?抽象呢?

    万次阅读 多人点赞 2017-05-15 15:52:56
    面试中可能会遇到这样的问题: 1.接口可以实现接口吗? ans:不可以. 2.抽象类可以实现接口吗? ans:可以
  • 接口实现:  (1)、定义一个接口IAssaultable(可攻击的)...(3)、定义一个抽象Weapon,实现IAssaultable接口和IMobile接口,但并没有给出具体的实现方法。 (4)、定义3个:Tank,Flighter,WarShip都继承自We
  • java中,一个类实现某个接口,必须重写接口中的所有方法吗???  java编程语言 专业回答 程秀娟 IT行业金牌讲师 北大青鸟中关村校区学术部 2015-09-29 10:30 不一定,关键要看子类是否是抽象...
  • java中如何在eclipse里查看一个接口的所有实现类?  Eclipsejava编程语言 专业回答 JAVA时空 团队 ala400 2015-05-29 16:27 首先选中接口类型名字,右键菜单,如图   然后会出来...
  • Java 抽象 接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口和抽象的概念不一样。...人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些实现它(类实现多个接口实现多个动作). 所以,在高级语言上,一个类只能继承一个类(抽象,jav
  • * @Description: 根据一个接口返回该接口的所有 * @param c 接口 * @return List<Class> 实现接口的所有 * @author LiYaoHua * @date 2012-4-5 上午11:22:24 */ @SuppressWarnings("unchecked") ...
  • 定义一个接口用来实现两个对象的比较。 interface CompareObject{  public int compareTo(Object o); //若返回值是 0 , 代表...定义一个ComparableCircle,继承Circle并且实现CompareObject接口。在Comparabl...
  • 通过反射机制获取位于同一个包下的接口的所有实现类  public class ClassUtils {   public static List getAllImplClassesByInterface(Class c) {   // 给一个接口,返回这个接口的所有实现类   List...
  • 分享一个大牛的人工智能教程。基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!...可以继承其他实现其他接口,在Swing编程和Android开发中常用此方式来实现事件监听和回调。 ...
  • Junit实现抽象接口类测试

    千次阅读 2018-03-22 20:48:39
    Junit实现抽象接口类测试 简单的目录: Junit实现抽象接口类测试 Junit实现接口类测试 Junit实现抽象测试() Junit实现抽象测试(二) JUnit使用abstract来进行测试 参考: Junit...
  • java找到指定接口实现类

    千次阅读 2020-02-10 13:30:20
    一、背景 想在自己开发的项目上加一个算法工具用来...因此开始在学习如何实现,在学习过程中发现需要写一个方法用来找到指定接口实现类,因此开启了这趟学习之旅。 二、寻求答案的路途 刚开始看到根据指定接...
  • 学习 java 第一天:从开始搭建项目,写第一个接口(IDEA)前言一、从开始搭建项目二、写第一个接口三、验证接口 前言 虽然我是一枚妥妥的前端无疑了,但是前端和后端的关系是密不可分的,数据对接是每个前后端的...
  • 实际编程过程中,我们可能遇到这样的问题,就是获取实现了指定接口类的所有实现类。 本工具就提供了这样的功能。下面是工具的详细解析: /** * 查找指定路径下面实现指定接口的全部 * @author longyin * ...
  • Java 枚举和自定义枚举和enum声明及实现接口1....若枚举只有一个成员, 则可以作为一种单例模式的实现方式 1.枚举的属性 枚举对象的属性不应允许被改动, 所以应该使用 private final 修饰...
  • 例子: 1. 直接new一个实例,这样肯定知道用的哪个实例 ...举个例子:A接口,A1,A2,A3实现A接口,有一个eat方法,A1:吃饭,A2:吃鱼,A3:吃肉 需要得到"吃肉",那么 A a = new A3(); 需要得到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,867,433
精华内容 746,973
关键字:

一个类可以实现零个接口