Java-Verbesserung Kapitel (14) -----Schlüsselwort final

Bei der Programmierung hoffen wir manchmal, dass bestimmte Daten nicht geändert werden können. Zu diesem Zeitpunkt kommt das Finale ins Spiel. Final ist ein Schlüsselwort in Java und bedeutet „Dieser Teil kann nicht geändert werden“. Es gibt zwei Gründe, sich nicht verändern zu wollen: Effizienz und Design. Es gibt drei Situationen, in denen final verwendet wird: Daten, Methoden und Klassen.

1. Endgültige Daten

Ja Die Konstanz der Daten ist sehr nützlich, wenn es darum geht, das System zur Laufzeit zu entlasten. Diese konstanten Daten kann ich „Konstanten“ nennen. „Konstante“ wird hauptsächlich an den folgenden zwei Stellen verwendet:

            1. Kompilierungszeitkonstanten können niemals geändert werden.

2. Bei der Initialisierung zur Laufzeit hoffen wir, dass es nicht verändert wird.

Konstanten zur Kompilierungszeit wurden während des Klassenladevorgangs initialisiert und können daher nach Abschluss des Klassenladens nicht mehr geändert werden während der Kompilierungszeit Es wird in jede Berechnungsformel eingesetzt, die es verwendet, was bedeutet, dass die Berechnungsformel zur Kompilierungszeit ausgeführt werden kann. Natürlich können für Konstanten zur Kompilierungszeit nur Basistypen verwendet werden, und diese müssen bei der Definition initialisiert werden.

Einige Variablen sollen sich je nach Objekt unterschiedlich verhalten, aber gleichzeitig möchten wir nicht, dass sie sich zu diesem Zeitpunkt ändern Wir können die Laufzeitkonstante verwenden. Bei Laufzeitkonstanten kann es sich entweder um einen Basisdatentyp oder einen Referenzdatentyp handeln. Das Unveränderliche an einem Basisdatentyp ist sein Inhalt, während das Unveränderliche an einem Referenzdatentyp seine Referenz ist und der Inhalt des durch die Referenz angegebenen Objekts veränderbar ist.

public class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

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

public class FinalTest {
    private final String final_01 = "chenssy";    //编译期常量，必须要进行初始化，且不可更改
    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
    
    private static Random random = new Random();
    private final int final_03 = random.nextInt(50);    //使用随机数来进行初始化
    
    //引用
    public final Person final_04 = new Person("chen_ssy");    //final指向引用数据类型
    
    FinalTest(String final_02){
        this.final_02 = final_02;
    }
    
    public String toString(){
        return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
               "   final_04 = " + final_04.getName();
    }
    
    public static void main(String[] args) {
        System.out.println("------------第一次创建对象------------");
        FinalTest final1 = new FinalTest("cm");
        System.out.println(final1);
        System.out.println("------------第二次创建对象------------");
        FinalTest final2 = new FinalTest("zj");
        System.out.println(final2);
        System.out.println("------------修改引用对象--------------");
        final2.final_04.setName("chenssy");
        System.out.println(final2);
    }
}

------------------
Output:
------------第一次创建对象------------
final_01 = chenssy   final_02 = cm   final_03 = 34   final_04 = chen_ssy
------------第二次创建对象------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chen_ssy
------------修改引用对象--------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chenssy

    Der einzige Punkt, der hier erklärt wird, ist: Denken Sie nicht, dass Sie ihren Wert zum Zeitpunkt der Kompilierung kennen können. Hier werden Zufallszahlen für die Initialisierung verwendet zur Laufzeit bekannt.

2. Endgültige Methode

Alle mit final gekennzeichneten Methoden können nicht vererbt oder geändert werden, daher der erste Grund für die Verwendung Eine letzte Methode ist die Methodensperre, um zu verhindern, dass Unterklassen sie ändern. Was den zweiten Grund betrifft, nämlich die Effizienz, verstehe ich dieses Effizienzproblem nicht ganz genau. Ich habe diesen Abschnitt aus dem Internet entnommen: Wenn Sie in der frühen Implementierung von Java eine Methode als endgültig angeben, stimmen Sie dem zu Alle Aufrufe dieser Methode werden in Inline-Aufrufe umgewandelt. Wenn der Compiler einen endgültigen Methodenaufrufbefehl findet, überspringt er nach sorgfältigem Ermessen die normale Aufrufmethode zum Einfügen von Programmcode und führt den Methodenaufrufmechanismus aus (Parameter auf den Stapel verschieben, zur Ausführung zum Methodencode springen usw.). Springen Sie zurück und bereinigen Sie die Parameter auf dem Stapel, verarbeiten Sie den Rückgabewert und ersetzen Sie den Methodenaufruf durch eine Kopie des tatsächlichen Codes im Methodenkörper. Dadurch entfällt der Aufwand für Methodenaufrufe. Wenn eine Methode groß ist, bläht sich Ihr Programmcode natürlich auf und Sie sehen die Leistungssteigerungen durch Inlining möglicherweise nicht, da die Leistungssteigerungen um die Zeit reduziert werden, die innerhalb der Methode verbracht wird.

Ich verstehe diese Passage nicht sehr gut, also habe ich sie kopiert. Kann dieser Java-Experte es erklären? !

Die endgültige Methode der übergeordneten Klasse kann nicht von der untergeordneten Klasse überschrieben werden, was bedeutet, dass die untergeordnete Klasse nicht dieselbe Methode wie die übergeordnete Klasse haben kann. .

public class Custom extends Person{
    public void method1(){
        System.out.println("Person's  method1....");
    }
    
//    Cannot override the final method from person：子类不能覆盖父类的final方法
//    public void method2(){
//        System.out.println("Person's method2...");
//    }
}

3. Abschlussklasse

 Wenn eine Klasse mit „final“ geändert wird, bedeutet dies, dass es sich bei der Klasse um die letzte Klasse handelt und sie nicht möchte oder anderen erlaubt, sie zu erben. Bei der Programmierung erlauben wir aus Sicherheits- oder anderen Gründen keine Änderungen an dieser Klasse und möchten nicht, dass sie Unterklassen hat. Zu diesem Zeitpunkt können wir final verwenden, um die Klasse zu ändern.

对于final修饰的类来说，它的成员变量可以为final，也可以为非final。如果定义为final，那么final数据的规则同样适合它。而它的方法则会自动的加上final，因为final类是无法被继承，所以这个是默认的。

       四、 final参数

       在实际应用中，我们除了可以用final修饰成员变量、成员方法、类，还可以修饰参数、若某个参数被final修饰了，则代表了该参数是不可改变的。

       如果在方法中我们修改了该参数，则编译器会提示你：The final local variable i cannot be assigned. It must be blank and not using a compound assignment。

public class Custom {
    public void test(final int i){
      //i++;     ---final参数不可改变
        System.out.println(i);
    }
    
    public void test(final Person p){
     //p = new Person();    --final参数不可变
     p.setName("chenssy");
    }
}

       同final修饰参数在内部类中是非常有用的，在匿名内部类中，为了保持参数的一致性，若所在的方法的形参需要被内部类里面使用时，该形参必须为final。详情参看：http://www.php.cn/。

       五、final与static

       final和static在一起使用就会发生神奇的化学反应，他们同时使用时即可修饰成员变量，也可修饰成员方法。

       对于成员变量，该变量一旦赋值就不能改变，我们称它为“全局常量”。可以通过类名直接访问。

       对于成员方法，则是不可继承和改变。可以通过类名直接访问。

以上就是java提高篇（十四）-----关键字final 的内容，更多相关内容请关注PHP中文网（www.php.cn）！