Em Java, os blocos de código são chamados de blocos de código e os blocos de código podem ser divididos nos quatro tipos a seguir:
1. Introdução
1. Bloco de código normal:
Método corpo do método na aula
2. Construa o bloco de código :
O construtor é chamado quando o objeto é criado e é chamado toda vez que for criado, tendo precedência sobre a execução do construtor de classe.
3. Bloco de código estático:
Um trecho de código embrulhado em estático {} será executado apenas uma vez. Os blocos de código estático têm precedência sobre a execução do bloco de construção.
4. Sincronize o bloco de código:
Usando os blocos de código Synchronized () {} envolvidos, em um ambiente multi-thread, leia e grava operações em dados compartilhados precisam ser mutuamente exclusivos, caso contrário, levará à inconsistência de dados. Os blocos de código síncrono precisam ser gravados no método.
2. Similaridades e diferenças entre blocos de código estático e blocos de código construídos
Similaridades: todas as JVMs carregam a classe e executam antes que o construtor seja executado. Vários podem ser definidos na classe. Geralmente, algumas variáveis estáticas são atribuídas no bloco de código.
Diferença: os blocos de código estático são executados antes dos blocos de código não estáticos. Os blocos de código estático são executados apenas uma vez no primeiro novo e não são executados posteriormente. Em vez disso, os blocos de código não estáticos são executados uma vez todos os novos.
Três. Exemplo
Bloco de código comum: {} que aparece em um método ou instrução é chamado de bloco de código normal. A ordem de execução dos blocos de código ordinária e declarações gerais é determinada pela ordem em que aparecem no código, primeiro aparecem primeiro.
classe pública teste {public static void main (string [] args) {{int x = 3; System.out.println ("variável x =" + x); } int x = 1; System.out.println ("variável x =" + x); {int y = 7; System.out.println ("variável y =" + y); }}} / * * Execute a variável de resultado x = 3 no bloco de código comum * variável x = 1 no método principal * variável y = 7 no bloco de código comum * /Bloco de código de construção: um bloco de código que é definido diretamente na classe e não possui uma palavra -chave estática é chamado de bloco de código de construção {}. O bloco de código do construtor é chamado ao criar um objeto e, cada vez que o objeto é criado, ele é chamado e a ordem de execução do bloco de código do construtor tem precedência sobre o construtor de classe. Se houver vários blocos de código construídos, a ordem de execução será determinada pela ordem em que eles aparecem no código, aparece primeiro a primeira execução.
public class Test1 {{System.out.println ("primeiro bloco de construção");} public test1 (int i) {System.out.println ("th" + i + "sub-call" + "construtor");} {System.out.println (segundo bloco de construção "); Test1 (2);}}/** Resultado da execução Primeiro bloco de construção* Segundo bloco de construção* 0th Call Constructor* Primeiro bloco de construção* Segundo bloco de construção* Primeiro bloco de construção* Primeiro bloco de construção* Primeiro bloco de construção* Segundo bloco de construção* A segunda chamada para construir o método*/Bloco de código estático: um bloco de código declarado usando a palavra -chave estática em Java. Os blocos estáticos são usados para inicializar as classes e inicializar os atributos da classe. Cada bloco de código estático será executado apenas uma vez. Como a JVM executa os bloqueios de código estático ao carregar a classe, os blocos de código estático são executados antes do método principal.
Se a classe contiver vários blocos de código estático, ela será executada primeiro, o código definido será executado posteriormente.
Perceber:
1. Os blocos de código estático não podem existir em nenhum corpo de método.
2. Os blocos de código estático não podem acessar diretamente variáveis de instância e métodos de instância e precisam ser acessados através do objeto de instância da classe.
public class Test3 {public static string static_field = "atributo estático"; // estático estático {System.out.println (static_field); System.out.println ("Código estático Bloco 1");} public string field = "não-estático"; // bloqueio não-estático {System.out.printlnnnnnnnnnnnnnnnnn (não-estático "; // Systemtic Block {System.out.Printlnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn; 2 ");} public initoderTest () {System.out.println (" nenhum construtor de parâmetros ");} public static void main (string [] args) {initodertest test = new initoderTest ();} // bloqueio não-estáático {System.out.println (field); System.out.Printlnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn/" bloqueio não-static {System.out.println (field); {System.out.println (static_field); system.out.println ("Código estático Bloco 2");}}/** Execute o atributo estático do resultado* Código estático Bloco 1* Atributo estático* Código estático Bloco 2* Bloco de código não estático*O código a seguir demonstra a relação prioritária entre os blocos de código individual de criar um objeto e chamar um método:
public class Pessoa {static {System.out.println ("1. Sou um bloco estático, que tem precedência sobre a execução do bloco de construção! E ele apenas executa uma vez quando o primeiro objeto é criado!");} {System.out.println ("2. Eu sou um construtor, que é criado, que é criado, que é criado. function1 () {System.out.println ("Sou um bloco de código normal em um método não estático, que tem precedência quando o método é chamado!");} public static void function2 () {System.out.println ("Eu sou um bloco de código normal em um método estático.Classe de teste:
classe pública hellowrold {public static void main (string [] args) {new Person (). function1 (); novo Person().function1();System.out.println("================================================================================== ================================================================ ================================================================ =============================================================== ================================================================ ================================================================ ================================================================Resultados em execução:
Podemos ver que os blocos estáticos são sempre executados primeiro e serão executados apenas uma vez quando a primeira instância da classe for criada; O segundo é o bloco construtor; e o terceiro é o método do construtor.
Resumir
O exposto acima é sobre a explicação detalhada dos quatro blocos de código em Java, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!