|
Vários meios de herança que uma classe pode herdar comportamentos e características de mais de uma classe pai lá, mas sabemos Java Para garantir a segurança dos dados, só permite herança simples. Às vezes pensamos que se o sistema requer o uso de herança múltipla são muitas vezes mal concebidos, desta vez, muitas vezes, precisa pensar não é como usar herança múltipla, mas seu projeto, se houver problemas, mas às vezes nós realmente precisamos para alcançar múltipla herança, mas também na vida real não é realmente tal situação, tais como genética, ou seja, nós herdamos o comportamento de seu pai e características também são herdadas comportamento e as características de sua mãe. Felizmente Java é muito gentil e compreender-nos, ele fornece duas maneiras para nós para alcançar tortuosa herança múltipla: Interfaces e classes internas.
Em primeiro lugar, a interface
subclasse aprendeu só pode herdar a introdução de interfaces e classes abstratas, quando uma classe pai, o que significa que há apenas herança simples, mas pode implementar várias interfaces, que para nós para conseguir a herança múltipla para fazer o trabalho de base.
Para a interface lo, às vezes não é apenas uma manifestação de um mais puramente abstrato classes, interfaces, não há nenhuma implementação específica, ou seja, não associadas com qualquer combinação de interface de armazenamento, por isso não pode impedir múltiplas interfaces a.
[Java]
planície vista de texto
Copie o código
|
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
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()方法，继承父类的，所以不需要显示声明
*/
}
|
Em segundo lugar, a classe interna
A interface de utilização acima de herança múltipla é uma maneira mais viável e popular, introduzindo classe interna quando se trata da classe herança múltipla interna da implementação tornou-se mais perfeito, mas também deixou claro que, se a classe pai é abstrato ou concreto classe, então só pode ser conseguida através de várias classes internas de herança. Como usar implementos de classe internas herança múltipla, considere o seguinte exemplo: Como é a utilização do filho herança múltipla de genes bons herdar pai e mãe.
Primeiro, o pai Pai e Mãe Mãe:
[Java]
planície vista de texto
Copie o código
|
01
02
03
04
05
06
07
08
09
10
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获取
|
