1. Na declaração da classe, use a palavra-chave extends para criar uma subclasse da classe. Uma classe declara que usa uma ou mais interfaces por meio da palavra-chave implements.
Estender significa herdar uma determinada classe. Após a herança, você pode usar os métodos da classe pai ou substituir os métodos da classe pai. Implementar significa implementar várias interfaces. Os métodos de interface geralmente são vazios e devem ser reescritos; usado.
2. Estender é herdar a classe pai. Contanto que a classe não seja declarada como final ou definida como abstrata, JAVA não suporta herança múltipla, mas pode ser implementada usando interfaces. Nesse caso, os implementos devem ser usados. A herança só pode herdar uma classe, mas os implementos podem implementar várias interfaces, basta separá-las com vírgulas.
Copie o código do código da seguinte forma:
classe A estende B implementa C,D,E
Depois de estudar muito, finalmente entendi a implementação hoje. Na verdade, é muito simples. Basta olhar os exemplos a seguir.
Alguns conceitos de interfaces
<!--[if !supportLineBreakNewLine]-->
Copie o código do código da seguinte forma:
Runner de interface pública
{
ID interno = 1;
execução nula();
}
interface Animal estende Runner
{
respirar vazio();
}
classe Peixe implementa Animal
{
execução de vazio público ()
{
System.out.println("o peixe está nadando");
}
respirador vazio público()
{
System.out.println("peixe está borbulhando");
}
}
abstrato LandAnimal implementa Animal
{
respirador vazio público ()
{
System.out.println("LandAnimal está respirando");
}
}
classe Aluno estende Pessoa implementa Runner
{
...
execução de vazio público ()
{
System.out.println("o aluno está correndo");
}
...
}
folheto de interface
{
mosca vazia();
}
classe Bird implementa Runner, Flyer
{
execução de vazio público ()
{
System.out.println("o pássaro está correndo");
}
mosca nula pública()
{
System.out.println("o pássaro está voando");
}
}
classe TestFish
{
público estático void principal (String args[])
{
Peixe f = novo Peixe();
int j = 0;
j = Corredor.ID;
j = f.ID;
}
}
Notas sobre implementação de interface:
a. Implementar uma interface é implementar todos os métodos da interface (exceto classes abstratas).
b. Os métodos na interface são abstratos.
c. Várias classes não relacionadas podem implementar a mesma interface e uma classe pode implementar várias interfaces não relacionadas.
================================================= =========
A diferença entre estende e implementa
estende é herdar a classe pai. Contanto que a classe não seja declarada como final ou definida como abstrata, JAVA não suporta herança múltipla, mas pode ser implementada usando interfaces. implementos devem ser usados. A herança pode herdar apenas uma classe, mas os implementos podem implementar várias interfaces, basta separá-las com vírgulas.
classe A estende B implementa C,D,E
Uma classe declara que usa uma ou mais interfaces por meio da palavra-chave implements. Na declaração da classe, use a palavra-chave extends para criar uma subclasse da classe.
Copie o código do código da seguinte forma:
nome da subclasse da classe estende o nome da classe pai implementa o nome da interface
{...
}
================================================= =========
A a = new B(); Como resultado, a é uma instância da classe A e só pode acessar métodos em A. Então, qual é a diferença de A a = new A();?
================================================= ========
classe B estende A
Após a herança, geralmente são definidos alguns membros ou métodos que não são encontrados na classe pai.
A = novo B();
Tudo bem, carregue-o.
a é uma instância de um objeto de classe pai e, portanto, não pode acessar novos membros ou métodos definidos pela subclasse.
================================================= ========
Se definido assim:
classe A{
int eu;
vazio f(){}
}
classe B estende A{
intj;
void f(){}//Reescrever
vazio g(){}
}
Então:
B b = novo B();
b é uma instância de um objeto de subclasse. Ele pode acessar não apenas suas próprias propriedades e métodos, mas também as propriedades e métodos da classe pai. Coisas como bi, bj, bf(), bg() são todas legais. Neste momento bf() é f() em B acessado
A = novo B();
Embora a use o construtor de B, ele se torna uma instância do objeto da classe pai após o upcast e não pode acessar as propriedades e métodos da subclasse. ai,af() são legais, mas aj,ag() são ilegais. Neste momento, acessar af() é acessar f() em B
================================================= ========
A a = new B(); Na verdade, esta instrução possui três processos:
(1) Uma;
Declare a como um objeto de classe pai, apenas uma referência, sem espaço alocado
(2) temperatura B = novo B();
Uma instância de um objeto da classe B é estabelecida através do construtor da classe B, ou seja, inicializada
(3) a = (A)temperatura;
Converta o objeto de subclasse temp em um objeto de classe não pai e atribua-o a um upload (upcast), que é seguro.
Após os três processos acima, a tornou-se completamente uma instância da classe A.
As subclasses geralmente têm mais propriedades e métodos do que as classes pai. O upload apenas os descarta, o que é seguro, enquanto o downcast às vezes os aumenta, o que geralmente é inseguro.
================================================= =========
af() deve corresponder ao método f() da classe B
Depois de chamar o construtor para criar uma instância, a entrada para o método correspondente foi determinada.
Desde então, embora a tenha sido carregado como classe A, o método substituído f() ainda é o método f() de B. Ou seja, cada objeto sabe qual método deve chamar.
A a1 = novo B();
A a2 = novo C();
Embora a1 e a2 sejam objetos da classe A, seus respectivos f() são diferentes. Esta é exatamente a concretização do polimorfismo mencionado no primeiro andar.
Tais questões são explicadas muito claramente em "Reflexões sobre programação Java"
Implements geralmente implementa a interface. estende é uma classe herdada. As interfaces geralmente possuem apenas declarações de métodos, mas nenhuma definição, então faz sentido para Java apontar especificamente a implementação de interfaces, porque herança significa que a classe pai implementou métodos, enquanto as interfaces não implementam seus próprios métodos, apenas declarações, ou seja Um cabeçalho de método não possui corpo de método. Portanto, você pode entender que uma interface é uma subclasse que implementa suas declarações de métodos em vez de herdar seus métodos. No entanto, métodos de classe gerais podem ter corpos de método, por isso é mais razoável chamá-los de herança. A importação de um pacote pode usar todas as classes que implementam não interfaces nele. Então você decide se deseja implementar a interface ou não. Se quiser usá-la, você não pode chamar a interface sem implementá-la, porque a interface é uma especificação, uma coleção de declarações de método sem um corpo de método. Deixe-me dar um exemplo: uma interface pode ser comparada a um protocolo. Por exemplo, se eu disser que um protocolo está “matando”, então você pode usar um facão para implementar essa interface. Claro, você também pode usar grab para implementar a interface de matar, mas não pode usar a interface de matar para matar pessoas, porque a interface de matar é apenas uma descrição de função e um protocolo. . Portanto, se houver uma interface em um pacote, você não precisará implementá-la. Isso não afeta o uso de outras classes.
implementos
implements é uma palavra-chave usada por uma classe para implementar uma interface. É usada para implementar os métodos abstratos definidos na interface. Por exemplo: people é uma interface e possui o método say. public interface people(){ public say();} Mas a interface não possui corpo de método. O corpo do método só pode ser implementado através de uma classe específica. Por exemplo, a classe chinesa implementa a interface de pessoas. classe pública chinesa implementa pessoas{ public say() {System.out.println("Olá!");}}
Em Java, implementa significa que uma subclasse herda uma classe pai. Por exemplo, a classe A herda a classe B e é escrita como a classe A implementa B{}.
Diferença de extensões
estende, você pode implementar a classe pai ou pode chamar a classe pai para inicializar this.parent(). E substituirá variáveis ou funções definidas pela classe pai. A vantagem disso é que o arquiteto pode definir a interface e deixar o engenheiro implementá-la. A eficiência de desenvolvimento e os custos de desenvolvimento de todo o projeto são bastante reduzidos.
implementa, implementa a classe pai e as subclasses não podem substituir os métodos ou variáveis da classe pai. Mesmo que a subclasse defina as mesmas variáveis ou funções que a classe pai, elas serão substituídas pela classe pai.
O uso específico dessas duas implementações depende da situação real do projeto e precisa ser implementado. Os implementos não podem ser modificados. Apenas a interface definida precisa ser implementada especificamente, ou pode ser modificada para uma boa escalabilidade.
<!--[endif]-->