精华内容
下载资源
问答
  • JAVA基础——接口(全网最详细教程)

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

                                       Java基础——接口


     

     

    接口概念


        官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)

        我的解释:接口可以理解为一种特殊的类,里面全部是由全局常量公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段,但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类,既接口中的方法必须全部是抽象方法。(JDK1.8之前可以这样理解)

     

    接口的特点


        就像一个类一样,一个接口也能够拥有方法和属性,但是在接口中声明的方法默认是抽象的。(即只有方法标识符,而没有方法体)。

     

    • 接口指明了一个类必须要做什么和不能做什么,相当于类的蓝图。
    • 一个接口就是描述一种能力,比如“运动员”也可以作为一个接口,并且任何实现“运动员”接口的类都必须有能力实现奔跑这个动作(或者implement move()方法),所以接口的作用就是告诉类,你要实现我这种接口代表的功能,你就必须实现某些方法,我才能承认你确实拥有该接口代表的某种能力。
    • 如果一个类实现了一个接口中要求的所有的方法,然而没有提供方法体而仅仅只有方法标识,那么这个类一定是一个抽象类。(必须记住:抽象方法只能存在于抽象类或者接口中,但抽象类中却能存在非抽象方法,即有方法体的方法。接口是百分之百的抽象类
    • 一个JAVA库中接口的例子是:Comparator 接口,这个接口代表了“能够进行比较”这种能力,任何类只要实现了这个Comparator接口的话,这个类也具备了“比较”这种能力,那么就可以用来进行排序操作了。

    为什么要用接口


    1.     接口被用来描述一种抽象。
    2. 因为Java不像C++一样支持多继承,所以Java可以通过实现接口来弥补这个局限
    3. 接口也被用来实现解耦。
    4. 接口被用来实现抽象,而抽象类也被用来实现抽象,为什么一定要用接口呢?接口和抽象类之间又有什么区别呢?原因是抽象类内部可能包含非final的变量,但是在接口中存在的变量一定是final,public,static的。

     

     

     

    接口的语法实现


        为了声明一个接口,我们使用interface这个关键字,在接口中的所有方法都必须只声明方法标识,而不要去声明具体的方法体,因为具体的方法体的实现是由继承该接口的类来去实现的,因此,接口并不用管具体的实现。接口中的属性默认为Public Static Final.一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。

        一个简单的接口就像这样:拥有全局变量和抽象方法。

        为了实现这个接口,我们使用implements关键词去实现接口:

    其中testClass类实现了我们上面刚才定义的 in1 这个接口,既然你要实现接口,也就是实现接口代表的一种能力,那么你就必须去实现接口给你规定的方法,只有把接口给你规定的抽象方法都给实现了,才承认你这个类实现了这个接口,实现了这个接口代表的某种功能。上图实现了接口中规定的display()方法。

        写一个测试类,用来测试一下我们刚才实现的这个接口,因为testclass类的对象t实现了接口规定的display方法,那么自然而然就可以调用display()方法咯。

        有兴趣的同学可以去这个在线IDE亲自试一试:点击打开链接

     

     

    接口的进一步理解


     

        我们知道,如果某个设备需要向电脑中读取或者写入某些东西,这些设备一般都是采用USB方式与电脑连接的,我们发现,只要带有USB功能的设备就可以插入电脑中使用了,那么我们可以认为USB就是一种功能,这种功能能够做出很多的事情(实现很多的方法),其实USB就可以看做是一种标准,一种接口,只要实现了USB标准的设备我就认为你已经拥有了USB这种功能。(因为你实现了我USB标准中规定的方法),下面是具体的例子:

     

    先声明USB接口:其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法。

    interface USB {
       
    void read();

       
    void write();
    }

    然后在写一个U盘类和一个键盘类,这两个类都去实现USB接口。(实现其中的方法)

    class YouPan implements USB {

        @Override

        public void read() {

            System.out.println("U盘正在通过USB功能读取数据");

        }

        @Override

        public void write() {

            System.out.println("U盘正在通过USB功能写入数据");

        }

    }

     

     

    这是U盘的具体实现。

    class JianPan implements USB {

        @Override

        public void read() {

            System.out.println("键盘正在通过USB功能读取数据");

        }

        @Override

        public void write() {

            System.out.println("键盘正在通过USB功能写入数据");

        }

    }

     

     

    这是键盘的具体实现。

        那么,现在U盘和键盘都实现了USB功能,也就是说U盘和键盘都能够调用USB接口中规定的方法,并且他们实现的方式都不一样。

    我们在写一个测试,来看看具体的实现:

    public class Main {

        public static void main(String[] args) {

            //生成一个实现可USB接口(标准)的U盘对象

            YouPan youPan = new YouPan();

            //调用U盘的read( )方法读取数据

            youPan.read();

            //调用U盘的write( )方法写入数据

            youPan.write();

            //生成一个实现可USB接口(标准)的键盘对象

            JianPan jianPan = new JianPan();

            //调用键盘的read( )方法读取数据

            jianPan.read();

            //调用键盘的write( )方法写入数据

            jianPan.write();

        }

    }

     

     

     

    结果如下:

     

     

        感兴趣的同学可以去在线IDE平台自己验证一下:点击打开链接

     

     

    关于接口的几个重点


    1. 我们不能直接去实例化一个接口,因为接口中的方法都是抽象的,是没有方法体的,这样怎么可能产生具体的实例呢?但是,我们可以使用接口类型的引用指向一个实现了该接口的对象,并且可以调用这个接口中的方法。因此,上图中最后的方法调用我们还可以这样写:(实际上就是使用了Java中多态的特性)

    public class Main {

        public static void main(String[] args) {

            //生成一个实现可USB接口(标准)的U盘对象

            //但是使用一个接口引用指向对象

            //USB接口类引用可以指向一个实现了USB接口的对象

            USB youPan = new YouPan();

            //调用U盘的read( )方法读取数据

            youPan.read();

            //调用U盘的write( )方法写入数据

            youPan.write();

            //生成一个实现可USB接口(标准)的键盘对象

            //但是使用一个接口引用指向对象

            //USB接口类引用可以指向一个实现了USB接口的对象

            USB jianPan = new JianPan();

            //调用键盘的read( )方法读取数据

            jianPan.read();

            //调用键盘的write( )方法写入数据

            jianPan.write();

        }

    }                                                                                                                                     

     

     2.一个类可以实现不止一个接口。

     

    3.一个接口可以继承于另一个接口,或者另一些接口,接口也可以继承,并且可以多继承

    4.一个类如果要实现某个接口的话,那么它必须要实现这个接口中的所有方法。

    5.接口中所有的方法都是抽象的和public的,所有的属性都是public,static,final的。

    6.接口用来弥补类无法实现多继承的局限。

    7.接口也可以用来实现解耦。

    接口的通俗理解


     

        前面我们讲多态的时候用“空调”——“遥控器”的方式去理解多态,实际上在上面的的几个重点中的第一条讲的也是多态的实现,比如,我们可以把“节能”作为一种标准,或者说节能就是一个“接口”,这个接口中有一个方法,叫做变频方法,任何空调,如果要称得上叫做节能空调的话,那么必须实现“节能”这个接口,实现“节能”这个接口,也就必须实现“节能”接口中规定实现的“变频”方法,这样才算是真正的实现了“节能”这个接口,实现了“节能”这个功能。

        当某个空调实现了“节能”接口后,这个空调就具备了节能的功能,那么我们也可以不用空调类的引用指向空调对象,我们可以直接使用一个“节能”接口类型引用的“遥控器”去指向“空调”,虽然这个“遥控器”上面只有一个按键,只有一个“变频”的方法,但是“遥控器”所指向的空调是实现了“节能”这个接口的,是有“变频”方法的实现的,我们用这个只有一个“变频”方法的遥控器去命令空调调用“变频”方法,也是行得通的,实在不清楚的同学可以去看我的另一篇文章:JAVA之对象的多态性

     

     

    接口的标识用法


        虽然接口内部定义了一些抽象方法,但是并不是所有的接口内部都必须要有方法,比如Seriallizable接口,Seriallizable接口的作用是使对象能够“序列化”,但是Seriallizable接口中却没有任何内容,也就是说,如果有一个类需要实现“序列化”的功能,则这个类必须去实现Seriallizable接口,但是却并不用实现方法(因为接口中没有方法),此时,这个Serilizable接口就仅仅是一个“标识”接口,是用来标志一个类的,标志这个类具有这个“序列化”功能。具体的实现请参考我的另一篇文章——JAVA之IO流。

     

    接口在生活中的思想体现


    其实,在我们的生活当中,有很多地方都体现了“接口”的思想,想必,正在阅读这篇博文的你,是不是也喜欢摄影呢?

    佳能(Canon)EOS 80D 单反相机 单反套机(EF-S 18-200mm f/3.5-5.6 IS 单反镜头)

    玩摄影的童鞋都知道,单反由相机镜头组成,相机分不同的型号,有半画幅的,也有全画幅的。镜头也是一样的,分长焦,短焦;还有定焦和变焦。每种镜头都有各自特定的发挥场景正是因为镜头的多元化,使得我们的摄影能够“术业有专攻”。大家想一想,如果我们的单反相机部分和镜头部分是固定在一起的,不能够更换镜头,那么将会多么的糟糕啊!

    因此,每个相机品牌为了能够兼容不同的镜头,各自发布了一套镜头卡口的标准,这套标准就好比我们前面提到的“接口”,都是某种“约束”。举个栗子,我们佳能的相机,不管你是哪一家镜头生产厂商,腾龙也好,适马也好,只要你按照我佳能卡口的标准来生产镜头,你生产的镜头都能够很好的在我佳能相机上面驱动。

    因此,当我们打开“狗东”,准备给自己的新相机买镜头的时候,就不难发现,我们需要根据自己相机的品牌来挑选特定卡口的镜头,这样的镜头才能被我们的相机正常驱动。

    回到Java上面来说,其实接口给我们带来的最大的好处就是“解耦”了,相机能够搭配不同的镜头,才能有各种各样的搭配玩法,变得更加的灵活。在软件系统中也是一样的,接口可以有很多不同“特色”的实现类,我们只需要声明同一个接口,却可以引用很多个该“接口”引申出来的“子类”,这不也大大增强了我们软件系统中组件的灵活性吗?

    聪明的你,对于“接口”的理解是不是又更加的深入了呢?

     

    基础不牢?新手不友好?无人带路?关注《扬俊的小屋》公众号吧!


     

     

     

    参考资料


    1.Java开发实战经典》 李兴华著  清华大学出版社

    2.https://www.geeksforgeeks.org/interfaces-in-java  作者:Mehak Kumar. and Nitsdheerendra.   翻译:刘扬俊

     

    博客文章版权说明


    第一条 本博客文章仅代表作者本人的观点,不保证文章等内容的有效性。

    第二条 本博客部分内容转载于合作站点或摘录于部分书籍,但都会注明作/译者和原出处。如有不妥之处,敬请指出。

    第三条 征得本博客作者同意的情况下,本博客的作品允许非盈利性引用,并请注明出处:“作者:____转载自____”字样,以尊重作者的劳动成果。版权归原作/译者所有。未经允许,严禁转载

    第四条 对非法转载者,“扬俊的小屋”和作/译者保留采用法律手段追究的权利

    第五条 本博客之声明以及其修改权、更新权及最终解释权均属“扬俊的小屋”。

    第六条 以上声明的解释权归扬俊的小屋所有。

     

    展开全文
  • Java接口

    千次阅读 多人点赞 2018-12-24 12:00:36
    Java接口也表示IS-A关系。它不能像抽象类一样被实例化。 q) Java为什么需要接口 通过接口实现多继承 用于实现耦合 如下图所示,一个类扩展了另一个类,一个接口扩展了另一个接口,一个类实现了一个接口。 接...


    java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它不能像抽象类一样被实例化。

    q) Java为什么需要接口

    • 通过接口实现多继承
    • 用于实现耦合
      如下图所示,一个类扩展了另一个类,一个接口扩展了另一个接口,一个类实现了一个接口。
      在这里插入图片描述

    接口的用法

    interface Printer{                                                                //打印机的接口
    	void print();                                                        //打印机的打印方法
    }
    

    电脑来了

    class  Computer implements Printer{                                           //computer连接了Printer的方法
    	@override
    	public void print(){
    		System.out.println("我是电脑");                                        //把msg的方法打印出来
    	}
    }
    

    手机来了

    class SmartPhone implements Printer{                                   //手机连接了打印机
    	@override
    	public void print(){
    		System.out.println("我是智能手机");                           //手机的println()方法
    	}
    }
    

    Java 8接口特性

    Java 8以前的接口只能有抽象方法,不能有方法体
    Java 8开始可以有方法体,但是只能是默认的方法体和静态方法

    Q)为什么要加这两个特性呢?
    A)简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。我们只需在方法名前面加个default关键字即可实现默认方法。该策略可以解决多继承的问题。

    default方法可以解决兼容性问题和简单的解决多继承问题

    Java8之前
    HeadFirst Java 时,作者说,为了解决多重继承所引起的“致命方块问题”
    在这里插入图片描述
    所以Java不用多重继承,用多重实现,但是在多重实现中,这个问题解决了吗?还没有

    interface CanonPrinter{
    	void print();
    }
    
    interface DeliPrinter{
    	void ptint();
    }
    

    有一个类两个接口都支持,但是当答打印的时候

    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public void print(){
    		System.out.println("This is computer!!!");
    	}
    	public static void main(String[] args){
    		new Computer.print();
    	}
    }
    

    这个时候会出来个问题,你重写的打印的方法到底是实现了哪个接口的打印方法?
    如果CannonPrinter接口和DeliPrinter接口的print()方法相同,那么编译器认为你同时都实现了两个接口的两个方法,并且运行哪个方法都可以,因为两个接口的print()方法都一样。
    输出结果

    This is computer!!!
    

    如果同名方法只是参数类型不同呢?

    interface CanonPrinter{
    	void print(StringBuilder msg);
    }
    
    interface DeliPrinter{
    	void ptint(String msg);
    }
    
    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public void print(String msg){
    		System.out.println(msg);
    	}
    
    	@override
    	public void print(StringBuilder msg){
    		System.out.println(new StringBuilder(msg));
    	}
    	
    	public static void main(String[] args){
    		new Computer.print("This is Computer!!!");
    		new Computer.print(new StringBuilder("This is Computer!!!"))
    	}
    }
    

    编译器可以准确区分,没有产生歧义,所以输出结果

    This is Computer!!!
    This is Computer!!!
    

    如果print()方法返回参数不同呢?

    interface CanonPrinter{
    	String print();
    }
    interface DeliPrinter{
    	StringBuilder ptint();
    }
    
    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public String print(){                             //如果只实现了CanonPrinter 的返回类型为String的print(),
    		return "This is computer!!!";               //没有实现DeliPrinter的StringBuilder的print()方法,编译器会报错	                                                                         
    	}                                                  //所以只实现一个接口的方法,是违背接口的规则的,不能通过编译。
    
    	@override
    	public int  print(){                                     //如果实现了两个方法,编译器则会报错,因为名字重复
    		return new StringBuilder("This is computer!!!");  //当对象调用的时候,不知道调用的是哪个方法                                                                         
    	}                                                        
    
    	
    	public static void main(String[] args){
    		new Computer.print();                                      //我调用的是哪个方法呢?
    	}
    }
    

    如果两个不同的接口各有同名且不同返回类型的方法,如果一个类想同时实现这两个接口,无解,在编译时就会报错,没有办法实现。除非把问题变得复杂,使用内部类。

    interface CanonPrinter{
    	String print();
    }
    interface DeliPrinter{
    	StringBuilder ptint();
    }
    
    class Computer implements CannonPrinter{
    	@override
    	public String print(){                             
    		return "This is computer!!!";               
    	}                                                  
    
    	@override
    	public int  print(){
    		return new StringBuilder("This is computer!!!");  
    	}                                                        
    	class MultiComputer implements DeliPrinter{
    		@override
    		public String print(){                            
    			return "This is computer!!!"; 
    		}                                                  
    
    		@override
    		public int  print(){
    			return new StringBuilder("This is computer!!!");  
    		}
    	}
    }
    

    但是Java8新特性后

    public class Java8Tester {
       public static void main(String args[]){
          Vehicle vehicle = new Car();
          vehicle.print();
       }
    }
     
    interface Vehicle {
       default void print(){
          System.out.println("我是一辆车!");
       }
        
       static void blowHorn(){
          System.out.println("按喇叭!!!");
       }
    }
     
    interface FourWheeler {
       default void print(){
          System.out.println("我是一辆四轮车!");
       }
    }
     
    class Car implements Vehicle, FourWheeler {
       public void print(){
          Vehicle.super.print();
          FourWheeler.super.print();
          Vehicle.blowHorn();
          System.out.println("我是一辆汽车!");
       }
    }
    

    输出结果

    我是一辆车!
    我是一辆四轮车!
    按喇叭!!!
    我是一辆汽车!
    

    这样你就可以区分使用哪个接口的方法。
    同时default方法还可以解决兼容性。
    当你在接口中添加一个方法时,需要所有实现它的类都实现它的抽象方法。就会带来不必要的操作,但如果使用默认方法,你只需在接口中添加好方法体,之后在需要实现的类中调用就可以了,减少了不必要的操作。
    例如:

    interface Printer{
    	void print{};
    }
    

    实现类

    class computer implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is Computer");
    	}
    }
    class SmartPhone implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is smartPhone");
    	}
    }
    

    如果需要给接口添加一个方法

    interface Printer{
    	void print{};
    	default void println(){
    		System.out.println("增加了Println()方法")
    	};                                                                                   //新添加的方法
    }
    

    实体类需要实现

    class Computer implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is Computer");
    	}
    	@override
    	default void prinln(){
    		System.out.println("This is println() for Computer");             //这里用,就在这里重写好了,其他实现了Printer的类就不用管了
    	}
    	
    }
    class SmartPhone implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is smartPhone");
    	}
    }
    

    接口中的静态方法可以用做保存常用方法

    我们知道常量可以用接口来保存
    例如

    interface addressCodeConstant{
    	String CHINA = "CN";
    	String AMERICA = "US";
    }
    

    同理常用方法,也就是常用工具方法可以用static来修饰
    例如

    interface getAddressCode{
    	static String returnAdressCod(String country){
    		switch (country){
    			case CHINA :
    				return CN;
    			case AMERICA:
    				return US;
    			default:
    				retrun null;
    		} 	
    	}
    }
    

    相当于

    public final getAddressCode{
    	public String returnAdressCod(String country){
        		switch (country){
        			case CHINA :
        				return CN;
        			case AMERICA:
        				return US;
        			default:
        				retrun null;
        		} 	
        	}
    }
    

    只不过以后的常用方法可以存储像常量一样存储在接口中了。

    标记接口

    没有成员的接口(仅定义一个空的接口)称为标记或标记接口。 例如:可序列化,可克隆,远程等。它们用于向JVM提供一些基本信息,以便JVM可以执行一些有用的操作。

    //How Serializable interface is written?  
    public interface Serializable{  
    
    }
    
    展开全文
  • 新手小白学JAVA 接口 面向接口开发

    万次阅读 多人点赞 2021-05-13 13:35:52
    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。 接口并不是类,编写接口的方式和类很相似,但是...

    接口

    1 接口的概念

    与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型,接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

    2 接口格式

    在这里插入图片描述

    3 接口的特点:

    1. 通过interface关键字来定义接口
    2. 通过implements让子类来实现接口
    3. 接口中的方法全部都是抽象方法(JAVA8)
    4. 可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
    5. 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
    6. 接口突破了java单继承的局限性
    7. 接口和类之间可以多实现,接口与接口之间可以多继承
    8. 接口是对外暴露的规则,是一套开发规范
    9. 接口提高了程序的功能拓展,降低了耦合性
      在这里插入图片描述

    4.1 练习-1:创建接口

    创建包: cn.tedu.inter
    创建接口:Inter.java

    package cn.tedu.inter;
    /*本接口用于创建接口测试*/
    /*1.我们通过interface关键字来定义接口*/
    public interface Inter {
        /*2.接口中可以定义普通方法吗?--不可以!*/
        //public void eat(){}
        /*3.接口中可以定义抽象方法吗?--可以,接口中的方法都是抽象方法!*/
        public abstract void eat();
        public abstract void play();
    }
    

    4.2 练习-2:创建接口实现类

    创建包: cn.tedu.inter
    创建接口实现类:InterImpl.java

    package cn.tedu.inter;
    /*本类作为Inter接口的实现类*/
    /*1.实现类如果想要实现接口定义的功能,需要与接口建立实现关系
    * 通过关键字implements来建立实现类 实现 接口的关系*/
    /*2.1 方案一:如果实现类与接口建立实现关系以后
    可以选择不实现接口中的抽象方法,把自己变成一个抽象类*/
    //abstract public class InterImpl implements Inter{//方案一
    /*2.2方法二:如果实现类与接口建立实现关系以后
    * 还可以选择实现接口中的所有抽象方法,把自己变成一个普通子类*/
    public class InterImpl implements Inter{
        @Override
        public void eat() {
            System.out.println("吃火锅");
        }
        @Override
        public void play() {
            System.out.println("玩代码");
        }
    }
    
    

    4.3 练习-3:创建接口测试类

    创建包: cn.tedu.inter
    创建接口测试类:InterTests.java

    package cn.tedu.inter;
    /*本类用于运行测试接口实现类*/
    public class InterTests {
        public static void main(String[] args) {
            /*接口可以实例化吗?--不可以!!!*/
            //Inter i = new Inter();
    
            //创建多态对象进行测试--不常用
            Inter i = new InterImpl();
            i.eat();
            i.play();
    
            //创建纯纯的接口实现类对象进行测试--推荐使用
            InterImpl i2 = new InterImpl();
            i2.eat();
            i2.play();
        }
    }
    

    5 接口的用法

    5.1 练习: 接口之构造方法

    创建包: cn.tedu.inter2
    创建类:TestUserInter.java

    package cn.tedu.inter2;
    /**本类用于进一步测试接口的使用*/
    public class TestUserInter {
    	//5.创建入口函数main()
    	public static void main(String[] args) {
    		/**查看类的继承结构:Ctrl+O*/
    		Inter2 i = new Inter2Impl();
    	}
    }
    //1.创建接口
    interface UserInter{
        //2.测试接口中是否包含构造方法
        //public UserInter(){}
        /*1.接口里没有构造方法*/
    }
    
    //3.创建接口的实现类
    class UserInterImpl implements UserInter{
        //4.创建实现类的构造方法
        public UserInterImpl(){
            /*2.如果一个类没有明确指定它的父类,那么它默认继承顶级父类Object*/
            super();/*3.此处调用的父类的无参构造是Object的无参构造*/
            System.out.println("我是子实现类的无参构造");
        }
    }
    
    总结:接口里是没有构造方法的
    如果一个类没有明确指定它的父类,那么它默认继承顶级父类Object,调用的super()是Object的无参构造

    5.2 练习: 接口之成员变量

    package cn.tedu.inter2;
    /*本类用于进一步测试接口的使用*/
    public class TestUserInter {
        public static void main(String[] args) {
            //6.测试接口中的静态常量
            System.out.println(UserInter.age);//静态,因为可以被接口名直接调用
            //UserInter.age = 37;//final,因为值不可以被修改
        }
    }
    //1.创建接口
    interface UserInter{
        //5.测试接口中是否可以定义成员变量
        /*4.接口中的是静态常量,实际上的写法是public static final int age = 20;
        * 只不过接口中可以省略不写,会默认拼接,所以写成 int age = 20;也可以*/
        public static final int age = 20;
    }
    //3.创建接口的实现类
    class UserInterImpl implements UserInter{
      
    }
    
    
    总结:接口里没有成员变量,都是常量。所以,你定义一个变量没有写修饰符时,默认会加上:public static final

    5.3 练习: 接口之成员方法

    package cn.tedu.inter2;
    /*本类用于进一步测试接口的使用*/
    public class TestUserInter {
        public static void main(String[] args) {
           UserInterImpl u = new UserInterImpl();
            u.eat();
            u.play();
        }
    }
    //1.创建接口
    interface UserInter{
        //7.测试接口中有抽象方法吗?
        /*5.接口中抽象方法的定义可以简写,会自动给方法拼接public abstract*/
        public abstract void eat();
        void play();
    }
    //3.创建接口的实现类
    class UserInterImpl implements UserInter{
        @Override
        public void eat() {
    		System.out.println("实现接口中的抽象方法1");	
        }
        @Override
        public void play() {
    		System.out.println("实现接口中的抽象方法2");
        }
    }
    
    总结:接口里的方法,默认都是抽象的,方法上会默认拼接public abstract。例如:public abstract void save();

    6 练习:分析老师示例—面向接口编程

    具体事物: 培优班老师 高手班老师
    共性: 讲课 备课
    创建包: cn.tedu.inter2
    创建类:TestTeacherInter.java

    package cn.tedu.inter2;
    /*本类用于面向接口编程*/
    public class TestTeacherInter {
        public static void main(String[] args) {
            CGBTeacher ct = new CGBTeacher();
            ct.ready();
            ct.teach();
        }
    }
    //1.创建老师接口--接口是先天设计的结果,最先设计的就是接口,要制定规则
    interface Teacher{
        //2.定义接口里的方法
        void teach();//授课方法
        void ready();//备课方法
    }
    class CGBTeacher implements Teacher{
        @Override
        public void teach() {
            System.out.println("授课电商项目");
        }
        @Override
        public void ready() {
            System.out.println("备课电商项目");
        }
    }
    class ACTTeacher implements Teacher{
        @Override
        public void teach() {
            System.out.println("正在授课基础加强+框架加强");
        }
        @Override
        public void ready() {
            System.out.println("正在备课基础加强+框架加强");
        }
    }
    abstract class SCDTeacher implements Teacher{
    
        @Override
        public void ready() {
            System.out.println("正在研发新课程。。。");
        }
    }
    

    7 接口的多继承多实现

    创建包: cn.tedu.inter2
    创建类:TestRelation.java

    package cn.tedu.inner2;
    
    import cn.tedu.inter.Inter;
    
    /*本类用于测试接口与类之间的复杂关系*/
    public class TestRelation {
        public static void main(String[] args) {
            //创建对象进行功能测试
            Inter3Impl i = new Inter3Impl();
            i.save();
            i.delete();
            i.update();
            i.find();
        }
    }
    
    //1.创建接口1
    interface Inter1{
        void save();//保存功能
        void delete();//删除功能
    }
    //2.创建接口22
    interface Inter22{
        void update();//更新功能
        void find();//查询功能
    }
    //3.创建接口1的实现类
    class Inter1Impl implements Inter1{
        @Override
        public void save() { }
        @Override
        public void delete() { }
    }
    
    //4.创建接口3,同时继承两个接口
    /*1.接口可以继承接口,并且可以多继承,多个接口之间用逗号隔开*/
    interface Inter3 extends Inter1,Inter22{ }
    
    //5.创建接口3的实现类
    /*2.接口与实现类是实现的关系,并且可以多实现,多个接口之间用逗号隔开
    * 对于Java中的类而言,遵循:单继承 多实现
    * 一个类只能有一个父类,但是一个类可以实现多个接口*/
    //class Inter3Impl implements Inter3{//写法1
    class Inter3Impl implements Inter1,Inter22{//写法2
        @Override
        public void save() {
            System.out.println("稍等...正在努力保存中...");
        }
        @Override
        public void delete() {
            System.out.println("删除成功!");
        }
        @Override
        public void update() {
            System.out.println("小二正在马不停蹄的更新~");
        }
        @Override
        public void find() {
            System.out.println("客官,马上就查询好啦,稍等一丢丢~");
        }
    }
    

    8 总结

    1. 类与类的关系

    继承关系,只支持单继承
    比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源和构造方法)
    子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)

    2. 类和接口的关系

    实现关系.可以单实现,也可以多实现
    class A implements B,C{}
    其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类

    3. 接口与接口的关系

    是继承关系,可以单继承,也可以多继承
    interface A extends B,C{}
    其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
    class X implements A{}
    X实现类需要重写ABC接口的所有方法,否则就是抽象类
    class A extends B implements C,D{}
    其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
    这时A需要重写CD接口里的所有抽象方法

    4. 抽象类与接口的区别

    抽象类是一个特殊的类,特殊在,抽象类中可以包含没有方法体的方法(抽象方法)
    接口可以理解成一个特殊的抽象类,特殊在,接口里的都是抽象方法,没有普通方法
    接口会为方法自动拼接public abstract,还会为变量自动拼接public final static
    抽象类可以有成员变量成员常量 接口只能有静态常量
    抽象类可以有构造方法–用来给子类创建对象,接口中没有构造方法
    抽象类和接口都不能实例化(创建对象)
    接口可继承接口,并可多继承接口,但类只能单继承
    抽象方法只能声明,不能实现,接口是设计的结果 ,抽象类是重构的结果

    展开全文
  • java接口和类的区别Java 接口

    万次阅读 2016-11-07 20:47:55
    Java 接口 接口(interface)在java语言中就是一个抽象类型,但接口并不是一个抽象类,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。 接口并不是类...

    Java 接口

    接口(interface)在java语言中就是一个抽象类型,但接口并不是一个抽象类,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

    接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类是描述对象的属性和方法。而接口却是包含类要实现的方法。

    除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。当类要实现接口中的方法时候,若这个类不是抽象类的话,这个类就要去实现接口中所有的方法、

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在Java中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

    抽象类(abstract) :若一个类是用abstract修饰,并且没有方法体的实现的话,就说明是个抽象类;

    还有若有空可以去看看runoob.com网站,那也有很多的资源;

    展开全文
  • java接口中的default方法

    万次阅读 多人点赞 2018-02-24 17:26:16
    java8以后,接口中可以添加使用default或者static修饰的方法,在这里我们只讨论default方法,default修饰方法只能在接口中使用,在接口种被default标记的方法为普通方法,可以直接写方法体。实现类会继承接口中的...
  • A、一个Java接口是一些方法特征的集合,但没有方法的实现 B、Java接口中定义的方法在不同的地方被实现,可以具有完全不同的行为 C、Java接口中可以声明私有成员 D、Java接口不能被实例化 答案:C 解释: A:接口就是...
  • Java接口及接口继承

    千次阅读 2019-04-24 17:57:13
    Java接口 开发工具与关键技术:My Eclipse 10、Java 作者:郑凯丰 撰写时间: 2019年5月2日 修饰符 :public 、abstract [修饰符] interface 接口名称 extends 父接口,父接口1,… { 静态常量定义; 抽象方法定义;...
  • java接口测试

    千次阅读 2017-11-14 10:30:55
    第一次做接口测试,网上找了很久,找不到想要的,只能自己摸索写了测试代码T.T ApiRequestUtil.javapackage com.util.api;import java.io.BufferedReader; import java.io.IOException; import java.io....
  • JAVA接口机制

    万次阅读 2020-05-14 19:17:18
    java支持多继承吗,答案是否定的 java不支持多继承 接口中所有的方法自动的属于public 接口的特性 接口不是类,不能实例化, 抽象类也不能实例化 可以声明接口类型的变量 抽象类也能声明抽象类型的变量 这个...
  • java接口开发流程

    千次阅读 2018-12-16 18:46:03
    java接口开发流程 前后端分离接口写法 前后端不分离写法
  • java接口可以继承多个接口

    千次阅读 2019-03-07 19:11:54
    classB extends classAjava接口可以多继承。Interface3 extends Interface0, Interface1, interface…… 不允许类多重继承的主要原因是,如果A同时继承B和C,而b和c同时有一个D方法,A如何决定该继承哪一个呢? 但...
  • Java接口继承接口

    万次阅读 2019-02-27 08:49:26
    接口A有个方法getName(),接口B继承接口A,不用复写接口A的方法,写接口B自己的东西(业务)即可,当一个类C去继承B接口的时候,是需要复写两个接口中的方法的实现的——语法层 意义: 举个都知道的东西——书。...
  • java接口的意义

    万次阅读 多人点赞 2019-05-23 16:51:55
    1. java当中继承一个接口,要重写他的方法的话,那为什么还要多此一举的去实现一个接口呢? 直接把方法写在类当中不就可以了? 就是说去掉类名后面的Implements 接口 ,可以不可以呢? 统一访问: 接口的最主要的...
  • java web开发(二) 接口开发

    万次阅读 多人点赞 2016-06-03 16:50:34
    java web开发(一) 环境搭建讲解了如何搭建一个Java Web项目,如果你还没了解,建议先浏览下!今天这篇文章主要讲解的就是接口开发,打算使用比较古老的或者说比较原始方法实现的接口。 一.数据库设计。 假设要做...
  • Java接口 详解(一)

    万次阅读 多人点赞 2016-10-06 00:46:42
    一、基本概念接口(Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。如果一个类只由抽象方法和全局常量组成,...
  • Java 接口实例化

    千次阅读 多人点赞 2019-08-09 10:14:46
    但是可以在 Java 中,使用接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。 public interface TestInterface{} TestInterface testInterface = new TestInterface();//...
  • 快速理解什么是java接口

    千次阅读 2018-09-24 12:21:32
    什么是接口 接口就是调用方法 ......由一个接口定义这个方法>>>>实现这接口方法>>>>在类中调用   接口的特点         例:   ...
  • 什么是java 接口,用处是什么

    万次阅读 多人点赞 2017-05-02 13:39:16
    关于学习到java ,很多人可能接触到接口,但并不理解接口的用处,其实接口很简单,其作用有两个 1 泛化  下面请看代码  public void feed(Chicken chiken){//喂鸡  giveFood();//给予食物  chicken..eat()...
  • java接口interface理解,接口作用

    万次阅读 2017-12-17 20:35:22
    java 接口interface 1. 固定统一调用的方法(想想适配器模式)public void somefunc(HttpServletRequest resq){ //调用时传来实现该接口的类就行 //里面直接调用接口方法2. 标记作用,作为一个类的标记, 里面空方法...
  • Java 接口做参数,接口回调

    千次阅读 2020-07-05 15:53:33
    JAVA接口做参数,接口回调 接口做参数:将实现某接口的类的对象的引用用作参数传递给该接口参数。该接口通过回调来实现该接口方法。 接口回调:实现某接口的类的对象的引用,赋值给该接口声明的接口变量。 难以理解...
  • JAVA接口调试

    千次阅读 2017-07-10 16:39:31
    2、服务器启动后,直接在浏览器地址栏输入要调试的接口; 3、如果有请求参数,请在调试接口的路径结尾处加上:“?”+请求参数+“=”+请求值。如:127.0.0.1:8080/WebProject/LoginServlet?userName=jim&password=...
  • Java调用第三方接口示范

    万次阅读 多人点赞 2018-10-08 15:03:53
    在项目开发中经常会遇到调用第三方接口的情况,比如说调用第三方的天气预报接口。 使用流程 【1】准备工作:在项目的工具包下导入HttpClientUtil这个工具类,或者也可以使用Spring框架的restTemplate来调用,上面...
  • Java接口继承和使用接口

    千次阅读 2019-06-08 17:57:58
    接口支持多继承,一个接口可以有多个父接口,子接口扩展某个父接口,将会获得父接口里定义的所有抽象方法、常量。 一个接口继承多个父接口时,多个父接口排在extends关键字之后。 2代码 interface interfaceA { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,332,288
精华内容 932,915
关键字:

java接口是

java 订阅