java中，一个类实现某个接口，必须重写接口中的所有方法吗？？？
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java中，一个类实现某个接口，必须重写接口中的所有方法吗？？？相关的知识，希望对你有一定的参考价值。
在java API文档中，javax.swing.AbstractListModel实现了listModel接口，但它的方法摘要里只有ListModel接口方法中的两个，另外继承了ListModel中的getsize()和getElementAt(int index)？？？不明白。
class MyComboBox extends AbstractListModel implements ComboBoxModel
String selecteditem = null;
String[] test = "身份证", "军人证", "学生证", "工作证" ;
public Object getElementAt(int index)
return test[index];
public int getSize()
return test.length;
public void setSelectedItem(Object item)
selecteditem = (String) item;
public Object getSelectedItem()
return selecteditem;
public int getIndex()
for (int i = 0; i < test.length; i++)
if (test[i].equals(getSelectedItem()))
return i;
break;
return 0;
如果子类是非抽象类，则必须实现接口中的所有方法；
如果子类是抽象类，则可以不实现接口中的所有方法，因为抽象类中允许有抽象方法的存在！
1、抽象类定义
抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。通常在编程语句中用 abstract 修饰的类是抽象类。在C++中，含有纯虚拟函数的类称为抽象类，它不能生成对象；在java中，含有抽象方法的类称为抽象类，同样不能生成对象。抽象类是不完整的，它只能用作基类。在面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。
2、抽象类特点
1）抽象类不能实例化。
2）抽象类可以包含抽象方法和抽象访问器。
3）不能用 sealed 修饰符修饰抽象类，因为这两个修饰符的含义是相反的。 采用 sealed 修饰符的类无法继承，而 abstract 修饰符要求对类进行继承。
4）从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。
3、与具体类的比较
1）抽象类不能直接实例化，并且对抽象类使用 new 运算符会导致编译时错误。虽然一些变量和值在编译时的类型可以是抽象的，但是这样的变量和值必须或者为 null，或者含有对非抽象类的实例的引用（此非抽象类是从抽象类派生的）。
2）允许（但不要求）抽象类包含抽象成员。
3）抽象类不能被密封。
4、与接口的比较
1）相同点
a、不能实例化；
b、包含未实现的方法声明；
c、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）
2）不同点
a、类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。
b、抽象类当中可以存在非抽象的方法，可接口不能，且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
c、抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。
d、抽象类是对象的抽象，然而接口是一种行为规范。 参考技术A 楼主，先声明一点，javax.swing基本是过时的，属于前台的工作，现在前台基本都是定制的，JAVA编程只要关注后台就可以，不过你问的接口问题倒是很重要的，给你解释以下，java中类和接口的设计完全体现了java语言的一些设计思想，比如面向对象，继承、多态等
1 接口的设计解决了java只能单继承的缺点，可以实现多个接口来实现java的多继承
2 实现某个接口必须覆写其中的所有方法，当然也可以是一个空的实现（方法体为空没有任何作用）
3 楼主也许会问了空实现有什么用呢，这就是java的特殊设计，通常的是接口在最上面，下面会有一个这个接口的实现类，有时候这个实现类也是一个空的实现，没有任何方作用！！！编程人员只需要实现那个空的方法，覆写其中自己需要方法的就可以了~~
为什么要这样做呢？原因就是接口是一个抽象的概念，与具体的底层、实现都无关，打个比方，现在的网络编程都是与HTTP协议相关的，如果将来有新的协议出现就只要实现这个接口就可以了，完全不用做任何修改就可以把新的协议容纳进来
总结一下，接口就是一个物体的抽象，规定了这个物体所有的行为方法，与具体的实现无关，这正体现了抽象的概念~~ 参考技术B 哈哈，这是API文档的问题，你没看过Java源码，源码中实现的方法比这多，只是API没写全。要学会看源码！！！！ 参考技术C 必须地！2楼正解 参考技术D
是的，需要全部实现
接口的特点：
1、用 interface 来定义。
2、接口中的所有成员变量都默认是由public static final修饰的。
3、接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。
4、实现接口的类中必须提供接口中所有方法的具体实现内容。
5、多个无关的类可以实现同一个接口
6、一个类可以实现多个无关的接口
7、与继承关系类似，接口与实现类之间存在多态性
8、接口也可以继承另一个接口，使用extends关键字。
9、下图是我们的教案中的截取
java基础-接口与实现
接口的定义和类的定义很相似，可以分为接口声明和接口体积，和类不同的是，使用关键字interface来声明自己是一个接口。
格式如下;
interface 接口的名字
这里需要注意的是：
1、如果一个非抽象类实现了某个接口，那么这个类必须重写这个接口中的所有方法。
2、如果一个类声明实现一个接口，但是没有重写接口中的从所有方法，那么这个类必须是抽象类，也就是说抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法。
3、程序可以用接口名访问接口中的常量，但是如果一个类实现了接口，那么该类可以直接在类体中使用该接口的常量。
4、在我们定义接口的时候，如果关键字interface 前面加一个public关键字，就成这样的接口是一个public接口，public接口可以被任何一个类实现。如果一个接口不加public修饰。就称作是友好接口，友好接口可以被 与该接口在同一个包中的类实现。
5、如果父类实现了某个接口，那么子类自然也就实现了该接口，子类不必再显式地使用关键字implement声明实现这个接口。
6、接口也可以被继承，即可以通过关键字extends声明一个接口是另外一个接口的子接口。由于接口中的方法和常量都是public的，子接口将继承父接口中的全部方法和常量。
举个例子吧：
在这个例子中China类和Japan类分别继承computable接口。
下面是具体的源代码：
China类
1 package Example14; 2 3 import Example5.ComputerAver; 4 5 public class China exends Computable { 6 int number; 7 public int f(int x) { 8 //public关键字别漏了 9 int sum = 0; 10 for(int i=1; i<= x;i++){ 11 sum+=i; 12 } 13 return sum; 14 } 15 //重写方法f 16 }
Japan类
1 package Example14; 2 3 public class Japan extends Computable { 4 int number; 5 @Override 6 public int f(int x) { 7 return MAX + x; 8 //直接调用接口中的常量 9 } 10 11 }
computable接口
1 package Example14; 2 3 public interface Computable { 4 int MAX = 46; 5 public abstract int f(int x); 6 }
主函数：
1 package Example14; 2 3 public class Demo { 4 5 public static void main(String[] args) { 6 China zhang; 7 Japan henlu; 8 zhang = new China(); 9 henlu = new Japan(); 10 zhang.number = 32 + Computable.MAX; 11 henlu.number = 14 + Computable.MAX; 12 System.out.println("zhang的学号" + zhang.number + " zhang求和结果" + zhang.f(100)); 13 System.out.println("henlu的学号" + henlu.number + " henlu求和结果" + henlu.f(100)); 14 } 15 16 }
运行结果：
zhang的学号78 zhang求和结果5050
henlu的学号60 henlu求和结果146
例子2：
动机类MotorVehicles ：
1 package Example15; 2 3 interface MoneyFare { 4 void charge(); 5 }
空调接口ControlTemperature：
1 package Example15; 2 3 interface ControlTemperature { 4 void controlAirTemperature(); 5 }
Bus类继承了动机类并且实现了收费接口
1 package Example15; 2 //bus实现MoneyFare 3 //一个接口 4 5 public class Bus extends MotorVehicles implements MoneyFare{ 6 7 void brake(){ 8 System.out.println("公共汽车使用毂式刹车"); 9 }//重写 10 11 public void charge() { 12 System.out.println("公共汽车：一元/张，不计算公里数"); 13 } 14 15 16 }
Taxi类继承了动机类并且实现了空调和收费接口
1 package Example15; 2 3 public class Taxi extends MotorVehicles implements MoneyFare ,ControlTemperature { 4 5 6 public void charge() { 7 System.out.println("出租车：2元/公里，起价3公里"); 8 } 9 10 11 void brake() { 12 System.out.println("出租车使用盘式刹车技术："); 13 } 14 15 16 public void controlAirTemperature() { 17 System.out.println("出租车安装了Hair空调"); 18 } 19 20 }
Cinrma 实现了空调和收费接口
1 package Example15; 2 3 public class Cinrma implements MoneyFare, ControlTemperature { 4 5 @Override 6 public void controlAirTemperature() { 7 System.out.println("电影院安装了中央空调"); 8 } 9 10 @Override 11 public void charge() { 12 System.out.println("电影院：门票,10/张"); 13 } 14 15 }
主函数调用
1 package Example15; 2 3 public class Demo { 4 5 public static void main(String[] args) { 6 Bus bus = new Bus(); 7 Taxi taxi = new Taxi(); 8 Cinrma cinrma = new Cinrma(); 9 bus.brake(); 10 bus.charge(); 11 taxi.charge(); 12 taxi.brake(); 13 taxi.controlAirTemperature(); 14 cinrma.charge(); 15 cinrma.controlAirTemperature(); 16 } 17 18 }
调试结果：
公共汽车使用毂式刹车 公共汽车：一元/张，不计算公里数 出租车：2元/公里，起价3公里 出租车使用盘式刹车技术： 出租车安装了Hair空调 电影院：门票,10/张 电影院安装了中央空调
关于接口回调
和类一样，接口也是Java中一种重要的数据类型，用接口声明的变量称作接口变量。
接口属于引用型变量，接口变量中可以存放实现该接口类的实例应引用，即存放对象的引用。
“接口回调”这个词是借用了C语言中的指针回调的术语，表示一个变量的地址在某一个时刻放在一个指针变量中，那么指针变量就可以间接操作该变量中存放的数据。
在Java语言中，接口回调是指:可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。事实上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法。
举个例子：假设Com是一个接口，ImpleCom类是实现Com接口的类
Com com; ImpleCom impleCom; com = impleCom;// 这样是合法的。将impleCom 的对象的引用赋值给com接口。
类似上转型对象调用子类重写的方法
下面我们举个例子：
ShowMessage 接口：
package Example16;
public interface ShowMessage {
void 显示商标(String s);
}
PC类实现了ShowMessage接口
package Example16;
public class PC implements ShowMessage {
public void 显示商标(String s) {
System.out.println(s);
}
}
TV类实现了ShowMessage 接口：
package Example16;
public class TV implements ShowMessage {
public void 显示商标(String s) {
System.out.println(s);
}
}
主函数：
package Example16;
public class Demo {
public static void main(String[] args) {
ShowMessage message;
message = new TV();
message.显示商标("长虹牌电视机");
message = new PC();
message.显示商标("华硕A550jk4200");
}
}
调试结果
长虹牌电视机 华硕A550jk4200
关于接口和多态：
接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方法，那么接口变量在回调接口方法是就可能具有多种形态。
下面我们举个例子：
接口ComputerAverage ：
package Example17;
interface ComputerAverage {
public double average(double a,double b);
}
类A实现接口ComputerAverage
package Example17;
public class A implements ComputerAverage {
public double average(double a, double b) {
double aver = 0;
aver = (a+b)/2;
return aver;
}
}
类B实现接口ComputerAverage
package Example17;
public class B implements ComputerAverage {
public double average(double a, double b) {
double aver = 0;
aver = Math.sqrt(a*b);
return aver;
}
}
主函数调用：
package Example17;
public class Demo {
public static void main(String[] args) {
ComputerAverage average;
double a = 11.45,b = 45.45;
average = new A();
double result = average.average(a, b);
System.out.println(a + "和" + b + "的算术平均值：" + result );
average = new B();
result = average.average(a, b);
System.out.println(a + "和" + b + "的几何平均值：" + result );
}
}
调试结果：
11.45和45.45的算术平均值：28.450000000000003 11.45和45.45的几个平均值：22.81233219116362
在这个例子中类A和类B都实现了ComputerAverage接口，但是实现的方式不同。
关于接口参数：
如果一个方法参数的类型是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给接口参数，那么接口参数就可以回调类实现的接口方法，下面举个例子：
基本接口SpeakHello.java
package Example18;
interface SpeakHello {
void speakHello();
}
Chinese类实现接口：
package Example18;
public class Chinese implements SpeakHello {
public void speakHello() {
System.out.println("中国人习惯问候语：你好！吃饭了吗？");
}
}
English类实现接口
package Example18;
public class English implements SpeakHello {
public void speakHello() {
System.out.println("英国人习惯性用语：你好，天气不错！");
}
}
KindHello类使用接口类型参数，实现接口回调
package Example18;
public class KindHello {
public void lookHello(SpeakHello hello) {
//接口类型参数，接口回调
hello.speakHello();
}
}
主调用函数：
1 package Example18; 2 3 public class Demo { 4 5 public static void main(String[] args) { 6 KindHello kindHello = new KindHello(); 7 kindHello.lookHello(new Chinese()); 8 kindHello.lookHello(new English()); 9 } 10 11 }
调试结果：
1 中国人习惯问候语：你好！吃饭了吗？ 2 英国人习惯性用语：你好，天气不错！
abstract类与接口的比较：
1、abstract类和接口都可以有abstract方法。
2、接口中只可以有常量，不能有变量；而abstract类中既可以有常量也可以有变量。
3、abstract类中也可以有非abstract方法，而接口必须是抽象方法。
需要注意的是：
在设计程序时应当根据具体的方法来确定是使用抽象类还是接口。abstract类除了提供重要的需要子类重写的abstract方法之外，也提供了子类可以继承的变量和非abstract方法。如果某个问题需要使用继承才能更好地解决，比如：子类除了需要重写父类的abstract方法，还需要从父类继承一些变量或者继承一些重要的非abstract方法，就可以考虑使用abstract类。如果某个问题不需要继承，只是需要若干个子类给出某些重要的abstract方法的实现细节，就可以考虑使用接口。
一个面向接口编程的应用举例：
问题的提出：
设计一个广告牌，希望所设计的广告牌可以展示许多公司的广告词。
1、问题的分析：
如果我们设计的创建广告牌的类中是某个具体公司类。（例如联想公司类），声明了对象。那么我们的广告牌就缺少弹性，因为用户一旦需要广告牌展示其他公司的广告词，就需要修改广告牌类的代码，比如用长虹公司声明成员变量。
如果没当用户有了新的需求，就会导致修改类的某部分代码，那么就应当将这部分代码从该类重分割出去，使它和其他稳定的代码之间是松耦合的关系（否则系统缺乏弹性，难以维护），即将每种可能的变化对应地交给实现接口的类（抽象类的子类）去负责完成。
2、设计接口。
根据以上的对问题的分析，首先设计一个接口Advertisement，改接口有2个方法show-Advertisement()和getCorpName();那么实现Advertisement接口的类必须重写，show-Advertisement()和getCropName()方法，及要求各个公司给出具体的广告词和公司的名称。
3、设计广告牌类
然后我们设计AdvertisementBoard类（广告牌），该类有一个show（Advertisement adver）方法，该方法的参数adver是Advertisement接口类型（就像人们常说的，广告牌对外留有接口）。显然，该及参数adver可以存放任何实现Advertisement接口的类的对象的引用，并且回调重写的接口方法ShowAdvertisement()来显示公司的广告词，回调类重写的接口方法getCropName()来显示公司的名称。
下面是具体实现的代码：
广告Advertisement接口：
1 package Example19; 2 /** 3 * 接口 4 * @author 10497 5 * 6 */ 7 public interface Advertisement { 8 public void ShowAdvertisement(); 9 public String getCropName(); 10 }
广告牌类，完成接口回调：
1 package Example19; 2 /** 3 * 广告牌类 4 * @author 10497 5 * 6 */ 7 8 public class AdvertisementBoard { 9 public void Show(Advertisement adver){//使用接口参数 10 System.out.println(adver.getCropName() + "的广告词如下："); 11 adver.ShowAdvertisement(); 12 //接口回调 13 } 14 }
安踏公司实现接口：
1 package Example19; 2 3 public class AnTaCrop implements Advertisement { 4 5 public void ShowAdvertisement() { 6 System.out.println("@@@@@@@@@@@@@@@@@@@"); 7 System.out.println("安踏，运动永不止步~~"); 8 System.out.println("@@@@@@@@@@@@@@@@@@@"); 9 } 10 11 public String getCropName() { 12 return "安踏有限公司"; 13 } 14 15 }
特步公司实现接口
package Example19; public class TeBuCorp implements Advertisement { public void ShowAdvertisement() { System.out.println("**********************"); System.out.println("特步，非一般的感觉~~~~~"); System.out.println("**********************"); } public String getCropName() { return "特步有限公司"; } }
主调用函数：
1 package Example19; 2 3 public class Application { 4 public static void main(String args[]){ 5 AdvertisementBoard board = new AdvertisementBoard(); 6 board.Show(new AnTaCrop()); 7 board.Show(new TeBuCorp()); 8 } 9 }
调试结果：
1 安踏有限公司的广告词如下： 2 @@@@@@@@@@@@@@@@@@@ 3 安踏，运动永不止步~~ 4 @@@@@@@@@@@@@@@@@@@ 5 特步有限公司的广告词如下： 6 ********************** 7 特步，非一般的感觉~~~~~ 8 **********************
以上是关于java中，一个类实现某个接口，必须重写接口中的所有方法吗？？？的主要内容，如果未能解决你的问题，请参考以下文章
java中，一个类实现某个接口，必须重写接口中的所有方法吗？