Primeiro, vamos falar sobre o final.
A palavra -chave final pode modificar variáveis, métodos e classes .
Variável final:
precisar:
Preciso de uma constante de tempo de compilação que nunca mude
2 Um valor inicializado em tempo de execução, não querendo ser alterado
Benefícios: Computação executada no momento da compilação, reduzindo o ônus do tempo de execução
Extensões:
Você pode modificar tipos básicos e objetos de referência. Ao modificar o tipo básico, significa que o valor é bastante constante. Ao modificar uma referência de objeto, uma vez que a referência é inicializada e apontada para um objeto, ele não pode ser alterado para outro objeto (o próprio objeto pode ser modificado)
Em branco final
O domínio que é modificado por final, mas não fornece o valor inicial, deve receber um valor para o final usando uma expressão na definição ou construtor de domínio (o final deve ser inicializado antes do uso)
Perceber:
Se um objeto for modificado por estático e final ao mesmo tempo (constante do período de compilação), ele geralmente é expresso no capital e os parâmetros de modificação de palavras de link sublinhado:
Se o parâmetro final de modificar, significa que o parâmetro é legível, mas não poderá ser modificado.
Exemplo de uso:
Rand aleatório privado = novo aleatório (); Randomal aleatório estático privado = novo aleatório (); private final int n1 = 12; Private Final Int Number = Rand.NextInt (30); private estático final int number2 = aleatom.nextint (40); @Test public void finalDatatest () {System.out.println (n1); System.out.println ("---------------------------------"); System.out.println (Rand.NextInt (30)); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- * @param sk * @return */public string finalParam (string final sk) {// sk = "jeyson"; Método final:
Final também pode modificar o método, indicando que o método não pode ser herdado por subclasses.
Benefícios do uso da final:
1 Antes de JDK1.5, a eficiência foi maior e, após o JDK1.5, pode ser ignorado
2 O bloqueio do método para garantir que o significado do método na subclasse permaneça inalterado e não pode ser substituído. Exemplo de uso:
public final String finalMethod () {return "Hello World"; } Classe final:
Se você não deseja ser herdado por nenhuma classe, pode usar o Final para modificar o exemplo de uso da classe:
Public Final Class finalClasStx {private int k; public void getMyword () {System. out .println ("Esta é uma classe final, o valor de k é" +getk ()); } public int getk () {return k;} public void setk (int k) {this .k = k;}} Então a palavra -chave transitória:
O transitório pode modificar apenas variáveis, indicando que a variável não pode ser serializada.
Geralmente, herdamos a classe de interface serializável e a serialização será realizada automaticamente. Quando a variável modificada por transiente é serializada, ela não será serializada para o destino especificado.
então,
1 A variável modificada pelo transiente não faz mais parte da persistência do objeto, e o conteúdo da variável é serializado e não pode ser acessado.
2 transitórios só pode modificar variáveis, não métodos e classes
3 Exemplo de uso de uma variável estática que não pode ser serializada, independentemente de ser modificado por transitório:
classe pública transientEx {public static void main (string [] args) {user user = new user (); user.setUserName ("jeyson"); user.setPassword ("123456"); System.out.println ("Antes da serialização:"); System.out.println ("userName ="+user.getUserName ()); System.out.println ("senha ="+user.getpassword ()); // serialização try {objectOutputStream OS = new ObjectOutputStream (new FileOutputStream ("c: //myresource//test1.txt"); OS.WriteObject (Usuário); os.flush (); os.close (); } catch (Exceção e) {e.printStackTrace (); } // Deserialização try {objectInputStream IS = new ObjectInputStream (new FileInputStream ("c: //myResource//test1.txt"); usuário = (usuário) is.readObject (); is.close (); System.out.println ("序列化后 ：:"); System.out.println ("userName ="+user.getUserName ()); System.out.println ("senha ="+user.getpassword ()); } catch (Exceção e) {e.printStackTrace (); } System.out.println ("--------------------------------"); }} classe o usuário implementa serializável {private estático final serialversionuid = 1L; Nome de usuário privado de string; // Use senha de string transitória transitória transitória; public String getUserName () {return Username; } public void setUserName (string userName) {this.username = nome de usuário; } public string getPassword () {return senha; } public void setPassword (string senha) {this.password = senha; }} Extensão: externizável
A classe que implementa a interface serializável é implementada; portanto, a serialização implementará automaticamente a classe que implementa a interface externiazble. Nada pode ser serializado automaticamente e se o uso transitório não tem efeito no resultado.
Se for necessária serialização, você precisará especificar manualmente a variável a ser serializada no método WriteExternal.
Exemplo de uso:
classe pública externalizablex implementa externizable {private transitório string name = "ssss"; @Override public void ReadExternal (ObjectInput in) lança IoException, classNotFoundException {name = (String) in.readObject (); } @Override public void writeExternal (objectOutput out) lança IoException {out.WriteObject (nome); } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public static void main (string [] args) {externalizable ex = new externalizableEx (); ex.setName ("jeyson"); System.out.println ("serialização externazável:"); System.out.println (ex.getName ()); // serialização try {objectOutputStream OS = new ObjectOutputStream (new FileOutputStream (new File ("c: //myResource//test2.txt")); OS.WriteObject (Ex); os.flush (); os.close (); } catch (Exceção e) {e.printStackTrace (); } // Deserializando try {objectInputStream IS = new ObjectInputStream (new FileInputStream (new File ("c: //myresource//test2.txt"))); ex = (externalizableEx) is.readObject (); is.close (); System.out.println ("serialização externazável:"); System.out.println (ex.getName ()); } catch (Exceção e) {e.printStackTrace (); }}} declaração:
A maior parte da final vem da quarta edição de "Java Programming Thoughts"
Artigo de referência: //www.vevb.com/article/86996.htm
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.