Este artigo é transferido de: https://www.cnblogs.com/yubinfeng/p/4555948.html
Na seção anterior, falamos sobre o encapsulamento de um dos três principais recursos orientados a objetos, que resolve o problema de reunir todas as informações que podem ser operadas no mesmo objeto, implementar chamadas externas unificadas, conseguir a reutilização do mesmo objeto e reduzir o acoplamento.
No entanto, em aplicações práticas, muitos objetos têm os mesmos atributos ou atributos semelhantes.Por exemplo, existe um objeto árvore frutífera (FruitTree), que possui um atributo de membro leaf (Leaf), florescerá (Flower), terá um tronco (Stem), terá uma raiz ( Root), crescerá (método de crescimento).
Há outro objeto macieira (AppleTree), que também é uma árvore frutífera, com todas as características das árvores frutíferas, então definimos um objeto macieira ao programar, se houver outra laranjeira (OrangeTree), pessegueiro (PeachTree), nós Você não pode sempre copiar este objeto e alterar seu nome? Aqui vamos usar o segundo recurso orientado a objetos: herança.
1. O que é herança
Existe uma relação "is-a" entre FruitTree e OrangeTree acima, ou seja, podemos dizer "laranjeira é uma árvore frutífera". Na programação orientada a objetos, chamamos esse relacionamento de "herança", ou seja, a laranjeira herda da árvore frutífera. Em outras palavras, a laranjeira é um derivado da fruteira; também se pode dizer que a fruteira é a classe pai e a laranjeira é a classe filho. A mesma macieira também pode herdar árvores frutíferas; portanto, pode-se dizer que as macieiras são uma subclasse de árvores frutíferas. Aqui descobrimos que uma classe pode ter várias classes derivadas, ou seja, uma classe pode ser herdada por várias classes .
Através do exemplo acima, resumimos os conceitos relacionados à herança:
(1) Quando uma classe A pode obter a definição de todos os dados e operações não particulares em outra classe B como parte ou todos os seus próprios componentes, diz-se que há uma relação de herança entre as duas classes.
(2) A classe herdada B é chamada classe pai ou classe base, e a classe A que herda a classe pai é chamada classe filho ou classe derivada .
2. Características herdadas
No exemplo acima, se a macieira herda da árvore frutífera, ela possui todos os atributos (folhas, raízes, flores) e métodos (crescimento) da árvore frutífera.A macieira também possui alguns atributos exclusivos, como seu próprio fruto. Apple (Apple); o mesmo pessegueiro possui seu próprio pêssego de frutas (Peach), de modo que as subclasses herdadas podem ter seus próprios membros exclusivos (propriedades ou métodos, etc.).
Recurso um: além de herdar as características da classe pai, as classes derivadas também podem ter suas próprias características exclusivas
Além dos membros públicos, como folhas, raízes e flores, a FruitTree mencionada acima também pode ter membros particulares, como espécies (árvores de fruto decíduas, árvores de fruto sempre verdes) e o membro "espécie", Ele não pertence às subclasses AppleTree e OrangeTree, portanto é um membro privado.Depois que a subclasse herda a classe pai, ela não pode ter os membros privados da classe pai.
Recurso dois: As subclasses não podem ter membros particulares da classe pai
O exemplo acima, se a árvore possui um método público de crescimento (Crescimento), possui duas subclasses pessegueiro e macieira, então a subclasse também possui o método de crescimento, mas o processo de crescimento do pessegueiro e da macieira é diferente Podemos modificar esse método para se adaptar ao crescimento de diferentes tipos de árvores frutíferas.
Recurso três: As subclasses podem implementar as funções da classe pai à sua maneira (ou seja, reescrita de método, que é especificamente introduzida posteriormente)
3 . Implementação herdada
Através do exemplo acima, já estamos familiarizados com a herança, deixando de lado o conceito. Simplificando, a palavra herança vem da vida, há herança de propriedade, herança espiritual. A programação orientada a objetos nada mais é do que abstração desses conceitos, nos termos de um leigo, "macieira é uma árvore frutífera"
O código implementa o exemplo acima
1 /// <resumo>
2 /// classe de árvore de fruto
3 /// </ summary>
4 classe FruitTree
5 {
6 /// <resumo>
7 /// Nome
8 /// Descrição: O modificador protege o acesso. O acesso é limitado a essa classe e subclasses e as instâncias não podem ser acessadas.
9 /// </ summary>
10 nome da string protegida;
11 /// <resumo>
12 /// construtor
13 /// </ summary>
14 public FruitTree ()
15 {
16 this.name = "no name";
17}
18 /// <resumo>
19 /// Construtor 2
20 /// </ summary>
21 /// <param name = "name"> <
22 public FruitTree (nome da string)
24 this.name = name;
25}
26 object _leaf;
27 object _root;
28 object _flower;
29 string _type;
30 /// <resumo>
31 /// leaf (public property)
32 / // </ resumo>
33 folha de objeto público
34 {
35 get {return _leaf;}
36 set {_leaf = value;}
37}
38 /// <summary>
39 /// root (public property)
40 /// < / summary>
41 raiz de objeto público
42 {
43 get {return _root;}
44 conjunto {_root = value;}
45}
46 /// <resumo>
47 /// Flower (public property)
48 /// </ summary>
49 objeto público flower
50 {
51 get {return _flower;}
52 set {_flower = value;}
53}
54 /// <resumo>
55 // / Category (nenhum modificador definido, o padrão é privado)
56 /// </ summary>
57 tipo de string
58 {
59 get {return _type;}
60 set {_type = value;}
61}
62
63}
64
65 /// <summary>
66 /// macieira
67 /// Herdado de: Fruit Tree
68 /// </ summary>
69 class AppleTree: FruitTree
70 {
71 string _myName;
72 /// <resumo>
73 /// Construtor
74 /// Descrição: As subclasses chamam o mesmo construtor da classe pai, você precisa usar: base ()
75 /// </ summary>
76 public AppleTree (): base ()
77 {
78}
79 /// <resumo>
80 /// Construtor dois
81 /// Descrição: As subclasses chamam o mesmo construtor da classe pai, você precisa usar: base (nome)
82 / // </ resumo>
83 /// <param name = "name"> </ param>
84 public AppleTree (nome da string): base (nome)
85 {
86 _myName = nome;
87}
88
89 /// <resumo>
90 /// retorna o nome da fruta
91 /// </ summary>
92 /// <
retorns > </ return > 93 string pública MyFruitName ()
94 {
95 return "Eu sou:" + _meuNome + "; meus frutos são chamados: Apple";
96}
97}
98 /// <summary>
99 ///
Orange
tree class 100 /// Herdado de: Fruit tree class
101 /// </ summary> 102 class OrangeTree: FruitTree
103 {
104 string _myName;
105 /// <resumo>
106 /// Construtor
107 / // Descrição: A subclasse chama o mesmo construtor da classe pai, você precisa usar: base ()
108 /// </ summary>
109 public OrangeTree (): base () base ()
110 {
111}
112 /// <resumo>
113 /// Construtor II
114 /// Descrição : A subclasse chama o mesmo construtor da classe pai, você precisa usar:base (nome)
115 /// </summary>
116 /// <param name = "name"> </ param>
117 public OrangeTree (nome da string): base (name)
118 {
119 _myName = name;
120}
121
122 /// <summary>
123 /// retorna o nome da fruta
124 /// </ summary>
125 /// <returns> </
Returns > 126 cadeia pública MyFruitName ()
127 {
128 return "Eu sou:" + _meu nome + "; I A fruta é chamada: laranja ";
129}
130}
Ligue para a subclasse:
// Chame a subclasse
AppleTree appleTree = new AppleTree ("Apple Tree");
string myName = appleTree.MyFruitName ();
// O resultado do retorno é: Eu sou: macieira; meus frutos são chamados: apple
// Chama a subclasse
OrangeTree orangeTree = new OrangeTree ("橙 树");
string myName = orangeTree. MyFruitName ();
// O resultado retornado é: Eu sou: laranjeira; meus frutos são chamados: laranja
Através desse código, podemos ver que existe uma árvore frutífera da classe base; então, temos centenas de árvores, precisamos apenas de uma herança, pois a subclasse AppleTree.MyFruitName () retorna o nome desse método, em diferentes subclasses Pode ser único, ou seja, as características da herança, pode adicionar membros únicos. Embora as características exclusivas precisem ser definidas separadamente em cada subclasse, o compartilhamento dos membros da classe pai nos salvou muito trabalho, e a estrutura do programa mais importante é mais clara e fácil de manter.
4. Desvantagens da herança
Vendo esse título, os amigos podem se surpreender, pois há muitas vantagens na herança orientada a objetos, e ainda há desvantagens. Obviamente, não há nada perfeito no mundo, e a herança também.
Uma desvantagem: a classe pai muda, a classe filho precisa mudar;
Desvantagem dois: a herança quebra a embalagem e os detalhes da classe pai são expostos à classe filho.
A seção anterior disse que o recurso independente do encapsulamento é reduzir o acoplamento, e herdá-lo para obter a reutilização aumentou o acoplamento.
Falando de onde os amigos estão emaranhados, e depois de usar herança ou não, a resposta é sim, suas vantagens e luz encobrem as deficiências, ou seja, mais benefícios. Aqui para explicar suas deficiências, é para nos lembrar de evitar as consequências de suas deficiências, tanto quanto possível no processo de uso.
Então, como podemos usar bem a herança? Devemos prestar atenção a estes pontos:
a) Quando o relacionamento entre os dois objetos é "é a", você pode usar a herança (como a macieira é uma árvore) b) Quando os dois objetos são "como", não é apropriado usar a herança (como a mão faz parte do ser humano , Não pode deixar a mão herdeiro);
No que diz respeito às vantagens e desvantagens da herança, devemos lembrar de uma coisa: para usar a herança de maneira razoável, podemos obter os melhores resultados, e não cegamente.
Como uma das três principais características da orientação a objetos: herança, pode-se dizer que é a principal prioridade do aprendizado de programação orientada a objetos.Como se pode dizer que esta seção é o foco desta série, não há ninguém.
Meus amigos, é de manhã cedo novamente e continuarei a escrever amanhã. Finalmente, de acordo com a convenção, escreva alguns pontos que precisam ser prestados atenção ao usar a herança.
Pontos-chave:
1: Membros privados na classe pai, classes derivadas nunca são acessíveis;
2: C # requer que uma classe possa ter apenas uma classe base direta;
3: Classes modificadas pela palavra-chave "selada" não podem ser herdadas;
4: Membros ou dados modificados por "protegido" podem ser acessados diretamente por classes derivadas e pertencem a "segredos que podem ser compartilhados na família".
5: faça bom uso da palavra-chave "base" para mostrar que o construtor de classe base personalizado apropriado é chamado em vez de usar o construtor padrão.
6: A herança requer um uso razoável para obter os melhores resultados.Em geral, aplica-se ao relacionamento "é um", não ao relacionamento "tem um".