Analyse détaillée des interfaces JAVA et des classes abstraites

Cet article vous apporte des connaissances pertinentes sur java, qui organise principalement les problèmes liés aux interfaces et aux classes abstraites. Lorsque vous devez dériver une classe de plusieurs classes et hériter de toutes leurs propriétés et méthodes, JAVA Il n'est pas nécessaire d'utiliser des interfaces pour. implémentons l'héritage multiple. Jetons-y un coup d'œil. J'espère que cela sera utile à tout le monde.

Etude recommandée : "Tutoriel vidéo Java"

Interface

Vue d'ensemble

1. Lorsque vous devez dériver une classe de plusieurs classes, hériterde toutes leurs propriétés et méthodes, JAVA n'a pas d'héritage multiple Il doit être implémenté à l'aide d'interfaces
2. pour extraire certaines caractéristiques comportementales communes de plusieurs classes, et il n'y a pas de relation entre elles. Il doit également être implémenté à l'aide d'interfaces
3. L'essence des interfaces est. contrats et spécifications

Utiliser

1. Utiliser interface dans l'interface pour définir
2. L'interface et la classe sont deux structures différentes
3. Le constructeur ne peut pas être défini dans l'interface (il ne peut donc pas être instancié)
4. L'interface implémente des implémentations via des classes
5. Les classes JAVA peuvent implémenter plusieurs formats d'interface : la ​​classe AA étend l'interface BB CC, DD
6. Les interfaces peuvent être héritées les unes des autres et l'héritage multiple
7. les interfaces incarnent le polymorphisme

public class UsbTest {
    public static void main(String[] args) {
        Computer com =new Computer();
        Flash flash=new Flash();
        com.transferData(flash); // USB usb =new Flash()
        com.transferData(new Printer());
        /*
		* U盘开始工作
		* 传输数据
		* U盘结束工作
		* 打印机开始工作
		* 传输数据
		* 打印机结束工作
		* 
		* */
    }}class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("传输数据");
        usb.stop();
    }}interface USB{
    void start();
    void stop();}class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");

    }}class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作");

    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");

    }}

8. JDK8

• La méthode statique définie dans l'interface ne peut être appelée que via l'interface
• La méthode par défaut dans l'interface peut être implémentée via l'objet de la classe d'implémentation
• Si la sous-classe (ou la classe d'implémentation) hérite la classe parent et l'interface implémentée déclare une méthode avec le même nom et les mêmes paramètres. Si la sous-classe ne remplace pas cette méthode, la méthode avec le même nom et les mêmes paramètres dans la classe parent est appelée

public class JDK8Test {
    public static void main(String[] args) {
        SubClass sub =new SubClass();
        CompareA.methods1();
        sub.methods2();
        /*
        * Compare 北京
		* Compare 上海
        */
    }}class SubClass implements CompareA{}interface CompareA{
    public static void methods1() {
        System.out.println("Compare 北京");
    }
    public default void methods2() {
        System.out.println("Compare 上海");
    }}

Mode agent.

1. Le mode proxy consiste à fournir un proxy pour d'autres objets. Contrôler l'accès à cet objet
2. Instance

public class NetWorkTest {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server); // 放的是被代理对象进去
        proxyServer.browse(); // 调用的是代理对象，但结果是真实对象的方法被调用
        /*
        * 检查工作
		* 真实服务器访问网络
        */
    }}interface NetWork{
    void browse();}// 被代理类class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实服务器访问网络");
    }}// 代理类class ProxyServer implements NetWork{
    private NetWork work;
    public ProxyServer(NetWork work){
        this.work=work;
    }
    public void check(){
        System.out.println("检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }}

Classe interne

1. JAVA permet de déclarer une classe A dans une autre classe B, alors la classe A est une la classe interne et la classe B sont une classe externe
2. Classification de classe interne

• classe interne de membre
  • statique statique
  • non statique
• classe interne locale
  • méthode interne
  • bloc de code interne
  • dans le constructeur

3. instancier un objet de classe interne

public class InnerClassTest {
    public static void main(String[] args) {
        // 实例化Dog，静态类
        Pseson.Dog dog=new Pseson.Dog();
        dog.eat();
        // 吃骨头
        // 实例化Cat，非静态类
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        // 猫吃鱼
    }}class Pseson{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨头");
        }
    }
    class Cat{
        public void eat(){
            System.out.println("猫吃鱼");
        }
    }}

4. Appeler la structure de classe externe

public class InnerClassTest {
    public static void main(String[] args) {
        // 实例化Cat，非静态类
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        cat.display("小花");
        /*
        * 小花
        * 波斯猫
        * 人
        */ 
    }}class Pseson{
    String name="人";
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨头");
        }
    }
    class Cat{
        String name="波斯猫";
        public void eat(){
            System.out.println("猫吃鱼");
        }
        public void display(String name){
            System.out.println(name); // 方法中name
            System.out.println(this.name); // 内部类中name
            System.out.println(Pseson.this.name); // 外部类中name

        }
    }}

5. Même entre l'interface et la classe abstraite

•  : les deux contiennent des méthodes abstraites peuvent être héritées ;
Différence : la classe abstraite a un constructeur, l'interface n'a pas de constructeur ; les classes abstraites n'ont qu'un seul héritage, tandis que les interfaces peuvent avoir plusieurs héritages ; les interfaces implémentent l'implémentation

Apprentissage recommandé : "

Tutoriel vidéo Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!