O papel do uso do final para modificar parâmetros em java
Adicionar a palavra -chave final antes dos parâmetros do método é impedir que os dados sejam modificados no peso do método.
Existem duas situações principais: primeiro, use final para modificar o tipo de dados básico; Segundo, use final para modificar o tipo de dados de referência.
No primeiro caso, modifique o tipo de dados básico, quando o valor do parâmetro não pode ser modificado no corpo do método, ou seja, ele não pode ser transferido. Caso contrário, a compilação não será aprovada.
O segundo caso é modificar o tipo de referência. No momento, o objeto referenciado pela variável do parâmetro não pode ser alterado. No entanto, para tipos de dados de referência, é perfeitamente bom modificar suas propriedades.
Portanto, se você deseja usar a palavra -chave final, use o tipo de dados básico, que é muito útil.
Variável final:
Use final para tipos básicos: é uma constante, o valor é constante e o valor permanece inalterado.
Use as referências finais para objeto: faça a constante de referência e, uma vez que a referência seja inicializada para apontar para um objeto, ela não pode ser alterada para apontar para outro objeto. No entanto, o próprio objeto pode ser modificado e o Java não fornece uma maneira de tornar constante qualquer objeto. Essa limitação também usa matrizes, que são objetos.
exemplo:
classe Valor {int i; Public Value (int i) {this.i = i; }} classe pública FinalData {private static aleatom Random = new Random (47); ID de string privado; public finalData (string id) {this.id = id; } private final Int ValueOne = 9; private estático final int vale_two = 99; public static final int vale_three = 39; private final int i4 = random.nextint (20); estático final int_5 = random.nextInt (20); Valor privado v1 = novo valor (11); Valor final privado v2 = novo valor (22); Valor final estático privado val_3 = novo valor (33); private final int [] a = {1, 2, 3, 4, 5, 6}; public string tostring () {return id + ":" + "i4 =" + i4 + ", int_5 =" + int_5; } public static void main (string [] args) {finalData fd1 = new FinalData ("fd1"); //! fd1.valueOne ++; // Como o ValueOne é uma constante do tipo básico, seu valor é constante FD1.v2.i ++; // O conteúdo do objeto modificado por final pode ser alterado fd1.v1 = novo valor (9); for (int i = 0; i <fd1.a.length; i ++) fd1.a [i] ++; //! fd1.v2 = novo valor (0); // porque V2 é um tipo de referência modificado por final, sua referência não pode ser modificada para apontar para outro objeto //! fd1.val_3 = novo valor (1); // ocupa um espaço de memória que não pode ser alterado //! fd1.a = novo int [3]; // Final Modified Array System.out.println (FD1); System.out.println ("Criando novo FinalData"); FinalData fd2 = novo FinalData ("FD2"); System.out.println (fd1); System.out.println (fd2); }}/*saída: fd1: i4 = 15, int_5 = 18creating novo finalDatafd1: i4 = 15, int_5 = 18fd2: i4 = 13, int_5 = 18*/analisar:
Para FD1, FD2 Dois objetos, I4 é único, ou seja, cada objeto tem um I4, mas o INT_5 é declarado estático, ou seja, é compartilhado pela classe, FD1 e FD2 compartilham INT_5, que é inicializado no momento do carregamento, em vez de inicializar sempre que um novo objeto é criado (por exemplo, i4); Mas está definido como final ao mesmo tempo, portanto, sua referência é imutável, ou seja, não pode ser modificada para apontar para outro objeto.
Final em branco:
é declarado como final, mas não possui valor inicial fornecido. O final deve ser atribuído usando expressões na definição de domínio ou em cada construtor, e é por isso que o domínio final é sempre inicializado antes do uso.
Parâmetros finais:
Isso significa que você não pode alterar a referência do parâmetro no método para apontar para outro parâmetro, mas você pode modificar o que o objeto final aponta para
exemplo:
classe gizmo {int i = 0; public void spin () {}} public class FinalArguments {void com (final Gizmo g) {//! g = novo gizmo (); // A referência modificada por final não é modificada para apontar para outro objeto G.i ++; // mas o conteúdo apontado pelo objeto final pode ser modificado} vazio sem (gizmo g) {g = new Gizmo (); g.spin (); } // int g (final int i) {// //! i ++; // porque o parâmetro i é um valor constante //} int g (final int i) {return i + 1; } public static void main (string [] args) {FinalArguments bf = new FinalArguments (); bf.with (nulo); bf.with (nulo); }}analisar:
O parâmetro é declarado como final. Se for um parâmetro básico, é uma constante e não pode ser modificado; Se for uma variável de referência, não pode ser modificado para apontar para outro objeto, mas o conteúdo do objeto referido pela referência pode ser modificado.
Método Fianl:
Motivo de uso:
Todos os métodos privados da classe são especificados implicitamente como final e, como o método privado não pode ser usado, ele não pode ser substituído. Um modificador final pode ser adicionado ao método privado, mas isso não fornece nenhum significado adicional ao método.
exemplo:
classe WithFinalals {private final void f () {System.out.println ("withFinalals.f ()"); } private void g () {System.out.println ("substituindoprivate.f ()"); }} classe OverdingPrivate se estende com finais {private final void f () {System.out.println ("substituindoprivate.f ()"); }} classe OverdingPrivate2 estende o substituto de { /** ao usar a anotação de substituição para forçar o método f () para substituir o método f () da classe pai, um erro será relatado* porque não sabe se a classe pai tem o método. Para o método g (), ele apenas gera um novo método e * não substitui o método G () na classe pai. *///@Substitua public final void f () {System.out.println ("substituindoprivate2.f ()"); } public void g () {System.out.println ("substituindoprivate2.g ()"); }} classe pública FinalOverridingillusion {public static void main (string [] args) {substituindoprivate2 op2 = new OverdingPrivate2 (); op2.f (); op2.g (); // você pode transformar o substituto substituto op = op2; //! op.f (); // O método final na classe pai é invisível para a subclasse //! op.g (); Com finais wf = op2; // wf.f (); // wf.g (); }}/*output: domingprivate2.f () domingprivate2.g ()*/analisar:
Quando ocorre a cobertura:
1. Métodos que aparecem em subclasses exatamente iguais às das classes de pais
2. Uma subclasse pode ser transformada em uma classe pai para cima e chamar o método na classe pai
Se um método na classe pai for declarado como final ou privado, esse método será invisível para a subclasse. Mesmo que um método exatamente o mesmo que a classe pai seja criado na subclasse, este é um novo método, em vez de um método substituído da classe pai.
Classe final:
Ou seja, essa classe não pode ser herdada, seja você ou outras pessoas, essa classe não requer alterações, nem exige subclasses, como a classe String.
exemplo:
classe smallbrain {} classe final dinossaur {int i = 7; int j = 1; SmallBrain x = new SmallBrain (); void f () {}} // erro: o tipo não pode subclasse a classe final Dinosaur // classe de dinossauros não pode ter subclasses // classe estende ainda mais dinossauros {} public class Jurassic {public static void main (string [] args) {dinosaur n = new dinosaur (); nf (); ni = 40; n.j ++; }}Resumir
O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.