Ключевое слово JAVA Final используется для изменения данных, методов или классов, что обычно означает «неизменяемый», то есть данные не могут быть изменены, методы не могут быть переопределены, а классы не могут быть унаследованы. Обычно есть две причины для использования Final: дизайн и эффективность. По мере обновления версии JAVA некоторые проблемы эффективности могут решаться с помощью компилятора и JVM. Поэтому использование Final для решения проблем эффективности не так важно.
Модификатор Final чаще всего используется в полях примитивных типов данных или неизменяемых классов (если все методы класса не изменяют его объект, этот класс является неизменяемым классом. String — неизменяемый класс).
【Окончательные данные】
Ключевое слово Final используется для изменения данных в двух основных ситуациях:
1. Константы времени компиляции
2. Значения, инициализируемые во время выполнения
Для констант времени компиляции это относится к полю, которое является одновременно окончательным и статическим (согласно соглашению, константы времени компиляции именуются заглавными буквами, а каждое слово отделяется подчеркиванием). не может быть изменено. Компилятор может подставлять константы времени компиляции в любую формулу расчета, которая может ее использовать. Другими словами, формула расчета может выполняться во время компиляции, что относительно снижает нагрузку во время выполнения. Константе времени компиляции должно быть присвоено значение при ее определении (не обязательно базового типа).
Для значений, инициализированных во время выполнения, для базовых типов Final делает значение неизменяемым; для ссылок на объекты Final делает ссылку неизменяемой, то есть ее нельзя изменить, чтобы она указывала на другой объект. Однако сам объект можно изменить ( применимо к массивам, массивы также являются объектами).
частная статическая окончательная строка TESTD = «тест»;
public static Final String TESTE = "тест";
public static Final String[] TESTF = {"1","2"} //Небазовый тип;
частная статическая окончательная строка [] TESTG = новая строка [2];
public static void main(String args[]){
окончательный int testA = 1;
окончательная строка testB = "тест";
окончательный int[] testC = {1,1,2,};
System.out.println(testC[1]);
тестC[1] = 123;
System.out.println(testC[1]);
}
}
JAVA позволяет генерировать неназначенные конечные поля, но последнее поле должно быть назначено при определении поля или в каждом конструкторе (столько конструкторов, сколько имеется), чтобы гарантировать его инициализацию перед использованием. Таким образом, Final можно использовать более гибко. В одном классе разным объектам можно присваивать разные значения, сохраняя при этом неизменяемые характеристики.
общественный javaBlankFinal() {
пусто = 2011;
}
общественный javaBlankFinal (int temp) {
пусто = 2012;
}
общественный javaBlankFinal (String temp) {
пусто = 2014;
}
public static void main(String args[]){
новый javaBlankFinal();
}
}
Есть две причины для использования финального метода: одна — заблокировать метод, чтобы предотвратить его перезапись, и гарантировать, что поведение метода останется неизменным во время наследования, другая — преобразовать вызовы метода во встраиваемые вызовы, чтобы снизить стоимость метода; звонки. Однако в последних версиях JVM может оптимизировать себя, поэтому нет необходимости использовать финальные методы для решения проблем с эффективностью.
Что касается финального метода, следует отметить ещё одну вещь: все приватные методы в классе неявно обозначены как финальные методы (к ним также можно добавить финальную модификацию, но это бессмысленно). Когда вы пытаетесь переопределить приватный метод, компилятор не сообщает об ошибке, но на самом деле вы не перезаписываете метод, а просто генерируете новый метод. Поскольку внешний класс не может получить доступ к частному методу, его, конечно, нельзя переопределить.
Использование аннотации @Override может предотвратить вышеуказанные проблемы. Как показано в программе:
частный финал void FinalFunctionB(){
System.out.println("finalFunctionB");
}
окончательный недействительный FinalFunctionC () {
System.out.println("finalFunctionC");
}
недействительная функцияD(){}
}
класс overrideFinalFunction расширяет FinalFunction{
//@Override Добавьте аннотацию @Override, чтобы определить, является ли это переопределением
общественная недействительность FinalFunctionA () {
System.out.println("переопределить FinalFunctionA");
}
публичный финал void FinalFunctionB(){
System.out.println("переопределить FinalFunctionB");
}
//final void FinalFunctionC(){} //Невозможно переопределить последний метод из FinalFunction
@Override
void functionD(){} //Реальный метод переопределения
}
публичный класс javaFinalFunction расширяет FinalFunction {
public static void main(String args[]){
FinalFunction ff = новая FinalFunction();
//ff.finalFunctionA(); //Невозможно вызвать частный метод
//ff.finalFunctionB();
overrideFinalFunction off = новая overrideFinalFunction();
off.finalFunctionA(); //публичный метод
off.finalFunctionB();
}
}
Финальные классы обычно используются по соображениям проектирования, которые не позволяют наследовать класс. Это гарантирует, что поведение класса не изменится, а также позволит избежать некоторых угроз безопасности. Все методы в классе Final неявно обозначены как конечные методы и поэтому не могут быть переопределены (поскольку конечный класс запрещает наследование, методы в его классе не могут быть переопределены). В базовом API Java существует множество примеров применения метода Final, например java.lang.String. Укажите Final для класса String, чтобы предотвратить перезапись таких методов, как length().
Что касается финальных полей, даже если класс объявлен как окончательный, поля в классе не станут автоматически окончательными полями.
общественный класс javaFinalClass {
public static void main(String args[]){
FinalClass fc = новый FinalClass();
System.out.println(fc.testA);
FC.testA = 2012;
System.out.println(fc.testA);
}
}