Compartilhamento de tecnologia

[Introdução ao JAVA] Dia 15 - Interface

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

[Introdução ao JAVA] Dia 15 - Interface



Por que existe uma interface?
Como todos sabemos, herança consiste em extrair as abstrações comuns da subclasse para a classe pai e obtercomum de todo o sistemaPara salvar o código, entretanto, também existe uma situação: a maioria das subclasses tem uma certa semelhança, mas apenas algumas subclasses não possuem esse recurso, então se essa semelhança for escrita na classe pai, ela será herdada, o que não é razoável para essas poucas subcategorias.
Por exemplo: cães e gatos podem nadar, mas os coelhos não. Neste momento, se o método "natação" for definido na classe pai, não é razoável que o coelho herde. respectivamente, isso pode acontecer. O formato de escrita e a nomenclatura dos dois métodos são inconsistentes. Portanto, precisamos definir um novo conceito para restringir as especificações de escrita dos métodos de "natação" nessas duas subclasses.Neste ponto, podemos definir uma “natação”interface, defina o método abstrato swim() na interface e deixe cães e gatos se conectarem a esta interface para garantirUnificação de código
Resumindo, a interface é umregra, quando precisamos definir regras para múltiplas classes ao mesmo tempo, precisamos usarinterface

1. Interface é uma abstração de “comportamento”

A interface não representa um tipo de coisa, a interface representauma regra, portanto, as interfaces podem ser passadas como parâmetros para métodos.
“Seja um caminhão, um veículo de três rodas ou mão de obra, desde que possa se mover, será útil.”

搬家(车的对象);
  • 1
搬家(搬家公司);
  • 1
public interface 运输 {
	...
}
  • 1
  • 2
  • 3
public void 搬家(运输的接口 c) {
	...
}
  • 1
  • 2
  • 3

2. Definição e utilização de interfaces

  • As interfaces são definidas com a palavra-chave interface.
public interface 接口名 {}
  • 1
  • As interfaces não podem ser instanciadas, o que significa que as interfaces não podem ser usadas para criar objetos.
  • A diferença entre interface e classe éconcluirOs relacionamentos são representados pela palavra-chave implements.
public class 类名 implements 接口名 {}
  • 1
  • Uma subclasse de uma interface (classe de implementação) substitui todos os métodos abstratos na interface ou é ela própria uma classe abstrata.
  • O relacionamento de implementação entre interfaces e classes pode serImplementação única, também podeMúltiplas implementações
public class 类名 implements 接口名1 , 接口名2 {}
  • 1
  • Uma classe de implementação pode implementar múltiplas interfaces enquanto herda uma classe.
public class 类名 extends 父类 implements 接口名1 , 接口名2 {}
  • 1

prática:Escreva classes Javabean padrão com interfaces e classes abstratas.

 青蛙		属性:名字,年龄		行为:吃虫子,蛙泳
 狗			属性:名字,年龄		行为:吃骨头,狗刨
 兔子		属性:名字,年龄		行为:吃胡萝卜
  • 1
  • 2
  • 3

Escreva a classe pai primeiro. Como as três subclasses comem coisas diferentes, você pode definir eat() como um método abstrato:

package oopInterface;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

Interface de gravação Nadar:

package oopInterface;

public interface Swim {
    public abstract void swim();
}
  • 1
  • 2
  • 3
  • 4
  • 5

Ao escrever uma classe sapo, preste atenção em herdar a classe pai e reescrever o método abstrato da classe pai, e preste atenção na implementação da interface de natação:

package oopInterface;

public class Frog extends Animal implements Swim {
    public Frog() {
        super();
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳。");
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Ao escrever uma classe dog, preste atenção em herdar a classe pai e substituir o método abstrato da classe pai para implementar a interface de natação:

package oopInterface;

public class Dog extends Animal implements Swim {

    public Dog(){
        super();
    }

    public Dog(String name, int age) {
        super(name,age);
    }
    @Override
    public void swim() {
        System.out.println("狗在狗刨。");
    }

    @Override
    public void eat() {
        System.out.println("狗在吃骨头。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Ao escrever uma classe de coelho, observe que você só precisa herdar a classe pai e substituir o método abstrato, e não precisa implementar a interface de natação (você não pode nadar):

package oopInterface;

public class Rabbit extends Animal {

    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

Escreva aulas de teste.

package oopInterface;

public class Test {
    public static void main(String[] args) {
        Frog f = new Frog("小绿",23);
        f.eat();
        f.swim();
        System.out.println(f.getName() + ", " + f.getAge());
        Dog d = new Dog("大D", 24);
        d.eat();
        d.swim();
        System.out.println(d.getName() + ", " + d.getAge());
        Rabbit r = new Rabbit("兔子", 30);
        r.eat();
        System.out.println(r.getName() + ", " + r.getAge());
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

3. Características dos membros da interface

  • Variáveis ​​de membro: variáveis ​​de membro em uma interface só podem serconstante, public static final é usado por padrão (mesmo que você não o escreva, ele será automaticamente considerado desta forma).
  • Construtor: interfaceNãoMétodo de construção.
  • Métodos membros: Antes do JDK7, eles só podiam ser métodos abstratos.padrãoO modificador é público abstrato; após JDK8, métodos com corpos de método podem ser definidos em interfaces; após JDK9, métodos privados podem ser definidos em interfaces;

4. A relação entre interfaces e classes

  • O relacionamento entre classes: Relacionamento de herança - apenas herança única, não herança múltipla, mas herança multinível é possível.
  • O relacionamento entre classes e interfaces: Relacionamento de implementação - pode ser implementado sozinho ou em múltiplas implementações, e você também pode implementar múltiplas interfaces enquanto herda uma classe.
  • A relação entre interfaces: relação de herança - pode ser herança única ou herança múltipla.

Perceber:
1. Quando uma classe implementa uma interface, ela deve implementar todos os métodos abstratos na interface ou a própria classe também é uma classe abstrata.
2. Uma classe pode implementar múltiplas interfaces. Se implementar múltiplas interfaces, ela precisa ser.todosTodos os métodos abstratos a serem implementados na interface são implementados.
3. As interfaces podem ser herdadas de múltiplas interfaces Se uma subinterface herda múltiplas interfaces e é então implementada por uma classe de implementação, então a classe de implementação deve combinar a subinterface e todas as suas interfaces pai.todosTodos os métodos abstratos são implementados.

prática:Escreva classes Javabean padrão com interfaces e classes abstratas.

乒乓球运动员:姓名,年龄,学打乒乓球,说英语
篮球运动员:姓名,年龄,学打篮球
乒乓球教练:姓名,年龄,教打乒乓球,说英语
篮球教练:姓名,年龄,教打篮球
  • 1
  • 2
  • 3
  • 4
//Person类
package oopInterExp;

//因为直接创建顶层父类人的对象是没有意义的
//所以将其写为抽象类
public abstract class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
//Sporter类继承Person
package oopInterExp;

public abstract class Sporter extends Person {

    public Sporter(String name, int age) {
        super(name, age);
    }

    public Sporter() {
    }

    public abstract void learn();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
//Coach类继承Person
package oopInterExp;

public abstract class Coach extends Person {

    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
//SpeakEnglish接口
package oopInterExp;

public interface SpeakEnglishInter {
    public abstract void speakEnglish();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
//PingPongSporter继承Sporter,实现SpeakEnglish
package oopInterExp;

public class PingPongSporter extends Sporter implements SpeakEnglishInter {

    public PingPongSporter(String name, int age) {
        super(name, age);
    }

    public PingPongSporter() {
    }

    @Override
    public void learn() {
        System.out.println("学习乒乓球。");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
//PingPongCoach继承Coach,实现SpeakEnglish
package oopInterExp;

public class PingPongCoach extends Coach implements SpeakEnglishInter {
    public PingPongCoach() {
    }

    public PingPongCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("教乒乓球。");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在说英语。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
//BasketballSporter继承Sporter
package oopInterExp;

public class BasketballSporter extends Sporter {

    public BasketballSporter(String name, int age) {
        super(name, age);
    }

    public BasketballSporter() {
    }

    public void learn() {
        System.out.println("学篮球。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
//BasketballCoach继承Coach
package oopInterExp;

public class BasketballCoach extends Coach {

    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    public void teach() {
        System.out.println("教篮球。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

5. Novos métodos na interface

5.1 Novos métodos na interface inicial do JDK8

Antes do JDK7, apenas métodos abstratos podiam ser definidos em interfaces.
O novo recurso do JDK8 é: métodos com corpos de método podem ser definidos na interface (pode definirpadrãométodo ouestáticométodo).
A novidade do JDK9 é: ele pode ser definido na interfaceprivadométodo.

5.1.1 Métodos padrão em interfaces

Métodos com corpos de método são definidos na interface, principalmente paraAtualização de interfaceConsiderando que a interface não pode ser imutável, novos métodos precisam ser adicionados a ela para atualização. Se esses métodos forem métodos abstratos, neste momento, esses métodos precisam ser implementados na classe de implementação ao mesmo tempo, o que é muito problemático e. não é fácil de sincronizar; se A atualização usa um método com um corpo de método, portanto, a classe de implementação não precisa ser modificada adicionalmente. Se forem necessárias modificações, elas também podem ser modificadas por reescrita.

  • Para definir métodos padrão na interface, você precisa usar palavras-chave padrão Asseio.
  • Formato: tipo de valor de retorno padrão público nome do método (lista de parâmetros) { }
  • Exemplo: público padrão void show() { }
  • Os métodos padrão não são métodos abstratos e não precisam ser substituídos. Mas se for reescrito, a palavra-chave padrão deverá ser removida ao reescrever.
  • public pode ser omitido, mas default não pode ser omitido.
  • Se múltiplas interfaces forem implementadas e houver métodos padrão com o mesmo nome em múltiplas interfaces, então a subclasse deverá substituir o método (não substituir causará conflitos).

Interface Inter1:

package oopInterface5;

public interface Inter1 {
    public abstract void method();
    public default void default_method() {
        System.out.println("Inter1接口中的默认方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

Interface Inter2:

package oopInterface5;

public interface Inter2 {
    public default void default_method() {
        System.out.println("Inter2接口中的默认方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Os dois métodos padrão têm o mesmo nome. Se a classe de implementação implementar essas duas interfaces ao mesmo tempo, esse método padrão deverá ser reescrito!

package oopInterface5;

public class InterImpl implements Inter1, Inter2 {

    @Override
    public void method() {
        System.out.println("抽象方法的实现");
    }

    @Override
    public void default_method() {
        System.out.println("重写接口中的默认方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

Aula de teste:

package oopInterface5;

public class Test {
    public static void main(String[] args) {
            InterImpl ii = new InterImpl();
            ii.method();				//抽象方法的实现
            ii.default_method();		//重写接口中的默认方法
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
5.1.2 Métodos estáticos em interfaces

JDK8 e posteriores permitirão que métodos estáticos sejam definidos em interfaces, que precisam ser modificadas com estática.
na interfacemétodo estáticoO formato de definição é:

  • tipo de valor de retorno estático público nome do método (lista de parâmetros) { }
  • Exemplo: public static void show() { }

Coisas a serem observadas sobre métodos estáticos em interfaces:

  • Métodos estáticos só podem passarNome da interfaceChamado, não pode ser chamado por meio do nome da classe de implementação ou do nome do objeto.
  • public pode ser omitido, static não pode ser omitido.

Escreva uma interface:

package oopInterface6;

public interface Inter {
    public abstract void method();

    public static void static_method() {
        System.out.println("接口中的静态方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Escreva uma classe de implementação. Também existe um método estático na classe com o mesmo nome do método na interface, mas isso não é substituído porque os métodos estáticos não podem ser substituídos:

package oopInterface6;

public class InteImpl implements Inter {
    @Override
    public void method() {
        System.out.println("重写接口中的抽象方法");
    }

    //这不叫重写
    public static void static_method() {
        System.out.println("我不是重写的Inter接口中的静态方法");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

Mas, na verdade, os dois são métodos diferentes.

package oopInterface6;

public class Test {
    public static void main(String[] args) {
        InteImpl ii = new InteImpl();
        ii.method();						  //重写接口中的抽象方法
        Inter.static_method();               //调用接口中的静态方法
        InteImpl.static_method();           //调用实现类中的一个同名的静态方法
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

5.2 Novos métodos na interface inicial do JDK9

5.2.1 Definir métodos privados na interface
  • Formato 1: tipo de valor de retorno privado nome do método (lista de parâmetros) { }
  • Exemplo 1: private void show() { }
  • Uso: Sirva o método padrão.
package oopInterface7;

public interface InterA {
    public default void show1() {
        System.out.println("show1开始执行");
        show3();
    }

    public default void show2() {
        System.out.println("show2开始执行");
        show3();
    }

    //普通的私有方法,给默认方法服务的
    private void show3() {
        System.out.println("记录程序在运行过程中的各种细节,这里有100行代码。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • Formato 2: tipo de valor de retorno estático privado nome do método (lista de parâmetros) { }
  • Exemplo 2: método private static void() { }
  • Uso: Servir métodos estáticos.
package oopInterface7;

public interface InterB {
    public static void show1() {
        System.out.println("show1开始执行");
        show3();
    }

    public static void show2() {
        System.out.println("show2开始执行");
        show3();
    }

    //普通的私有方法,给静态方法服务的
    private static void show3() {
        System.out.println("记录程序在运行过程中的各种细节,这里有100行代码。");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

6. Aplicação de interface

1. Interface representa regras e é uma abstração de comportamento. Se você deseja que uma classe tenha um comportamento, deixe a classe implementar a interface correspondente.
2. Quando o parâmetro de um método é uma interface, a interface pode ser passadaTodos os objetos da classe de implementação, essa abordagem é chamada de polimorfismo de interface.

7. Padrão de design do adaptador

  • Design Pattern é um conjunto de experiências de design de código classificadas e catalogadas que são usadas repetidamente e conhecidas pela maioria das pessoas. O objetivo do uso de padrões de projeto é reutilizar o código, torná-lo mais fácil de ser entendido por outras pessoas, garantir a confiabilidade do código e a capacidade de reutilização do programa.

Adaptadores podem ser usados ​​para simplificar o código e evitar os inconvenientes causados ​​quando há muitos métodos abstratos na interface e só precisamos usar parte deles.
As etapas de escrita são geralmente:
1. Escreva a classe intermediária XXXAdapter para implementar a interface correspondente.
2. Implemente implementações vazias de métodos abstratos na interface.
3. Deixe a classe de implementação real herdar a classe intermediária e reescrever os métodos necessários.
4. Para evitar que outras classes criem objetos da classe do adaptador, a classe do adaptador intermediário é decorada com abstrato.

interface:

package AdapterDesignPattern;

public interface Inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Classe do adaptador:

package AdapterDesignPattern;

public abstract class InterAdapter implements Inter {
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

Classe de implementação:

package AdapterDesignPattern;

public class InterImpl extends InterAdapter {
    //我需要用到哪个方法,就重写哪个方法就可以了
    @Override
    public void method5() {
        System.out.println("只要用第五个方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10