java中什么是接口？接口的作用是什么？_百度知道
该问题可能描述不清，建议你
java中什么是接口？接口的作用是什么？
我有更好的答案
抽象类和接口什么是接口：接口就是一些方法特征的集合------接口是对抽象的抽象。什么是抽象类：抽象类对某具体类型的部分实现------抽象类是对具体的抽象。方法特征包括：方法的名字、参数的数目、参数的类型。不包括：返回类型、参数名字、和抛出的异常。接口是类型转换的前提、是动态调用的保证。实现某一接口就完成了类型的转换（多重继承）；动态调用只关心类型，不关心具体类。
--------------------------------------------------------------------------------------------------------------------------------------
java接口（抽象类）用来声明一个新的类型。Java设计师应当主要使用接口和抽象类将软件单位与内部和外部耦合起来。换言之，应当使用java接口和抽象类而不是具体类进行变量的类型声明、参数的类型声明、方法的返回类型声明、以及数据类型的转换等。当然一个更好的做法是仅仅使用接口，而不是抽象类来做上面这些事情。在理想的情况下，一个具体类应当只实现接口和抽象类中声明的方法，而不应当给出多余的方法！接口和抽象类一般作为一个类型等级结构的起点。接口比抽象类更为抽象所以优先使用接口声明抽象类型！--------------------------------------------------------------------------------------------------------------------------------------抽象类和接口
抽象类仅提供一个类的部分实现。抽象类可以有实例变量、以及一个或多个构造函数。抽象类可以同时又抽象方法和具体方法。
一个抽象类不会有实例，它的构造函数不能被客户端用来创建实例。一个抽象类的构造函数可以被其子类调用，从而使一个抽象类的所有子类可以有一些共同的实现，而不同的子类可以在此基础上有不同的实现。 接口比抽象类更为抽象所以有线使用接口声明抽象类！抽象类是用来继承的。（具体类不是用来继承的，“只要有可能不要从具体类继承---scott meryes”）。抽象类设计原则：1.
抽象类应当拥有尽可能多的代码！（公用方法）。代码集中于抽象的方向。2.
抽象类应当拥有尽可能少的数据！（公共属性）。数据集中于具体的方向。继承复用的使用条件------- Peter Coad条件1.
子类是超类的一个特殊种类而不是超类的一个角色！正确区分“Has-A”“Is-A”的关系。2.
子类之间不应发生替换！？3.
子类具有扩展超类的责任，而不是置换（Override）掉或注销（Nullify）掉的责任。4.
只有在分类学角度上有意义时才可以使用继承，不要从具体类继承。接口和抽象类的区别：
抽象类可以提供某些方法的实现。如果向抽象类中加入一个新的具体的方法，那么所有的子类一下子就得到了这个方法。接口做不到这一点！（这也许是抽象类的唯一优点）。2.
因java的单根结构限制，只类只能实现一个抽象类类型，而接口类型这无此限制。这使抽象类作为类型定义工具的效能落后于接口。接口是定义混合类型（实现多从继承）的理想工具：用一个3.
从代码重构的角度上讲，将一个具体类重构成一个接口的实现是很容易的。研究好这中间的差别很有用的!
采纳率：62%
定义了一些没有实现的方法的类
别的类实现这个接口
也就是要实现这个接口里边的所有的方法
下面这个例子很形象，可以分析下比如说你今年放假出去杭州旅游，玩了一上午，你也有点饿了，突然看到前面有个店子，上面挂着KFC，然后你就知道今天中饭有着落了。KFC就是接口，我们看到了这个接口，就知道这个店会卖炸鸡腿（实现接口）。那么为神马我们要去定义一个接口涅，这个店可以直接卖炸鸡腿啊（直接写实现方法），是的，这个店可以直接卖炸鸡腿，但没有挂KFC的招牌，我们就不能直接简单粗暴的冲进去叫服务员给两个炸鸡腿了。要么，我们就要进去问，你这里卖不卖炸鸡腿啊，卖不卖汉堡啊，卖不卖圣代啊（这就是反射）。很显然，这样一家家的问实在是非常麻烦（反射性能很差）。要么，我们就要记住，中山路108号卖炸鸡，黄山路45号卖炸鸡（硬编码），很显然这样我们要记住的很多很多东西（代码量剧增），而且，如果有新的店卖炸鸡腿，我们也不可能知道（不利于扩展）。链接：
为您推荐：
其他类似问题
您可能关注的内容
java的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。http://m.wsq.qq.com/
在java中接口到底是什么？如何才能用？
//接口说明了“做什么”，而实现这个接口的类，也就是实现类需要说明“怎么做”。
我们来看一个类
public int getA() {
这个类的属性是私有的，外界不能访问，而外界可以通过公有方法来访问这个类。我们说一个类的公有方法就是这个类的对外接口。通常
一个类的属性都是私有的，方法大多是公有的。外界只能过个这些公有方法来访问类。这也是Java封装性的体现。如果一个类没有公有属性，
也没有公有方法，这个类就是无法使用的类了。所以我们需要为一个类提供对外接口。
一个类中的方法，不只是说明了它要“做什么”，而且方法的内容也说明了“怎么做”。打个不太恰当的例子，一个杀人方法。从名字上
看，你知道了“做什么”，但没有办法看到“怎么做”。而方法的内容说明了“怎么做”。
class killer {
public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
这个类的kill方法内容说明了杀人的过程。如果你不想用这种方式杀人。因为你很BT，你想用毒药杀人。那么这个类的内容就需要改。但
是，还有很多其它的“客户”，需要用不同的方式杀人。怎么办呢？一个很好的办法就是，我们只定义“做什么”，而不定义“怎么做”。
interface Killer {
public void kill(Person p);
接口说明了“做什么”，而实现这个接口的类，也就是实现类需要说明“怎么做”。
class Killer1 implements Killer {
public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
class Killer2 implements Killer {
public void kill(Person p) {
Bane bane = new Bane();
p.eat(bane);
public class Test {
public static void main(String[] args) {
Killer jingKe = new Killer1();
Person yingZheng = new Person();
jingKe.kill(yingZheng);
接口可以把“做什么”和“怎么做”分离开来。这给Java带来了很多好处。虽然代码量增加了，可我们的程序的可维护性加强了。我们的程序是可以拆分的。就象电脑一样，可以拆分成很多组件。我一直在想，如果我的MP3耳机可以拆分就好了，那样在耳机只坏掉一个的时候就不用重新买一个了。
不过上面的例子看不到什么太大的好处。你可能会说，如果你
的目的是为了不修改代码，那么，如果我想使用Killer2来完成任务，还是需要修改main方法为：Killer jingKe = new Killer2();。没有错，
不过你可以通过一个工厂来完成上面的任务。也就是说，不通过new语句来获得Killer对象，而是通过工厂来获得Killer对象。
public class KillerFactory {
public static killer getKiller() {
return new Killer1();
public static Killer getKiller(String path) throws Exception {
Properties prop = new Properties();
prop.load(new FileInputStream(path));
String className = prop.getProperty("killer");
Class clazz = Class.forName(className);
return (Killer)clazz.newInstance();
代码确实增加了很多，可是这对后期的系统维修和系统升级带来了很多好处。
水龙头与出水管的关系，我们需要把水龙头安装到出水管上。如果有一天我们需要更换水龙头时，只需要把老的水龙头拆卸下来，把新的
水龙头安装到出水管上既可。如果水龙头与出水管是一体的，就是无法拆卸的怎么办呢？或是说出水管只能安装水龙头，而不能安装淋浴器，
这就使我们生活很不方便。我们可以理解为出水管的连接方法，连接的对象是“出水设备”，而这个“出水设备”是一个接口。而水龙头与淋
浴器都是这个接口的实现类。但是接口在哪里呢？它长什么样子？我们没看到。它是一个标准，连接处的内径与外径。螺丝抠的密度等。这就
和你的电脑上为什么可以连接USB设备一样。如果电脑和某一个USB设备电焊到一起，那么其它的USB设备就无法使用了。电脑使用的是实现了
USB接口的电子设备，而我们的U盘、MP3、移动硬盘及鼠标都是USB接口的实现类。
用Java写出来的程序也和我们现实生活中的设备一样。如电脑，我们希望电脑的所有部件都可以更换，如果主板上的内存插槽与内存条不
附。我们说，内存条没有实现某某接口。Java是完全面向对象的，而面向对象是我们最为熟悉的东东。面向对象并不简单，而是我们太熟悉它
了。所以我们学习Java会很方便。在现实社会中，所有的标准到了Java中都是接口。一盒香烟多少支烟，烟的长度等都是标准。一个光盘的大
小。Java中的JDBC就是一个标准，而各大数据库厂商及第三方厂商实现了这一标准。JDBC只说明了目的，没有说明怎么完成的目的。
面向对象就在我们眼前，不过我们有时不太注意它。希望你在今后学习Java时，多与现实社会联系。这样可以有利与你的理解。
代码量加大了，但对后期的维护与升级提供了方便。软件公司卖给客户的是class文件，而不是java文件。如果你的客户需要更换Killer对
象，只需修改资源文件既可。
下面我们来看一个定时器类。现在什么都是自动化的，如空调、电视、洗衣机等等。都要用到定时器这个类。对了，还有定时炸弹也要用
它。那我们可不可以只写一个定时器类，应用到所有的需要定时器的设备上呢？答案是肯定的，我们需要这个类。
好了，我们来分析一下定时器需要完成什么工作吧。定时器应该有启动、停止方法。定时器启动之后，每过一定时间就执行某个动作。其
中时间间隔为long型，而要执行的动作可能是输出一个字符串，也可能是打印作业。具体要干什么由使用定时器的用户来完成。而定义定时器
时，根本就不知道要干什么。
public class Timmer {
public Timmer() {}
public Timmer(long time, Action action) {
this.time =
this.action =
public void start() {
state = START;
if(th == null) {
th = new Thread() {
public void run() {
while(state == START) {
Thread.sleep(time);
action.action();
} catch(Exception e) {
th.start();
public void stop() {
state = STOP;
public void setTime(long time) {
this.time =
public void setAction(Action action) {
this.action =
public long getTime() {
return (this.time);
public Action getAction() {
return (this.action);
Action是一个接口，它只有一个方法，就是要完成的任务。我们在定时器启动时调用这个接口的方法。而这个Action接口的对象，代表一
个动作，这个动作就是用户要完成的动作。
public interface Action {
public void action();
public static void main(String[] args) {
Timer t = new Timer(2000, new Action() {
public void action() {
System.out.println("Hello World!");
t.start();
javax.swing.JOptionPane.showMessageDialog(null, "点击确定按钮停止定时器");
System.exit(0);
这是一个典型的回调方法例子。在AWT中，java使用了大量的监听器。这些监听器都是回调方法。在XML解析器SAX中，也使用了回调方法来解析XML文档。
接口要比抽象类还要抽象。抽象类需要子类继承，而Java是单继承，所以抽象类被限制了。而接口不同，一个类可以实现多个接口。好比人类与程序员类之间的关系。可以说程序员是人类的子类，如果程序员是一个接口。用人类的子类来实现它就会更好。这个子类还可以去实现会计接口、音乐家接口等等。
在struts2.0、spring、hibernate等框架中，都大量使用接口。我们关心的是某个接口与另一个接口之间的关系。而不关心某个实现类与另一个接口实现类的关系。在客观世界中，我们交谈时都大量使用接口，只是我们没有注意罢了。
如：我公司需要一个程序员(一个实现了程序员接口的对象)。上课时，讲师有一台计算机，用白板笔在白板上写字(计算机是接口，白板及白板笔也是接口)。讲师希望学生能学会所有的知识(讲师及学生都是接口)。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！【JAVA】接口
先问一个问题，为什么需要接口？
需求：要求实现防盗门的功能。门有&开&和&关&的功能，所有&上锁&和&开锁&的功能。
分析：首先防盗门是一扇门，它有一把锁。按照面向对象的思想，可以将门分别定义成抽象类。但是，不能让防盗门在继承门的同时又继承锁。原因有两点：1、防盗门不是锁，不符合 is a的关系；2、只支持单继承。那么如何解决这个问题呢？这时就要用到接口，可以将锁定义为接口，让防盗门继承门，实现锁的接口。
那么什么是接口？它的特点又是什么？我们一步一步学习
在生活中，接口是一套规范，满足这个规范的设备，就可以将它们组合到一起，从而实现该设备的功能。现在以USB接口为例，来学习接口的含义。USB接口实际上是某些企业和组织等制定的一种约定或标准，规定了接口的大小、形状、各引脚信号的范围和含义、通信速度、通信流程等，并按照该约定或标准来设计各种设备，如U盘、USB风扇、USB键盘都可以插到USB口上正常工作。
在软件中，接口同样是一种规范和标准，它们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现。从这个角度来讲，接口可以看作是一种特殊的&抽象类&，但是采用与抽象类完全不同的语法来表示，两者的设计理念也是不同的，抽象类利于代码复用，接口利于代码的扩展和维护。
接口语法：
//定义接口的语法：
[修饰符] interface 接口名 extends 父接口1、父接口2，&&{
//常量定义
//方法定义
//接口同样可以继承接口
//类实现接口的语法：
class 类名 extends 父类名 inplements 接口1,接口2&&{
//一个类可以继承多个接口
接口的特点：
1、 接口的命名规则与类相同。如果修饰符是public，则该接口在整个项目中可见，如果省略修饰符，则该接口只在当前包可见。
2、接口中可以东一常量，不能定义变量。接口中的属性都会自动用public static final 修饰，即接口中的属性都是全局静态常量。接口中的常量必须在定义时指定初始值。
public static final int PI = 3.14;
int PI = 3.14;//在接口中，这两个定义语句效果完全相同
int PI;//错误！在接口中必须指定初始值，在类中会有默认值
3、接口中所有方法都是抽象类。接口中方法都会自动用public abstract修饰，即接口中只有全局抽象方法。
4、和抽象类一样，接口也不能实例化，接口中不能有构造函数。
5、接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。
6、接口的实现类必须实现接口的全部方法，否则必须定义为抽象类。
了解了什么是接口以及接口的特点，这里我们还要明白一个概念：接口是一种能力
通过之前所说的防盗门案例，我们来详细说明：
防盗门是一个门，符合is a 的关系，可以抽象出一个门类。防盗门有一把锁，代表它有&上锁&和&开锁&的能力，表达的是has a（组合关系）的关系，这里可以将锁定义成接口，让防盗门继承门类实现锁接口。
具体步骤：
定义抽象类Door，具备开和关的功能。 定义Lock接口，具备&上锁&和&开锁&的能力。 定义TheftproofDoor类，继承Door类的同时实现Lock接口。 编写测试类，实现防盗门的开、关和上锁、开锁的功能。
//定义抽象类、门类
public abstract class Dooe{
public abstract void open();//开门
public abstract void close();//关门
//定义锁接口
public interface Lock{
void lockUp();//上锁
void openLock();//开锁
//定义防盗门类、继承Door类，实现Lock接口
public TheftproofDoor extends Door implements Lock{
public void lockUp(){
System.out.println(&向右转一圈，开锁&);
public void openLock(){
System.out.println(&向左转一圈，上锁&);
public void open(){
System.out.println(&轻轻一推，开门&);
public void close(){
System.out.println(&轻轻一拉，关门&);
public statci void main(String[] args){
//创建防盗门对象
TheftproofDoor tfd = new TheftproofDoor();
tfd.close();//关门
tfd.lockUp();//上锁
tfd.openDoor();//开锁
tfd.open();//开门
轻轻一拉，关门
向左转一圈，上锁
向右转一圈，开锁
轻轻一推，开门
通过示例，我们可以更加清晰的理解为什么接口是一种能力。一个类实现了某个接口，那么就表示这个类具备了某种能力，防盗门实现的锁的接口，就表示防盗门有了上锁开锁的能力。生活中还有许多这样的案例，如钳工、木匠并不是指某个人，而代表一种能力，招聘钳工、木匠就是招聘具备该能力的人。所以生活中一个人可以具备多项能力，程序的一个类也可以实现多个接口。
接口表示一种约定
问题：要求实现打印机打印功能。打印机的墨盒可能是彩色的，也可能是黑白的，所用的纸张可以有多种类型，如A4、B5等，并且墨盒和纸张都不是打印机厂商提供的，打印机产商如何避免自己的打印机与市场上的墨盒、纸张不符呢？
分析：有效解决该问题的途径是指定墨盒、纸张的约定或标准，然后打印机厂商按照约定对墨盒、纸张提供支持，无论最后使用的是哪个厂商提供的墨盒或纸张，只要符合统一的约定，打印机都可以打印。Java中的接口表示一种约定。
通过Java实现打印机打印的具体步骤：
定义墨盒接口InkBox，约定墨盒的标准。 定义纸张接口Paper，约定纸张的标准。 定义打印机类，引用墨盒接口、纸张接口实现打印功能。 墨盒厂商按照InkBox接口实现ColorInkBox类和GrayInkBox类。 纸张厂商按照Paper接口实现A4Paper类和B5Paper类。 &组装&打印机，让打印机通过不同的墨盒和纸张实现打印功能。
//定义墨盒接口
public interface InkBox{
//return 墨盒颜色
public String getColor();
//定义纸张接口
public interface Paper{
//return 纸张大小
public String size();
//定义打印机类
public class Printer{
InkBox inkB //墨盒
//设置打印机墨盒
public void setInkBox(InkBox inkBox){
this.InkBox = inkB
//设置打印机纸张
public void setPaper(Paper paper){
this.paper =
//使用墨盒在纸上打印
public void print(){
System.out.println(&使用&+inkBox.getColor()+&墨盒在&+paper.getSize()+&纸上打印。&);
//墨盒厂商按照InkBox接口实现ColorInkBox类和GrayInkBox类
//彩色墨盒类
public class ColorInkBox implements InkBox{
public String getColor(){
return &彩色&;
//黑白墨盒类
public class GrayInkBox implements InkBox{
public String getColor(){
return &黑白&;
//纸张厂商按照Paper接口实现A4Paper类和B5Paper类
public class A4Paper implements Paper{
public String getSize(){
return &A4&;
public class B5Paper implements Paper{
public String getSize(){
return &B5&;
//&组装&打印机，让打印机通过不同的墨盒和纸张实现打印功能。(测试类)
public static void main(String[] args){
//1、定义打印机
InkBox inkBox =//定义墨盒引用
Paper paper =
//定义纸张引用
Printer printer = new Printer();//定义打印机引用并指向打印机对象
//2、使用黑白墨盒在A4纸上打印
inkBox = new GrayInkBox();//指向黑白墨盒类对象
paper = new A4Paper();//指向A4纸类对象
printer.setColor(inkBox);//对墨盒进行赋值
printer.setSize(paper);//对纸张进行赋值
printer.print();//调用打印方法
//3、使用彩色墨盒在B5纸上打印
inkBox = new ColorInkBox();
paper = new B5Paper();
printer.setColor(inkBox);//对墨盒进行赋值
printer.setSize(paper);//对纸张进行赋值
printer.print();//调用打印方法
//4、使用彩色墨盒在A4纸上打印
paper = new A4Paper();
printer.setSize(paper);
printer.print();//调用打印方法
使用黑白墨盒在A4纸上打印
使用彩色墨盒在B5纸上打印
使用彩色墨盒在A4纸上打印
在以上的例子中，我们首先定义了墨盒接口、纸张接口，然后定义打印机类，将两个接口作为类的成员属性，并且定义了两个方法，以接口作为形参，对当前对象的属性进行赋值。
然后根据接口，分类定义了相应的类，并且实现了接口，实现了接口当中的所有方法，通过方法返回相应的约定参数。
在测试类中，首先定义了接口的引用以及打印机的引用并且指向打印机的对象，根据实际需求，通过接口的引用指向相应的对象。
通过打印机当中的获取墨盒以及纸张的方法，传递实现了接口的子类的实参，对打印机中的成员属性进行赋值，然后输出结果。
在面向对象中提倡面向接口编程，而不是面向实现编程。什么是面向接口编程？简单来说，如果打印机厂商只面向某一家或几家厂商的墨盒产品规格生产打印机，而没有一个统一的约定，就无法使用更多厂商的墨盒。如果这家墨盒厂倒闭了，那么打印机就无用武之地了。而如果按照统一的约定生产打印机和墨盒，就不会存在这个问题。
针对本示例，在打印机类当中，Printer类的两个属性使用了InkBox接口和Paper接口，就可以接受所有实现了这两个接口的类的对象，即使是新推出的墨盒类型，只要遵循该接口的约定，就能够被接收。如果采用面向实现编程，则两个属性类型使用GrayInkBox和B5Paper，大大限制了打印机的适用范围，无法对新推出的ColorInkBox提供支持，这也体现了多态的可扩展、可维护的特性。
接口体现了约定和实现相分离的原则，通过面向接口编程，可以降低代码间的耦合性，提高代码的可扩展性和可维护性。面向接口编程就意味着：开发时，主体架构使用接口，接口构成系统的骨架，这样就可以通过更换实现接口的类来实现更换系统。java中的interface接口实例详解
转载 &更新时间：日 11:55:55 & 作者：Engineer-MrYang
这篇文章主要介绍了 java中的interface接口实例详解的相关资料,需要的朋友可以参考下
&java中的interface接口实例详解
接口：Java接口是一些方法表征的集合，但是却不会在接口里实现具体的方法。
java接口的特点如下：
1、java接口不能被实例化
2、java接口中声明的成员自动被设置为public，所以不存在private成员
3、java接口中不能出现方法的具体实现。
4、实现某个接口就必须要实现里面定义的所有方法。
接下来看一个实现接口的案例:
interface competer{
//定义接口
void set_compt(int com);
void print_compt_information();
class bj implements competer{ //接口实现
public void set_compt(int com)
this.com =
// System.out.println("端口" + com);
public void print_compt_information()
System.out.println("端口" + com);
System.out.println("笔记本");
class taishi implements competer{
public void set_compt(int com)
this.com =
//System.out.println("端口" + com);
public void print_compt_information()
System.out.println("端口" + com);
System.out.println("台式机");
public class inter {
public static void main(String[] args)
taishi com = new taishi();
bj bjj = new bj();
com.set_compt(100);
bjj.set_compt(120);
com.print_compt_information();
bjj.print_compt_information();
运行结果：
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具JAVA中接口的作用_百度文库
您的浏览器Javascript被禁用，需开启后体验完整功能，
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
JAVA中接口的作用
阅读已结束，下载本文需要
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩1页未读，
定制HR最喜欢的简历
你可能喜欢