A palavra-chave JAVA final é usada para modificar dados, métodos ou classes, o que geralmente significa "inalterável", ou seja, os dados não podem ser alterados, os métodos não podem ser substituídos e as classes não podem ser herdadas. Geralmente há duas razões para usar o final: design e eficiência. À medida que a versão JAVA é atualizada, alguns problemas de eficiência podem ser resolvidos pelo compilador e pela JVM. Portanto, usar final para resolver problemas de eficiência não é tão importante.
O modificador Final é usado principalmente nos campos de tipos de dados primitivos ou classes imutáveis (se todos os métodos da classe não mudarem seu objeto, esta classe é uma classe imutável. String é uma classe imutável).
【dados finais】
Existem duas situações principais em que a palavra-chave Final é usada para modificar dados:
1. Constantes de tempo de compilação
2. Valores inicializados em tempo de execução
Para constantes de tempo de compilação, refere-se a um campo que é final e estático (de acordo com a convenção, as constantes de tempo de compilação são nomeadas com letras maiúsculas e cada palavra é separada por um sublinhado. Ocupa apenas um espaço de armazenamento que). não pode ser alterado. O compilador pode substituir constantes de tempo de compilação em qualquer fórmula de cálculo que possa utilizá-las. Ou seja, a fórmula de cálculo pode ser executada em tempo de compilação, o que reduz relativamente a carga de tempo de execução. Uma constante de tempo de compilação deve ter um valor atribuído a ela quando é definida (não necessariamente um tipo básico).
Para valores inicializados em tempo de execução, para tipos básicos, final torna o valor inalterável; para referências de objeto, final torna a referência inalterável, ou seja, não pode ser alterada para apontar para outro objeto, porém, o próprio objeto pode ser modificado (. aplicável a arrays, arrays também são objetos).
private static final String TESTD = "teste";
public static final String TESTE = "teste";
public static final String[] TESTF = {"1","2"} //Tipo não básico
String final estático privado[] TESTG = new String[2];
public static void main(String args[]){
final int testeA = 1;
string final testeB = "teste";
final int[] testeC = {1,1,2,};
System.out.println(testC[1]);
testeC[1] = 123;
System.out.println(testC[1]);
}
}
JAVA permite a geração de campos finais não atribuídos, mas o campo final deve ser atribuído na definição do campo ou em cada construtor (quantos construtores houver) para garantir que seja inicializado antes do uso. Desta forma, final pode ser usado de forma mais flexível. Na mesma classe, diferentes valores podem ser atribuídos a diferentes objetos, mantendo características imutáveis.
public javaBlankFinal(){
em branco = 2011;
}
public javaBlankFinal(int temp){
em branco = 2012;
}
public javaBlankFinal(String temp){
em branco = 2014;
}
public static void main(String args[]){
novo javaBlankFinal();
}
}
Existem duas razões para usar o método final: uma é bloquear o método para evitar que ele seja substituído e garantir que o comportamento do método permaneça inalterado durante a herança; a outra é converter chamadas de método em chamadas inlining para reduzir o custo do método; chamadas. Porém, em versões recentes, a JVM pode se otimizar, portanto não há necessidade de utilizar métodos finais para lidar com questões de eficiência.
Em relação ao método final, há outra coisa a ser observada. Todos os métodos privados na classe são implicitamente designados como métodos finais (você também pode adicionar modificações finais a eles, mas isso não faz sentido). Quando você tenta sobrescrever um método privado, o compilador não reporta erro, mas na verdade você não sobrescreve o método, apenas gera um novo método. Como o método privado não pode ser acessado por classes externas, é claro que não pode ser substituído.
Usar a anotação @Override pode evitar os problemas acima. Como mostrado no programa:
privado final void finalFunctionB(){
System.out.println("finalFunctionB");
}
final void finalFunctionC(){
System.out.println("finalFunctionC");
}
função nulaD(){}
}
classe overrideFinalFunction estende finalFunction{
//@Override Adicione a anotação @Override para identificar se é uma substituição
public void finalFunctionA(){
System.out.println("substituir finalFunctionA");
}
público final void finalFunctionB(){
System.out.println("substituir finalFunctionB");
}
//final void finalFunctionC(){} //Não é possível substituir o método final de finalFunction
@Substituir
void functionD(){} //Método de substituição real
}
classe pública javaFinalFunction estende finalFunction{
public static void main(String args[]){
funçãofinal ff = new funçãofinal();
//ff.finalFunctionA(); //Não é possível chamar o método privado
//ff.finalFunctionB();
overrideFinalFunction off = new overrideFinalFunction();
off.finalFunctionA();
off.finalFunctionB();
}
}
O uso de classes finais geralmente ocorre por motivos de design, que não permitem que a classe seja herdada. Isso garante que o comportamento da classe não mudará e também poderá evitar alguns riscos de segurança. Todos os métodos na classe Final são designados implicitamente como métodos finais e, portanto, não podem ser substituídos (como a classe final proíbe herança, os métodos em sua classe não podem ser substituídos). Na API principal do Java, há muitos exemplos de aplicação final, como java.lang.String. Especifique final para a classe String para evitar a substituição de métodos como length().
Para campos finais, mesmo que uma classe seja declarada final, os campos da classe não se tornarão automaticamente campos finais.
classe pública javaFinalClass{
public static void main(String args[]){
classefinal fc = new classefinal();
System.out.println(fc.testA);
fc.testeA = 2012;
System.out.println(fc.testA);
}
}