在java中，啥是接口，接口的特点是啥

Posted 2023-04-25

Java接口（Interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

　　一.接口含义：

　　1.Java接口，Java语言中存在的结构，有特定的语法和结构；2.一个类所具有的方法的特征集合，是一种逻辑上的抽象。

　　前者叫做“Java接口”，后者叫做“接口”。

　　Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。

　　Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public，静态的和final属性。

　　二.为何用接口Java是一种单继承的语言，若要给已有父类的具体类增加新功能，在OCP原则下,解决是给它的父类加父类，或者给它父类的父类加父类，直到移动到类等级结构的最顶端。这样一来，对一个具体类的可插入性的设计，就变成了对整个等级结构中所有类的修改。

　　当有了接口,以上例子中,就不需要维护整个等级结构中的所有类了.

　　三.接口具胡可插入性:

　　在一个等级结构中的任何一个类都可以实现一个接口，这个接口会影响到此类的所有子类，但不会影响到此类的任何超类。此类将不得不实现这个接口所规定的方法，而其子类可以从此类自动继承这些方法，当然也可以选择置换掉所有的这些方法，或者其中的某一些方法，这时候，这些子类具有了可插入性(并且可以用这个接口类型装载，传递实现了他的所有子类)。

　　接口提供了关联以及方法调用上的可插入性，软件系统的规模越大，生命周期越长，接口使得软件系统的灵活性和可扩展性，可插入性方面得到保证。

　　正是有了接口,使得Java单继承性有了新的扩展的可能(变向地实现多继承);三.类型等级结构Java接口(以及抽象类)一般用来作为一个类型的等级结构的起点。

　　如果一个类已经有了一个主要的超类型，那么通过实现一个接口，这个类可以拥有另一个次要的超类型，这种次要的超类型叫做混合类型。

　　四.Java接口分类
　　
　　1、普通接口(含有方法定义)public interface ActionListenerpublic abstract void actionPerformed(ActionEvent event);

　　2、标识接口(无任何方法和属性定义)标识接口是没有任何方法和属性的接口.标识接口不对实现它的类有任何语义上的要求，它仅仅表明实现它的类属于一个特定的类型。

　　public interface Serializable;
　　
　　3、常量接口是指用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量。

　　public interface AppConstantspublic static final DATA_SOURCE_NAME="test";public static final USER_NAME="test";public static final PASSWORD="test";

　　五.接口的特点
　　
　　1、Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用"_"分隔)
　　
　　2、Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化
　　
　　3、Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法
　　
　　4、接口中没有构造方法,不能被实例化5、一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
　　
　　6、Java接口必须通过类来实现它的抽象方法
　　
　　7、当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类
　　
　　8、不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例
　　
　　9、一个类只能继承一个直接的父类,但可以实现多个接口,间接的实现了多继承.

　　六.Java接口和Java抽象类区别面向对象设计的重点在于抽象。抽象类与接口都位于继承树的上层。

　　相同点：

　　1、代表系统的抽象层,当一个系统使用一颗继承树上的类时,应该尽量把引用变量声明为继承树的上层抽象类型,这样可以提高两个系统之间的送耦合
　　
　　2、都不能被实例化
　　
　　3、都包含抽象方法,这些抽象方法用于描述系统能提供哪些服务,但不包含方法体不同点：

　　1、最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以；这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。

　　可以向抽象类里加入一个新的具体方法，所有的子类都自动得到这个方法；但Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译，必需手动给每个实现了该接口的类加上该方法的实现；
　　
　　2、抽象类的实现只能由子类给出，也即该实现只能在抽象类定义的继承的等级结构中；所以抽象类作为类型定义工具的效能大打折扣。

　　Java接口，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。

　　以上看出：Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。

　　3、结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：

　　声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。

　　在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。

　　七.使用接口和抽象类的总体原则:

　　1、用接口作为系统与外界交互的窗口站在外界使用者(另一个系统)的角度,接口向使用者承诺系统能提供哪些服务,站在系统本身的角度,接口制定系统必须实现哪些服务,接口是系统中最高层次的抽象类型.通过接口交互可以提高两个系统之间的送耦合系统A通过系统B进行交互,是指系统A访问系统B时,把引用变量声明为系统B中的接口类型,该引用变量引用系统B中接口的实现类的实例。

　　public interface B      

　　public class C implements B      

　　public class A     B a = new C();  

　　2、Java接口本身必须非常稳定,Java接口一旦制定,就不允许随遇更加,否则对外面使用者及系统本身造成影响3、用抽象类来定制系统中的扩展点，抽象类来完成部分实现,还要一些功能通过它的子类来实现

参考技术A

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口作用如下：

1、丰富Java面向对象的思想：在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。

2、提供简单、规范性：如果一个项目比较庞大，那么就需要一个能理清所有业务的架构师来定义一些主要的接口，这些接口不仅告诉开发人员你需要实现那些业务，而且也将命名规范限制住了（防止一些开发人员随便命名导致别的程序员无法看明白）。

3、提高维护、拓展性：比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类，可是在不久将来，你突然发现这个类满足不了你了，然后你又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦，如果你一开始定义一个接口，把绘制功能放在接口里，然后定义类时实现这个接口，然后你只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。

4、增强安全、严密性：接口是实现软件松耦合的重要手段，它描叙了系统对外的所有服务，而不涉及任何具体的实现细节。这样就比较安全、严密一些(一般软件服务商考虑的比较多)。

扩展资料：

关于接口的使用规范：

1、接口中可以定义常量，不能定义变量，如果你在接口中定义属性，那么通过反编译可以看见他会自动用public static final 修饰，接口中的属性都是全局静态常量，接口中的常量必须在定义时指定初始值。

2、 接口中所有的方法都是抽象方法，接口中方法都会自动用public abstract 修饰，即接口中只有全局抽象方法。

3、 接口不能实例化，接口中不能有构造。

4、 接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。

5、 接口的实现类必须实现接口的全部方法，否则必须定义为抽象类。

参考资料：百度百科-Java接口

参考技术B

java接口：

1、Java语言中存在的结构，有特定的语法和结构。

2、Java语言中一个类所具有的方法的特征集合，是一种逻辑上的抽象。

java接口作用：

1、利于代码的规范

这样做的目的一方面是为了给开发人员一个清晰的指示，告诉他们哪些业务需要实现；同时也能防止由于开发人员随意命名而导致的命名不清晰和代码混乱，影响开发效率。

2、有利于对代码进行维护

可以一开始定义一个接口，把功能菜单放在接口里，然后定义类时实现这个接口，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。

3、保证代码的安全和严密

一个好的程序一定符合高内聚低耦合的特征，能够让系统的功能较好地实现，而不涉及任何具体的实现细节。这样就比较安全、严密一些，这一思想一般在软件开发中较为常见。

扩展资料：

关于java接口的使用规范：

1、接口中可以定义常量，不能定义变量，接口中的属性都是全局静态常量，接口中的常量必须在定义时指定初始值。

2、 接口中所有的方法都是抽象方法，接口中方法都会自动用public abstract 修饰，即接口中只有全局抽象方法。

3、 接口不能实例化，接口中不能有构造。

4、 接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。

5、 接口的实现类必须实现接口的全部方法，否则必须定义为抽象类。

参考资料来源：百度百科：java接口

参考技术C 接口一般来说有两种，一种是程序内部的接口，一种是系统对外的接口。
系统对外的接口：比如你要从别的网站或服务器上获取资源或信息，别人肯定不会把数据库共享给你，他只能给你提供一个他们写好的方法来获取数据，你引用他提供的接口就能使用他写好的方法，从而达到数据共享的目的，比如说咱们用的app、网址这些它在进行数据处理的时候都是通过接口来进行调用的。
程序内部的接口：方法与方法之间，模块与模块之间的交互，程序内部抛出的接口，比如bbs系统，有登录模块、发帖模块等等，那你要发帖就必须先登录，要发帖就得登录，那么这两个模块就得有交互，它就会抛出一个接口，供内部系统进行调用。 参考技术D 接口的作用:
接口的用途不但多，而且是非常必要。这就是为什么我们为什么老是提“面向接口编程”的概念。
你现在对其理解不深没有关系，只是在实际中先用。等积累到一定程度就知道接口的好处了。

就拿你上面的例子说接口的用途之一，那就是“多态”。这个词你应该不陌生吧，相信老师应该和你们说过吧
VideoCard vc=new Elsa();
//VideoCard vc=new Colourful();
vc.display();
这里vc 可以new Elsa(); 可以new Colourful(); 可以实现不同的功能。换句话说一会可以拿它当锤子使用，一会
拿他当电锯使用，前提是他们实现了同样的接口。只要你接口的方法定义没有变，针对外部而言 ，你的具体实现外部是不
感知的。所以，这就为你以后程序的扩展性提供基础。“对修改封闭，对扩展开发”。

前面是接口的一个基本用途，规定子类的行为。更为广阔的用途是接口为其他人使用者提供什么用途。模块和模块之间的解耦
就看你的接口设计的是不是合理，是不是好用。这就是框架设计师。

为什么要用接口 :用于处理多变的情况。
接口在实际开发过程中最大好处是，你可以按照设计，先把接口写好，然后分配大伙干活的时候，告诉a们去用写好的接口去实现他们的具体功能，而告诉b们，去写那些已经写好但是没有具体的代码的接口，这样可以提高工作效率。并且底层和应用也通过接口做了一个很明显的分层。

Java中接口的特点

Java接口在1.8之后发生了重大变化。所以谈Java接口特点可以分为1.8版本之前和1.8版本之后。

1.8版本之前的特点:

• 接口里只能有静态全局常量和public修饰的抽象方法。
• 为了代码简洁，在接口中方法可以不用public和abstract修饰，但是编译后的方法仍然是public abstract类型的方法。全局常量也可以用public static fianl修饰，同样编译后仍然为public static final类型。

下面代码演示了一个如何定义一个1.8版本之前的接口:

public interface IFlyable
{
    String info = "静态常量";
    void fly(); 
} 

上面代码尽管没有用public static final修饰info，但编译后info为静态全局常量，外部不能修改值。同样fly()没有用public abstract修饰，但编译结果是public abstract类型。

下面是测试代码:

 1 package org.lyk.vo;
 2 
 3 import org.lyk.intefaces.*;
 4 
 5 public class Bird implements IFlyable
 6 {
 7     public void fly()
 8     {
 9         System.out.println("鸟儿在飞翔");
10     }  
11 }

 1 package org.lyk.main;
 2 
 3 import org.lyk.intefaces.*;
 4 import org.lyk.vo.*;
 5 
 6 public class Hello
 7 {
 8     public static void main(String[] args)
 9     {
10         IFlyable flyAble = new Bird();
11         flyAble.fly();  
12         System.out.println(IFlyable.info); 
13     }
14 } 

 

1.8 版本之后的特点：

• 打破了1.8之前接口里只能有全局静态常量和public抽象方法的限制。允许接口中用default关键字修饰的实体方法出现（该方法在子类中可以被覆写）
• 也允许在接口中定义public static 类型的实体函数，该静态由接口调用。

 1 package org.lyk.intefaces;
 2 
 3 public interface IFlyable
 4 {
 5     public static final String info = "静态常量";
 6     public abstract void fly(); 
 7     
 8     public static void showSomething()
 9     {
10         System.out.println("这是Java1.8才支持的静态函数，该函数只能由接口调用");
11     }
12     
13     default void printSomething()
14     {
15         System.out.println("这是Java1.8才支持的default实体函数.该方法可以在子类中被覆写。");
16     }
17 } 

测试代码:

 1 package org.lyk.vo;
 2 
 3 import org.lyk.intefaces.*;
 4 
 5 public class Bird implements IFlyable
 6 {
 7     public void fly()
 8     {
 9         System.out.println("鸟儿在飞翔");
10     } 
11     
12     public  void printSomething()
13     {
14         System.out.println("在子类中覆写接口方法");
15     }
16 }

 1 package org.lyk.main;
 2 
 3 import org.lyk.intefaces.*;
 4 import org.lyk.vo.*;
 5 
 6 public class Hello
 7 {
 8     public static void main(String[] args)
 9     {
10         IFlyable flyAble = new Bird();
11         flyAble.fly();  
12         System.out.println(IFlyable.info);
13         
14         
15         flyAble.printSomething();
16         IFlyable.showSomething();
17     }
18 } 

 

后记: 我想，Java1.8之所以做出如此大的设计上的改变，应该是为了向.net学习，目的是支持流(stream)。因为Java一开始设计的时候没有考虑到stream这种场景出现，现在要在接口中增加功能，就必须打破原有限制。