|
Plusieurs moyens d'héritage qu'une classe peut hériter des comportements et des caractéristiques de plus d'une classe parente là-bas, mais nous savons que Java Pour assurer la sécurité des données, il permet seulement l'héritage unique. Parfois, nous pensons que si le système nécessite l'utilisation de l'héritage multiple sont souvent mal conçus, cette fois-ci nous avons souvent besoin de penser à est pas comment utiliser l'héritage multiple, mais votre conception s'il y a des problèmes, mais parfois nous avons vraiment besoin d'obtenir plusieurs l'héritage, mais aussi dans la vraie vie, il y a vraiment une telle situation, comme génétique: qui est, nous avons hérité le comportement de son père et ses caractéristiques sont également hérité du comportement de sa mère et ses caractéristiques. Heureusement Java est très gentil et nous comprendre, il fournit deux façons pour nous d'atteindre tortueuse héritage multiple: interfaces et classes internes.
Tout d'abord, l'interface
la sous-classe appris ne peut hériter que l'introduction d'interfaces et classes abstraites quand une classe parent, ce qui signifie qu'il n'y a qu'un seul héritage, mais peut implémenter plusieurs interfaces, qui pour nous d'obtenir l'héritage multiple pour préparer le terrain.
Pour l'interface, parfois il est non seulement une manifestation d'une classe plus purement abstraite, les interfaces, il n'y a pas de mise en œuvre spécifique, qui est, non associée à une combinaison de l'interface de stockage, de sorte qu'il ne peut pas empêcher plusieurs interfaces a.
[Java]
vue texte brut
Copiez le code
|
01
02
03
04
05
06
07
08
09
dix
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
interface
CanFight {
void
fight();
}
interface
CanSwim {
void
swim();
}
interface
CanFly {
void
fly();
}
public
class
ActionCharacter {
public
void
fight(){
}
}
public
class
Hero
extends
ActionCharacter
implements
CanFight,CanFly,CanSwim{
public
void
fly() {
}
public
void
swim() {
}
/**
* 对于fight()方法，继承父类的，所以不需要显示声明
*/
}
|
En second lieu, la classe interne
L'interface utilisation au-dessus de l'héritage multiple est un moyen plus viable et populaire, l'introduction de classe interne en ce qui concerne la classe interne héritage multiple de mise en œuvre est devenue plus parfaite, mais aussi clairement fait savoir que si la classe parente est abstraite ou concrète classe, alors je ne peut être atteint grâce à l'héritage multiple classes internes. Comment utiliser les outils internes de classe héritage multiple, considérons l'exemple suivant: Comment est l'utilisation de plusieurs fils d'héritage au père Hériter bons gènes et la mère.
Tout d'abord, le père Père et Mère Mère:
[Java]
vue texte brut
Copiez le code
|
01
02
03
04
05
06
07
08
09
dix
11
|
public
class
Father {
public
int
strong(){
return
9
;
}
}
public
class
Mother {
public
int
kind(){
return
8
;
}
}
|
重头戏在这里，儿子类Son：
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public
class
Son {
/**
* 内部类继承Father类
*/
class
Father_1
extends
Father{
public
int
strong(){
return
super
.strong() +
1
;
}
}
class
Mother_1
extends
Mother{
public
int
kind(){
return
super
.kind() -
2
;
}
}
public
int
getStrong(){
return
new
Father_1().strong();
}
public
int
getKind(){
return
new
Mother_1().kind();
}
}
|
测试程序：
[Java]
纯文本查看
复制代码
|
01
02
03
04
05
06
07
08
09
10
11
12
13
|
public
class
Test1 {
public
static
void
main(String[] args) {
Son son =
new
Son();
System.out.println(
"Son 的Strong："
+ son.getStrong());
System.out.println(
"Son 的kind："
+ son.getKind());
}
}
----------------------------------------
Output:
Son 的Strong：
10
Son 的kind：
6
|
儿子继承了父亲，变得比父亲更加强壮，同时也继承了母亲，只不过温柔指数下降了。这里定义了两个内部类，他们分别继承父亲Father类、母亲类Mother类，且都可以非常自然地获取各自父类的行为，这是内部类一个重要的特性：内部类可以继承一个与外部类无关的类，保证了内部类的独立性，正是基于这一点，多重继承才会成为可能。
更多java学习资料可关注:itheimaGZ获取
|
