精华内容
参与话题
问答
  • 接口和接口实现类,接口与抽象类

    千次阅读 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 [抽象类]
    
    展开全文
  • 作者:Dion ...来源:知乎 著作权归作者所有。...“不如直接就在这个中写实现方法岂不是更便捷”,你怎么保证这个接口就一个实现呢?如果多个实现同一个接口,程序怎么知道他们是有关联的呢? 既然不是一...

    作者:Dion
    链接:https://www.zhihu.com/question/20111251/answer/14012223
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    “接口是个规范”,这句没错。
    “不如直接就在这个类中写实现方法岂不是更便捷”,你怎么保证这个接口就一个类去实现呢?如果多个类去实现同一个接口,程序怎么知道他们是有关联的呢?

    既然不是一个类去实现,那就是有很多地方有用到,大家需要统一标准。甚至有的编程语言(Object-C)已经不把接口叫 interface,直接叫 protocol。

    统一标准的目的,是大家都知道这个是做什么的,但是具体不用知道具体怎么做。
    比如说:
    我知道 Comparable 这个接口是用来比较两个对象的,那么如何去比较呢?
    数字有数字的比较方法,字符串有字符串的比较方法,学生(自己定义的类)也有自己的比较方法。

    然后,在另外一个负责对象排序(不一定是数字喔)的代码里面,肯定需要将两个对象比较。
    这两个对象是什么类型呢?
    Object a,b?肯定不行,a > b 这样的语法无法通过编译。
    int a,b?也不行?一开始就说了,不一定是数字。

    所以,Comparable 就来了。他告诉编译器,a b 两个对象都满足 Comparable 接口,也就是他们是可以进行比较的。具体怎么比较,这段程序不需要知道。
    所以,他需要一些具体的实现,Comparable 接口有一个方法,叫 compareTo。那么这个方法就是用来取代 <、> 这样的运算符。
    因为运算符是编译器保留给内置类型(整数、浮点数)进行比较用的,而不是一个广义的比较运算。

    如果你可以明白 JDK 自身库里面诸如 Comparable 这样已经有的接口,那么就很容易理解自己在开发程序的时候为什么需要用到接口了。

    这样写的第一个作用:

    “不如直接就在这个类中写实现方法岂不是更便捷”,你怎么保证这个接口就一个类去实现呢?如果多个类去实现同一个接口,程序怎么知道他们是有关联的呢?

    可能有些同学还不知道我们探讨的具体是什么问题。这里给出例子

    public abstract class Context {
    public final class ContextImpl extends Context {
    就如上面的文字部分所说,你怎么就保证了只有一个类会去实现这个接口呢?事实上,Context类的结构是这样的:

    (图片来自郭霖博客)

    但是,有的时候,我参看源码,又会发现,很多时候,一个接口只有一个实现类,他还是要这么做,这样是不是真的就多此一举了呢?

    很抱歉,依然不是多此一举。在这里的作用是——项目协作,是项目模块化的利器。当你决定把一个类,仅仅给自己用,而且不打算再度扩展,那么这个时候,你可以选择不用接口+接口impl的形式。但是一旦你是进行一个团队合作的话,你就必须这么做。这个时候,接口就成为了一个约定,你的团队成员就无需在意你的代码细节,只需要关注于你的功能即可。说到这里,你是否可以想到,后台给你的东西,也叫接口?你再好好想想何为接口?难道后台返回给你所有的代码才是最合适的吗?我来替你总结一下,接口的作用之一:别人替你做了一些事,只给你你个调用口,你就可以成功地使用这个调用口,去得到他在背后默默地替你做的所有的操作所返回的结果。这,就是接口。

    再说项目模块化。啥是项目模块化?我的师傅这样问我。我装B的回答:

    “不太懂 我目前的认知是 组件化像sdk一样
    只和调用者耦合“
    师傅又问,带着怒意:
    “ 模块化 懂 吗?”

    我:“不懂”

    师傅:“

    组件化 先别 去理解 了 那个东西 没有固定的 概念
    都是按个人理解
    模块 化 就好开解了
    好理解了
    用户中心 模块
    商城 模块
    o2
    o2o模块
    聊天模块
    网络请求可以 是模块 也可以叫组件
    类似这样
    每个模块 做每个模块固定的功能
    理解了?

    这回我懂了,什么聊天模块,商城模块就是模块。

    这个时候你可能感觉到接口的必要性了吧! 那么我的商城模块这么多类,又互不统一,怎么才能优雅的以接口的形式暴露出来呢?

    你可以弄一个托管类接口,再弄一个托管类impl,在托管类impl中进行一个调用即可。

    总结一下:

    1.用接口形成多实现体系,如集合框架

    2.项目协作, 最小代价、最优雅地暴露功能给队友

    3.模块化

    最后 看了一点effective java 又领悟到了模块之间解耦的作用

    这个不是我随便乱说的 我能讲通道理

    interface和interfaceImpl还有调用者。本来是调用者和类直接耦合了,现在是interface和interfaceImpl建立联系,interface和调用者建立联系,我们旨在减少调用者和类的直接联系,这叫封装,也叫信息隐藏。

    展开全文
  • java多态详解(接口指向实现类)

    千次阅读 多人点赞 2017-08-13 16:00:46
    java第三大特性多态,在开发中是相当重要,对于初学者来说能熟悉多态的思想却有很多难点,下面我来一一介绍...但是发现list只是ArrayList的接口不是它的父类 ,不是父类引用指向子类对象 如果是应该是AbstractLIst ablist=

    java第三大特性多态,在开发中是相当重要,对于初学者来说能熟悉多态的思想却有很多难点,下面我来一一介绍下

    我们学习到集合的时候发现了List<?> list= new ArrayList<?>

               Map<?,?> map = new  HashMap<?,?>

    但是发现list只是ArrayList的接口不是它的父类 ,不是父类引用指向子类对象

    如果是应该是AbstractLIst ablist= new ArraryList();  或者直接写为ArrayList<?> list= new ArrayList<?>


    是不是觉得有些懵逼,在初学阶段我就懵逼了,接口怎么创建对象了?接口是没有构造方法的!

    后来我百度查询了很多讲解对其介绍的不够透彻,只是解释为多态!于是查询了java神书  编程思想 里面这么解释接口,换成正常人听得懂的话:interface是特殊的抽象类---------接口可以看成是个类,这样一切就解释的通了


    为什么要用接口引用指向实现类的对象

    这种写法其实Java多态的表现形式

    1. 多态的定义指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)

    List list;是在栈区开辟一个空间放list引用,并没有创建对象所以不知道ArrayList还是LinkedList当你list= new ArrayList(); 就创建了ArrayList对象。并且把开始创建的list引用指向这个对象ArrayList和LinkedList都是List的实现类。

    为什么一般都使用 List list = new ArrayList() ,而不用 ArrayList alist = new ArrayList()呢? 

    问题就在于List有多个实现类,如 LinkedList或者Vector等等,现在你用的是ArrayList,也许哪一天你需要换成其它的实现类呢?,这时你只要改变这一行就行了:List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。假设你开始用 ArrayList alist = new ArrayList(), 这下你有的改了,特别是如果你使用了 ArrayList特有的方法和属性。 ,如果没有特别需求的话,最好使用List list = new LinkedList(); ,便于程序代码的重构. 这就是面向接口编程的好处

    注意事项

    list只能使用ArrayList中已经实现了的List接口中的方法,ArrayList中那些自己的、没有在List接口定义的方法是不可以被访问到的

    list.add()其实是List接口的方法

    但是调用ArrayList的方法如 clone()方法是调用不到的




    接口的灵活性就在于“规定一个类必须做什么,而不管你如何做”。我们可以定义一个接口类型的引用变量来引用实现接口的类的实例,当这个引用调用方法时,它会根据实际引用的类的实例来判断具体调用哪个方法,这和上述的超类对象引用访问子类对象的机制相似。

    [java] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. //定义接口InterA  
    2. interface InterA  
    3. {  
    4.  void fun();  
    5. }  
    6. //实现接口InterA的类B  
    7. class B implements InterA  
    8. {  
    9.  public void fun()  
    10.  {  
    11.   System.out.println(“This is B”);  
    12.  }  
    13. }  
    14.   
    15. //实现接口InterA的类C  
    16. class C implements InterA  
    17. {  
    18.  public void fun()  
    19.  {  
    20.   System.out.println(“This is C”);  
    21.  }  
    22. }  
    23.   
    24. class Test  
    25. {  
    26.  public static void main(String[] args)  
    27.  {  
    28.   InterA a;  
    29.   a= new B();  
    30.   a.fun();  
    31.   a = new C();  
    32.   a.fun();  
    33.  }  
    34. }  



        输出结果为:

        This is B
        This is C


      上例中类B和类C是实现接口InterA的两个类,分别实现了接口的方法fun(),通过将类B和类C的实例赋给接口引用a,实现了方法在运行时的动态绑定,充分利用了“一个接口,多个方法”,展示了Java的动态多态性。

      需要注意的一点是:Java在利用接口变量调用其实现类的对象的方法时,该方法必须已经在接口中被声明,而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配

    展开全文
  • EA_接口实现类

    2018-12-27 15:12:43
    实现类指向接口 点击该类右键---&gt;高级--&gt;父类   类型选择实现 然后找到相应的接口,最终会有一条虚线 指向接口

    实现类指向接口

    点击该类右键--->高级-->父类

     

    类型选择实现  然后找到相应的接口,最终会有一条虚线 指向接口

    展开全文
  • 接口实现类

    2018-12-08 17:41:30
    建立一个dao接口,建立一个dao实现类 public interface CustomerDao { //插入方法,传一个Customer对象进去  public void insert(Customer custname); //根据名字查询  public Customer selectByName(String ...
  • 接口实现类

    2020-09-15 16:39:21
    2、接口中的方法都是抽象方法(public abstract 系统自带的,不需要写),但是 jdk1.8之后,还提供了默认方法:default(这个在实现类中重不重写都可以) 3、接口中的属性默认添加 public static final; 常量 即,...
  • 一、简单例子: 1. 直接new一个实例,这样肯定知道用的哪个实例 ...举个例子:A接口,A1,A2,A3实现A接口,有一个eat方法,A1:吃饭,A2:吃鱼,A3:吃肉 需要得到"吃肉",那么 A a = n
  • Eclipse如何查看接口实现类快捷键

    万次阅读 多人点赞 2017-03-01 12:32:44
    1、找到要打开的接口类 2、双击接口名选中 3、按Ctrl+T打开接口实现类 以List接口为例,如下所示
  • IDEA查找接口实现类及快速实现接口

    万次阅读 2018-08-28 18:30:28
    查找接口实现类: IDEA 风格 ctrl + alt +B   IDEA快速实现接口快捷方式 ALT +INSERT  
  • Intellij IDEA 查找接口实现类的快捷键

    万次阅读 2018-06-10 19:13:33
    查找接口实现类:IDEA 风格 ctrl + alt +B在按F2查看详细文档注解查看类或接口的继承关系:ctrl + h1、IDEA_查找接口的实现 的快捷键 个人分类管理http://blog.csdn.net/u010003835/article/details/790366662、...
  • 调用接口实现类方式

    千次阅读 2019-08-29 10:24:14
    1.当要调用接口实现类时,有2种方法 (1)声明接口实现类实例化 (2)通过配置文件的方式,用<bean>和<property>两个标签,决定使用接口的那个实现类 2.遇到的问题,别人写好使,我写不好使 (1)...
  • 查看idea接口实现类快捷键

    万次阅读 2019-02-26 18:23:42
    查找接口实现类: IDEA 风格 ctrl+h
  • MyEclipse查看接口实现类快捷键

    千次阅读 2019-03-08 11:26:45
    1、找到要打开的接口类 2、双击接口名选中 3、按Ctrl+T打开接口实现类
  • IDEA创建接口实现类的快捷方式

    千次阅读 2019-10-29 16:09:53
    IDEA创建接口实现类的快捷方式 这个问题我疑惑很长时间,为什么idea不和eclipse和myeclipse快捷创建实现类 因为我一开始用的是eclipse和myeclipse所以先入为主了, 以为idea和前两者一样建立接口后可以直接快捷建立...
  • eclipse 查看接口实现类快捷键

    千次阅读 2019-03-16 21:41:54
    在接口类里按 Ctrl + T 会出现接口实现类列表
  • idea打开接口实现类的快捷键

    千次阅读 2019-11-08 14:40:27
    1、在WebApplicationInitializer接口页面,按【Ctrl+h】,弹出右侧实现类的窗口,可以看到WebApplicationInitializer接口有4个实现类,如下图: 2、双击某一个实现类即可跳转到该实现类的页面,如下图: ...
  • Eclipse中查找接口实现类快捷键

    千次阅读 2015-09-19 16:19:28
    先找到接口类打开,然后双击接口名选中,再按住ctrl+T就可以了。
  • c#中接口实现类的动态调用实现

    千次阅读 2016-03-29 20:04:57
    一个接口有多个实现类,但是要在程 序外(比如说配置文件或者数据库表里)定义到底应该掉用哪一个实现类,这样 可以极大的提高程序的扩展性,调试也方便维护,多人同时使用一个程序时也可 以根据不同的需要写自己的...
  • IDEA快速生成接口实现类

    千次阅读 2020-06-05 11:52:13
    1.打开接口类,将鼠标移到接口名称上,Alt+Enter后点击implements interface: 2.填写实现类名称,选择实现类要放入的包名: 3.选择你要实现的接口方法: 4.快速创建实现类成功:
  • IDEA 查找接口实现类的快捷键

    千次阅读 2019-06-13 10:08:15
    https://blog.csdn.net/HeatDeath/article/details/79468782 IDEA 风格 ctrl + alt +B Eclipse 风格 ctrl +T Ctrl+o 快速打开当前的基类(父类) ctrl + h 查看接口的继承关系: ...
  • 查找接口的实现类: IDEA 风格 ctrl + alt +B IDEA快速实现接口快捷方式 ALT +INSERT 例如:查看Subject接口的实现类;...一....Ctrl + O 查看我们继承的类或者接口中的方法...查看接口实现类中方法(就是我们使用接...
  • C# 找出接口实现类

    千次阅读 2017-09-08 10:43:06
    找出实现了IForm的所有实现类 public interface IForm { } 方法一: var types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes().Where(t => t.GetInterfaces().Contains(typeof...
  • springMVC 使用注解注入接口实现类

    万次阅读 2014-07-24 20:05:19
    1.比如有一个接口如下:public interface Filter { ...有如下接口实现类:public class TimeFilter implements Filter { @Override public String doFilter(String param) { return param...
  • eclipse查找接口实现类方法

    千次阅读 2016-12-09 11:35:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • MyEclipse 查找接口实现类的方法

    千次阅读 2013-03-22 16:37:17
    MyEclipse 查找接口实现类的方法[转+总结] MyeclipseEclipse.net   很多时候我们在研究一些程序的源代码时会遇到许多接口的实现类,但是在Eclipse中上溯查找的时候只能最终查到这个接口,而不能反过来直接...
  • java快速查看接口实现类的快捷键

    千次阅读 2020-03-27 21:59:26
    idea快捷键:ctrl+alt+b eclipse快捷键:ctrl+t
  • 在eclipse中查看和进入接口实现类的快捷键:Ctrl+鼠标左键,然后选择查看接口实现类; 在IDEA2018 中查看和进入接口实现类的快捷键: 1、第一中方式:选择接口类,按Ctrl+Alt+B 2、第二种方式:Ctrl+Alt+鼠标左键...
  • 多态的特性,实现多态的方式有三种:重写、接口、抽象和抽象方法。 这里是接口的多态特性,并且使用的是动态绑定(后期绑定)
  • 接口、抽象类和实现类

    千次阅读 2019-04-13 10:49:25
    接口、抽象类和实现类 1. 接口是最抽象的一层,不需要进行任何实现;抽象层可以实现部分接口方法,也可以自定义方法;实现类必须实现所有方法。 2. 接口能被类(抽象类和具体类)实现,区别在于抽象类实现接口,...

空空如也

1 2 3 4 5 ... 20
收藏数 2,222,850
精华内容 889,140
关键字:

接口实现类