Neste tutorial, aprenderemos sobre a palavra-chave estática do Java junto com métodos estáticos, variáveis estáticas e blocos estáticos com a ajuda de exemplos.
O que é uma palavra-chave estática em Java?
Em Java, se quisermos acessar os membros da classe, devemos primeiro criar uma instância da classe. Mas haverá situações em que queremos acessar os membros da classe sem criar nenhuma variável.
Nessas situações, podemos usar a staticpalavra - chave em Java. Se quisermos acessar os membros da classe sem criar uma instância da classe, precisamos declarar os membros da classe como estáticos.
A Mathclasse em Java tem quase todos os seus membros estáticos. Portanto, podemos acessar seus membros sem criar instâncias da classe Math. Por exemplo,
public class Main ( public static void main( String() args ) ( // accessing the methods of the Math class System.out.println("Absolute value of -12 = " + Math.abs(-12)); System.out.println("Value of PI = " + Math.PI); System.out.println("Value of E = " + Math.E); System.out.println("2^2 = " + Math.pow(2,2)); ) )
Produto :
Valor absoluto de -12 = 12 Valor de PI = 3,141592653589793 Valor de E = 2,718281828459045 2 2 = 4,0
No exemplo acima, não criamos nenhuma instância da Mathclasse. Mas podemos acessar seus métodos: abs()e pow()e variáveis: PIe E.
Isso é possível porque os métodos e variáveis da Mathclasse são estáticos.
Métodos estáticos
Os métodos estáticos também são chamados de métodos de classe. É porque um método estático pertence à classe e não ao objeto de uma classe.
E podemos invocar métodos estáticos diretamente usando o nome da classe. Por exemplo,
class Test ( // static method inside the Test class public static void method() (… ) ) class Main ( // invoking the static method Test.method(); )
Aqui, podemos ver que o método estático pode ser acessado diretamente de outras classes usando o nome da classe.
Em todo programa Java, declaramos o mainmétodo static. Isso ocorre porque, para executar o programa, a JVM deve ser capaz de chamar o método principal durante a fase inicial, onde nenhum objeto existe na memória.
Exemplo 1: métodos Java estáticos e não estáticos
class StaticTest ( // non-static method int multiply(int a, int b)( return a * b; ) // static method static int add(int a, int b)( return a + b; ) ) public class Main ( public static void main( String() args ) ( // create an instance of the StaticTest class StaticTest st = new StaticTest(); // call the nonstatic method System.out.println(" 2 * 2 = " + st.multiply(2,2)); // call the static method System.out.println(" 2 + 3 = " + StaticTest.add(2,3)); ) )
Produto :
2 * 2 = 4 2 + 3 = 5
No programa acima, declaramos um método não estático denominado multiply()e um método estático denominado add()dentro da classe StaticTest.
Dentro da classe Main, podemos ver que estamos chamando o método não estático usando o objeto da classe ( st.multiply(2, 2)). No entanto, estamos chamando o método estático usando o nome da classe ( StaticTest.add(2, 3)).
Variáveis Estáticas
Em Java, quando criamos objetos de uma classe, cada objeto terá sua própria cópia de todas as variáveis da classe. Por exemplo,
class Test ( // regular variable int age; ) class Main ( // create instances of Test Test test1 = new Test(); Test test2 = new Test(); )
Aqui, os objetos test1 e test2 terão cópias separadas da variável age. E, eles são diferentes uns dos outros.
No entanto, se declararmos uma variável estática, todos os objetos da classe compartilham a mesma variável estática. É porque, como os métodos estáticos, as variáveis estáticas também estão associadas à classe. E, não precisamos criar objetos da classe para acessar as variáveis estáticas. Por exemplo,
class Test ( // static variable static int age; ) class Main ( // access the static variable Test.age = 20; )
Aqui, podemos ver que estamos acessando a variável estática da outra classe usando o nome da classe.
Exemplo 2: Variáveis Java estáticas e não estáticas
class Test ( // static variable static int max = 10; // non-static variable int min = 5; ) public class Main ( public static void main(String() args) ( Test obj = new Test(); // access the non-static variable System.out.println("min + 1 = " + (obj.min + 1)); // access the static variable System.out.println("max + 1 = " + (Test.max + 1)); ) )
Produto :
mín + 1 = 6 máx + 1 = 11
No programa acima, declaramos uma variável não estática chamada min e uma variável estática chamada max dentro da classe Test.
Dentro da classe Main, podemos ver que estamos chamando a variável não estática usando o objeto da classe ( obj.min + 1). No entanto, estamos chamando a variável estática usando o nome da classe ( Test.max + 1).
Nota : Variáveis estáticas raramente são usadas em Java. Em vez disso, as constantes estáticas são usadas. Essas constantes estáticas são definidas por static finalpalavra-chave e representadas em maiúsculas. É por isso que algumas pessoas preferem usar maiúsculas também para variáveis estáticas.
Acessar variáveis e métodos estáticos dentro da classe
Estamos acessando a variável estática de outra classe. Portanto, usamos o nome da classe para acessá-la. No entanto, se quisermos acessar o membro estático de dentro da classe, ele pode ser acessado diretamente. Por exemplo,
public class Main ( // static variable static int age; // static method static void display() ( System.out.println("Static Method"); ) public static void main(String() args) ( // access the static variable age = 30; System.out.println("Age is " + age); // access the static method display(); ) )
Produto :
Idade é 30 Método Estático
Aqui, podemos acessar a variável estática e o método diretamente, sem usar o nome da classe. É porque variáveis e métodos estáticos são públicos por padrão. E, como estamos acessando da mesma classe, não temos que especificar o nome da classe.
Blocos Estáticos
Em Java, os blocos estáticos são usados para inicializar as variáveis estáticas. Por exemplo,
class Test ( // static variable static int age; // static block static ( age = 23; ) )
Aqui podemos ver que usamos um bloco estático com a sintaxe:
static ( // variable initialization )
The static block is executed only once when the class is loaded in memory. The class is loaded if either the object of the class is requested in code or the static members are requested in code.
A class can have multiple static blocks and each static block is executed in the same sequence in which they have been written in a program.
Example 3: Use of static block in java
class Main ( // static variables static int a = 23; static int b; static int max; // static blocks static ( System.out.println("First Static block."); b = a * 4; ) static ( System.out.println("Second Static block."); max = 30; ) // static method static void display() ( System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("max = " + max); ) public static void main(String args()) ( // calling the static method display(); ) )
Output:
First Static block. Second Static block. a = 23 b = 92 max = 30
In the above program. as soon as the Main class is loaded,
- The value of a is set to
23. - The first static block is executed. Hence, the string
First Static blockis printed and the value of b is set toa * 4. - The second static block is executed. Hence, the string
Second Static blockis printed and the value of max is set to30. - E, finalmente, as instruções de impressão dentro do método
display()são executadas.
Classe estática aninhada
Em Java, podemos declarar uma classe dentro de outra classe. Essas classes são conhecidas como classes aninhadas. As classes aninhadas são de 2 tipos:
- Classes aninhadas estáticas
- Classes aninhadas não estáticas
Por exemplo,
class OuterClass ( // static nested class static class NestedClass (… ) // non-static nested class class InnerClass (… ) )
Para saber mais, visite o Java Nested Class.
