java抽象类和接口和继承之间关系
2013-02-18 16:06
211 查看
有时候,我们可能想要构造一个很抽象的父类对象,它可能仅仅代表一个分类或抽象概念,它的实例没有任何 意义,因此不希望它能被实例化。例如:有一个父类“水果(Fruit)”,它有几个子类“苹果(Apple)”、“橘子(Orange)”、“香蕉(Banana)”等。水果在这里仅仅只是作为一个分类, 显然水果的实例没有什么意义(就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子,你很难想象他到底买的是什么。)。而水果类又要能被子 类化,这就要求我们使用抽象类(abstract class)来解决这个问题。
在java中,通过在class关键字前增加abstract修饰符,就可以将一个类定义成抽象类。抽象类不能被实例化。例如:
定义抽象类水果(Fruit)
public abstract class Fruit {
……
}
如果我们试图用以下语句来获得一个实例,将无法编译成功。
Fruit fruit = new Fruit();
而我们仍然可以构造水果类的子类,如:
子类“苹果(Apple)”
public class Apple extends Fruit {
……
}
子类“橘子(Orange)”
public class Orange extends Fruit {
……
}
这样就达到我们的目的了。
抽象类除了能象普通类一样可以拥有一般的属性和方法,也可以拥有抽象方法(abstract method)。例如:
抽象类“形状(Shape)”拥有抽象方法draw()。
public abstract class Shape {
……
public abstract void draw();
……
}
抽象方法与抽象的行为相对应,通常是这个行为对父对象没有意义,而子对象有具体动作。例如方法draw()对于类Shape没有意义,而类Shape的子 类矩形(Rectangle)的方法draw()可以有实际的动作(根据矩形的四个顶点画出矩形的四个边),子类圆(Circle)的方法draw()也 可以有实际的动作(根据圆心和半径画出圆周)。
抽象类可以有抽象方法也可以没有抽象方法;但是如果一个类有抽象方法,那这个类只能定义为抽象类。
如果按照以下代码类“形状(Shape)”仍然拥有抽象方法draw(),但没有定义为抽象类,将会编译失败。
public class Shape {
……
public abstract void draw();
……
}
抽象方法还有一个特点是,它强迫子类要么仍然保持抽象性(即不具体实现该方法并仍然定义为抽象类),要么具体表现出这个方法的行为(实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为)。这样也可以强化多态性。
上面简要分析了抽象类,下面谈谈接口(interface)。java语言使用关键字interface定义一个接口。接口也是抽象对象,它甚至比抽象类更抽象。接口中的方法都是抽象方法。
一个接口可以继承其他接口;一个类通过关键字implements声明要实现一个接口,并具体实现接口的方法。
例如:有一个接口InterfaceA,
Java代码
public
interface
InterfaceA {
void
methodA();
}
类ClassA实现接口InterfaceA。
Java代码
public
class
ClassA implements InterfaceA {
public
void
methodA() {
System.out.println(
"methodA of ClassA implements InterfaceA"
);
}
}
如果是抽象类实现一个接口,那么抽象类中可以不具体实现接口的方法(保持其抽象性),而由其子类去实现。
抽象类ClassB实现接口InterfaceA,但是没有具体实现方法methodA(),
Java代码
public
abstract
class
ClassB { }
子类ClassBSub实现接口InterfaceA,但是没有具体实现方法methodA(),
Java代码
public
class
ClassBSub {
public
void
methodA() {
System.out.println(
"methodA of ClassBSub the subclass of ClassB"
);
}
}
接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。
接口和抽象类的不同点有:
(1)抽象类可以有实例变量,而接口不能拥有实例变量,接口中的变量都是静态(static)的常量(final)。
(2)抽象类可以有非抽象方法,而接口只能有抽象方法。
java中,类与类之间是不能多继承的。java之所以禁止类与类之间的多继承是因为多继承有很大的缺点。
多继承虽然能使子类同时拥有多个父类的特征,但是其缺点也是很显著的,主要有两方面:
(1)如果在一个子类继承的多个父类中拥有相同名字的实例变量,子类在引用该变量时将产生歧义,无法判断应该使用哪个父类的变量。例如:
类ClassA:
Java代码
public
class
ClassA {
protected
int
varSame = 0
;
}
类ClassB:
Java代码
public
class
ClassB {
protected
int
varSame = 1
;
}
子类ClassC:(假设允许类与类之间多继承)
Java代码
public
class
ClassC extends
ClassA, ClassB {
public
void
printOut() {
System.out.println(
super
.varSame);
}
public
static
void
main(String[] args) {
ClassC classC = new
ClassC();
classC.printOut();
}
}
上面程序的运行结果会是什么呢?输出0还是1?
(2)如果在一个子类继承的多个父类中拥有相同方法,子类中有没有覆盖该方法,那么调用该方法时将产生歧义,无法判断应该调用哪个父类的方法。例如:
类ClassA:
Java代码
public
class
ClassA {
public
void
printOut() {
System.out.println(
0
);
}
}
类ClassB:
Java代码
public
class
ClassB {
public
void
printOut() {
System.out.println(
1
);
}
}
子类ClassC:(假设允许类与类之间多继承)
Java代码
public
class
ClassC extends
ClassA, ClassB {
public
static
void
main(String[] args) {
ClassA classA =
new
ClassC();
classA.printOut();
// ------------------------- A行
ClassB classB =
new
ClassC();
classB.printOut();
// ------------------------- B行
ClassC classC =
new
ClassC();
classC.printOut();
//------------------------- C行
}
}
上面程序的运行结果会是什么呢?A、B、C三行的输出是0还是1?
正因为有以上的致命缺点,所以java中禁止一个类继承多个父类;但是幸运的是java提供了接口,并能通过接口的功能获得多继承的许多优点而又摒弃了类与类多继承的缺点。
java允许一个接口继承多个父接口,也允许一个类实现多个接口,而这样的多继承有上面提到的缺点马?
答案是没有,这是由接口的抽象性决定的。
正如前面介绍的,在接口中不能有实例变量,只能有静态的常量,不能有具体的方法(包含方法体),只能有抽象方法,因此也就摒弃了多继承的缺点。
对于一个类实现多个接口的情况,因为接口只有抽象方法,具体方法只能由实现接口的类实现,在调用的时候始终只会调用实现类的方法(不存在歧义),因此不存 在多继承的第二个缺点;而又因为接口只有静态的常量,但是由于静态变量是在编译期决定调用关系的,即使存在一定的冲突也会在编译时提示出错;而引用静态变 量一般直接使用类名或接口名,从而避免产生歧义,因此也不存在多继承的第一个缺点。
对于一个接口继承多个父接口的情况也一样不存在这些缺点。
请看以下示例。
接口A:
Java代码
public
interface
InterfaceA {
int
len = 1
;
void
output();
}
接口B:
Java代码
public
interface
InterfaceB {
int
len = 2
;
void
output();
}
接口Sub继承接口A和接口B:
Java代码
public
interface
InterfaceSub extends
InterfaceA, interfaceB { }
类Xyz实现接口Sub:
Java代码
public
class
Xyz implements
InterfaceSub {
public
void
output() {
System.out.println(
"output in class Xyz."
);
}
public
void
outputLen(
int
type) {
switch
(type) {
case
InterfaceA.len:
System.out.println(
"len of InterfaceA=."
+type);
break
;
case
InterfaceB.len:
System.out.println(
"len of InterfaceB=."
+type);
break
;
}
}
public
static
void
main(String[] args) {
Xyz xyz= new
Xyz ();
xyz .output();
xyz .outputLen();
}
以上代码不存在什么问题,但是如果试图编写以下存在冲突的代码,则会编译失败。
Java代码
Xyz xyz = new
Xyz();
int
len = xyz.len;
System.out.println(len);
由于引入了接口,java显得非常灵活,也使得java中的多态性更加富有魔力。
在java中,通过在class关键字前增加abstract修饰符,就可以将一个类定义成抽象类。抽象类不能被实例化。例如:
定义抽象类水果(Fruit)
public abstract class Fruit {
……
}
如果我们试图用以下语句来获得一个实例,将无法编译成功。
Fruit fruit = new Fruit();
而我们仍然可以构造水果类的子类,如:
子类“苹果(Apple)”
public class Apple extends Fruit {
……
}
子类“橘子(Orange)”
public class Orange extends Fruit {
……
}
这样就达到我们的目的了。
抽象类除了能象普通类一样可以拥有一般的属性和方法,也可以拥有抽象方法(abstract method)。例如:
抽象类“形状(Shape)”拥有抽象方法draw()。
public abstract class Shape {
……
public abstract void draw();
……
}
抽象方法与抽象的行为相对应,通常是这个行为对父对象没有意义,而子对象有具体动作。例如方法draw()对于类Shape没有意义,而类Shape的子 类矩形(Rectangle)的方法draw()可以有实际的动作(根据矩形的四个顶点画出矩形的四个边),子类圆(Circle)的方法draw()也 可以有实际的动作(根据圆心和半径画出圆周)。
抽象类可以有抽象方法也可以没有抽象方法;但是如果一个类有抽象方法,那这个类只能定义为抽象类。
如果按照以下代码类“形状(Shape)”仍然拥有抽象方法draw(),但没有定义为抽象类,将会编译失败。
public class Shape {
……
public abstract void draw();
……
}
抽象方法还有一个特点是,它强迫子类要么仍然保持抽象性(即不具体实现该方法并仍然定义为抽象类),要么具体表现出这个方法的行为(实现具体的动作或者通过抛出UnsupportedOperationException异常来表明不支持该行为)。这样也可以强化多态性。
上面简要分析了抽象类,下面谈谈接口(interface)。java语言使用关键字interface定义一个接口。接口也是抽象对象,它甚至比抽象类更抽象。接口中的方法都是抽象方法。
一个接口可以继承其他接口;一个类通过关键字implements声明要实现一个接口,并具体实现接口的方法。
例如:有一个接口InterfaceA,
Java代码
public
interface
InterfaceA {
void
methodA();
}
类ClassA实现接口InterfaceA。
Java代码
public
class
ClassA implements InterfaceA {
public
void
methodA() {
System.out.println(
"methodA of ClassA implements InterfaceA"
);
}
}
如果是抽象类实现一个接口,那么抽象类中可以不具体实现接口的方法(保持其抽象性),而由其子类去实现。
抽象类ClassB实现接口InterfaceA,但是没有具体实现方法methodA(),
Java代码
public
abstract
class
ClassB { }
子类ClassBSub实现接口InterfaceA,但是没有具体实现方法methodA(),
Java代码
public
class
ClassBSub {
public
void
methodA() {
System.out.println(
"methodA of ClassBSub the subclass of ClassB"
);
}
}
接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。
接口和抽象类的不同点有:
(1)抽象类可以有实例变量,而接口不能拥有实例变量,接口中的变量都是静态(static)的常量(final)。
(2)抽象类可以有非抽象方法,而接口只能有抽象方法。
java中,类与类之间是不能多继承的。java之所以禁止类与类之间的多继承是因为多继承有很大的缺点。
多继承虽然能使子类同时拥有多个父类的特征,但是其缺点也是很显著的,主要有两方面:
(1)如果在一个子类继承的多个父类中拥有相同名字的实例变量,子类在引用该变量时将产生歧义,无法判断应该使用哪个父类的变量。例如:
类ClassA:
Java代码
public
class
ClassA {
protected
int
varSame = 0
;
}
类ClassB:
Java代码
public
class
ClassB {
protected
int
varSame = 1
;
}
子类ClassC:(假设允许类与类之间多继承)
Java代码
public
class
ClassC extends
ClassA, ClassB {
public
void
printOut() {
System.out.println(
super
.varSame);
}
public
static
void
main(String[] args) {
ClassC classC = new
ClassC();
classC.printOut();
}
}
上面程序的运行结果会是什么呢?输出0还是1?
(2)如果在一个子类继承的多个父类中拥有相同方法,子类中有没有覆盖该方法,那么调用该方法时将产生歧义,无法判断应该调用哪个父类的方法。例如:
类ClassA:
Java代码
public
class
ClassA {
public
void
printOut() {
System.out.println(
0
);
}
}
类ClassB:
Java代码
public
class
ClassB {
public
void
printOut() {
System.out.println(
1
);
}
}
子类ClassC:(假设允许类与类之间多继承)
Java代码
public
class
ClassC extends
ClassA, ClassB {
public
static
void
main(String[] args) {
ClassA classA =
new
ClassC();
classA.printOut();
// ------------------------- A行
ClassB classB =
new
ClassC();
classB.printOut();
// ------------------------- B行
ClassC classC =
new
ClassC();
classC.printOut();
//------------------------- C行
}
}
上面程序的运行结果会是什么呢?A、B、C三行的输出是0还是1?
正因为有以上的致命缺点,所以java中禁止一个类继承多个父类;但是幸运的是java提供了接口,并能通过接口的功能获得多继承的许多优点而又摒弃了类与类多继承的缺点。
java允许一个接口继承多个父接口,也允许一个类实现多个接口,而这样的多继承有上面提到的缺点马?
答案是没有,这是由接口的抽象性决定的。
正如前面介绍的,在接口中不能有实例变量,只能有静态的常量,不能有具体的方法(包含方法体),只能有抽象方法,因此也就摒弃了多继承的缺点。
对于一个类实现多个接口的情况,因为接口只有抽象方法,具体方法只能由实现接口的类实现,在调用的时候始终只会调用实现类的方法(不存在歧义),因此不存 在多继承的第二个缺点;而又因为接口只有静态的常量,但是由于静态变量是在编译期决定调用关系的,即使存在一定的冲突也会在编译时提示出错;而引用静态变 量一般直接使用类名或接口名,从而避免产生歧义,因此也不存在多继承的第一个缺点。
对于一个接口继承多个父接口的情况也一样不存在这些缺点。
请看以下示例。
接口A:
Java代码
public
interface
InterfaceA {
int
len = 1
;
void
output();
}
接口B:
Java代码
public
interface
InterfaceB {
int
len = 2
;
void
output();
}
接口Sub继承接口A和接口B:
Java代码
public
interface
InterfaceSub extends
InterfaceA, interfaceB { }
类Xyz实现接口Sub:
Java代码
public
class
Xyz implements
InterfaceSub {
public
void
output() {
System.out.println(
"output in class Xyz."
);
}
public
void
outputLen(
int
type) {
switch
(type) {
case
InterfaceA.len:
System.out.println(
"len of InterfaceA=."
+type);
break
;
case
InterfaceB.len:
System.out.println(
"len of InterfaceB=."
+type);
break
;
}
}
public
static
void
main(String[] args) {
Xyz xyz= new
Xyz ();
xyz .output();
xyz .outputLen();
}
以上代码不存在什么问题,但是如果试图编写以下存在冲突的代码,则会编译失败。
Java代码
Xyz xyz = new
Xyz();
int
len = xyz.len;
System.out.println(len);
由于引入了接口,java显得非常灵活,也使得java中的多态性更加富有魔力。
相关文章推荐
- java抽象类和接口和继承之间关系
- java抽象类、接口和继承之间关系
- Java抽象类和接口和继承之间关系
- [转]java抽象类和接口和继承之间关系
- Java抽象类和接口和继承之间关系
- Java抽象类和接口和继承之间关系
- 继承,抽象,接口之间的关系和区别
- 抽象类与接口之间的继承和实现关系
- 抽象类与接口之间的继承和实现关系
- 继承,抽象,接口之间的关系和区别
- 接口之间继承、抽象类普通类继承关系总结 (
- java(未检出20130729) String、StringBuffer、类与类之间关系:依赖关系Use-a、.聚合关系has-a、组合继承(“is-a”)、抽象类、接口
- 类、抽象类、接口和继承之间的关系
- 接口、抽象类、继承、实现的定义及它们之间的关系
- c++中的类之间继承的关系
- java实现接口与继承的关系
- Cocoa框架类之间的继承关系
- IOS开发类之间的继承关系 两张树状图片
- [原创]java WEB学习笔记99:Spring学习---Spring Bean配置:自动装配,配置bean之间的关系(继承/依赖),bean的作用域(singleton,prototype,web环境作用域),使用外部属性文件
- Hibernate中的Entity类之间的继承关系之一MappedSuperclass