Introduction aux interfaces Java et aux classes abstraites (exemples de code)

Cet article vous présente une introduction aux interfaces Java et aux classes abstraites (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Interface :

(1)Les variables définies dans l'interface sont de type public static final, que ces modificateurs soient explicitement qualifiés ou non, et doivent être explicitement initialisées, sinon une erreur est signalée :

public interface Interface1 {
    /**
     * VARIABLE1显式添加public static final修饰符
     * VARIABLE2隐式含有public static final修饰符
     */
    public static final String VARIABLE1="AAA";
                        String VARIABLE2="BBB";
    
    /**
     * VARIABLE3未显式初始化，代码变异报错:
     * The blank final field VARIABLE3 may not have been initialized
     */
    String VARIABLE3;                    
}

(2) Les méthodes définies dans l'interface sont des méthodes abstraites, c'est-à-dire qu'elles ne contiennent pas toute implémentation de méthode :

a. Si la classe qui implémente l'interface est une classe normale (classe non abstraite), toutes les méthodes de l'interface doivent être implémentées, sinon une erreur de compilation sera signalée ;

b. Si la classe qui implémente l'interface S'il s'agit d'une classe abstraite, vous ne pouvez implémenter que certaines méthodes de l'interface, sinon une exception sera levée

public interface Interface2 {
    /**
     * method1方法定义显式添加public abstract修饰符
     * method2方法隐式含有public abstract修饰符，两个方法都是抽象方法
     */
    public abstract String method1();
                    String method2();
}

/**
 * 普通类Class1实现Interface2接口,必须实现所有接口方法
 *
 */
public class Class1 implements Interface2 {

    @Override
    public String method1() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public String method2() {
        // TODO Auto-generated method stub
        return null;
    }

}

/**
 * 抽象类Class2实现Interface2接口,可以只实现方法method1
 */
public abstract class Class2 implements Interface2 {

    @Override
    public String method1() {
        // TODO Auto-generated method stub
        return null;
    }

}

Cours abstrait :

( 1)

La classe abstraite est aussi une classe, et comme les classes ordinaires, elle peut avoir des variables ordinaires, les méthodes avec implémentation peuvent avoir des constructeurs, mais elles ne peuvent pas être instanciées et ne peuvent être utilisées que pour hériter Les méthodes ordinaires doivent avoir des corps de méthode, et les méthodes abstraites ne peuvent pas avoir de corps de méthode

public abstract class AbstractClass1 {
    String variable1;//普通变量
    public static final String VARIABLE2="AAA";//定义静态常量
    public void method1(){  }//普通方法，必须有方法体
    abstract void method2();//抽象方法，不能有方法体
    
    AbstractClass1(){//可以定义构造函数，但抽象类不能实例化，只能被继承
        System.out.println("此为构造函数");
    }
}

Il existe une autre plus grande différence entre les interfaces et les classes abstraites ; 🎜>Une classe peut implémenter plusieurs interfaces, mais ne peut hériter que d'une seule classe

;

Dans les applications pratiques, les interfaces sont les plus couramment utilisées. Si les implémentations de plusieurs interfaces ont des parties communes, vous pouvez envisager d'en extraire. cette partie dans une classe abstraite puis héritant de la classe abstraite. En d’autres termes, les classes abstraites permettent l’implémentation de méthodes publiques, qui peuvent être rapidement développées et gérées de manière uniforme, et permettent à votre classe d’implémenter pleinement toutes ses propres méthodes sans problèmes de couplage étroit.

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!