Java: quando usar métodos estáticos

Gostaria de saber quando usar métodos estáticos? Digamos se eu tenho uma classe com alguns getters e setters, um método ou dois, e quero que esses métodos sejam invocáveis ​​apenas em um objeto de instância da classe. Isso significa que eu deveria usar um método estático?

por exemplo

Obj x = new Obj();
x.someMethod

ou

Obj.someMethod

(é este o caminho estático?)

Estou um pouco confuso!

Uma regra prática: pergunte a si mesmo "Faz sentido chamar esse método, mesmo que nenhum objeto tenha sido construído ainda?" Nesse caso, deve ser definitivamente estático.

Portanto, em uma classe, Carvocê pode ter um método:

double convertMpgToKpl(double mpg)

... o que seria estático, porque é possível saber no que 35mpg se converte, mesmo que ninguém jamais tenha construído um Car. Mas este método (que define a eficiência de um particular Car):

void setMileage(double mpg)

... não pode ser estático, pois é inconcebível chamar o método antes que qualquer Cartenha sido construído.

(A propósito, o inverso nem sempre é verdadeiro: às vezes você pode ter um método que envolve dois Carobjetos e ainda assim querer que seja estático. Por exemplo:

Car theMoreEfficientOf( Car c1, Car c2 )

Embora isso possa ser convertido para uma versão não estática, alguns argumentam que, como não há uma opção "privilegiada", o que Caré mais importante, você não deve forçar um chamador a escolher um Carcomo o objeto que você chamará. método ativado. Essa situação é responsável por uma fração bastante pequena de todos os métodos estáticos.)

Defina métodos estáticos apenas nos seguintes cenários:

1. Se você estiver escrevendo classes de utilitário e elas não devem ser alteradas.
2. Se o método não estiver usando nenhuma variável de instância.
3. Se alguma operação não depende da criação da instância.
4. Se houver algum código que possa ser facilmente compartilhado por todos os métodos da instância, extraia esse código em um método estático.
5. Se você tiver certeza de que a definição do método nunca será alterada ou substituída. Como métodos estáticos não podem ser substituídos.

Existem alguns motivos válidos para usar métodos estáticos:

• Desempenho : se você deseja que algum código seja executado e não instancia um objeto extra para fazê-lo, coloque-o em um método estático. A JVM também pode otimizar muito os métodos estáticos (acho que já li James Gosling declarando que você não precisa de instruções personalizadas na JVM, pois os métodos estáticos serão tão rápidos, mas não conseguem encontrar a fonte - portanto pode ser completamente falso). Sim, é micro-otimização e provavelmente desnecessário. E nós programadores nunca fazemos coisas desnecessárias só porque são legais, certo?

• Praticidade : em vez de ligar new Util().method(arg), ligar Util.method(arg)ou method(arg)com importações estáticas. Mais fácil, mais curto.

• Adicionando métodos : você realmente queria que a classe String tivesse um removeSpecialChars()método de instância, mas não existe (e não deveria, pois os caracteres especiais do seu projeto podem ser diferentes dos do outro) e não pode ser adicionado (desde Java é um pouco sensato), então você cria uma classe de utilitário e chama em removeSpecialChars(s)vez de s.removeSpecialChars(). Doce.

• Pureza : tomando algumas precauções, seu método estático será uma função pura , ou seja, a única coisa de que depende são seus parâmetros. Entrada de dados, saída de dados. Isso é mais fácil de ler e depurar, pois você não precisa se preocupar com peculiaridades de herança. Você também pode fazer isso com métodos de instância, mas o compilador o ajudará um pouco mais com métodos estáticos (não permitindo referências a atributos de instância, substituindo métodos etc.).

Você também precisará criar um método estático se quiser criar um singleton, mas ... não. Quero dizer, pense duas vezes.

Agora, mais importante, por que você não gostaria de criar um método estático? Basicamente, o polimorfismo sai da janela . Você não poderá substituir o método nem declará-lo em uma interface (pré-Java 8) . É preciso muita flexibilidade do seu design. Além disso, se precisar de estado , você terá muitos bugs de concorrência e / ou gargalos, se não for cuidadoso.

Depois de ler os artigos de Misko, acredito que os métodos estáticos são ruins do ponto de vista de teste. Você deve ter fábricas (talvez usando uma ferramenta de injeção de dependência como o Guice ).

como posso garantir que tenho apenas algo

só tenho uma de alguma coisa O problema de "como garantir que só tenho uma de alguma coisa" é bem contornado. Você instancia apenas um único ApplicationFactory no seu principal e, como resultado, apenas instancia uma única instância de todos os seus singletons.

O problema básico dos métodos estáticos é que eles são código processual

O problema básico dos métodos estáticos é que eles são código processual. Não tenho idéia de como testar o código processual de unidade. O teste de unidade pressupõe que eu possa instanciar um pedaço do meu aplicativo isoladamente. Durante a instanciação, conecto as dependências com zombarias / amistosos que substituem as dependências reais. Com a programação procedural, não há nada para "conectar", pois não há objetos, o código e os dados são separados.

Um staticmétodo é um tipo de método que não precisa que nenhum objeto seja inicializado para ser chamado. Você notou que staticé usado na mainfunção em Java? A execução do programa começa a partir daí sem a criação de um objeto.

Considere o seguinte exemplo:

 class Languages 
 {
     public static void main(String[] args) 
     {
         display();
     }

     static void display() 
     {
         System.out.println("Java is my favorite programming language.");
     }
  }

Métodos estáticos em java pertencem à classe (não uma instância dela). Eles não usam variáveis ​​de instância e geralmente recebem informações dos parâmetros, executam ações e retornam algum resultado. Os métodos de instâncias estão associados a objetos e, como o nome indica, podem usar variáveis ​​de instância.

Não, métodos estáticos não estão associados a uma instância; eles pertencem à classe. Métodos estáticos são seu segundo exemplo; Os métodos de instância são os primeiros.

Se você aplicar uma palavra-chave estática a qualquer método, ela será conhecida como método estático.

1. Um método estático pertence à classe e não ao objeto de uma classe.
2. Um método estático chamado sem a necessidade de criar uma instância de uma classe.
3. O método static pode acessar o membro de dados estáticos e pode alterar o valor dele.
4. Um método estático pode ser acessado apenas usando o nome de um nome estático de ponto de classe. . . exemplo: Student9.change ();
5. Se você deseja usar campos não estáticos de uma classe, deve usar um método não estático.

// Programa de alteração da propriedade comum de todos os objetos (campo estático).

class Student9{  
 int rollno;  
 String name;  
 static String college = "ITS";  

 static void change(){  
 college = "BBDIT";  
 }  

 Student9(int r, String n){  
 rollno = r;  
 name = n;  
 }  

 void display (){System.out.println(rollno+" "+name+" "+college);}  

public static void main(String args[]){  
Student9.change();  

Student9 s1 = new Student9 (111,"Indian");  
Student9 s2 = new Student9 (222,"American");  
Student9 s3 = new Student9 (333,"China");  

s1.display();  
s2.display();  
s3.display();  
}  }

O / P: 111 BBDIT indiano 222 BBDIT americano 333 China BBDIT

Os métodos estáticos não estão associados a uma instância, portanto, eles não podem acessar nenhum campo não estático na classe.

Você usaria um método estático se o método não usar nenhum campo (ou apenas campos estáticos) de uma classe.

Se qualquer campo não estático de uma classe for usado, você deverá usar um método não estático.

Os métodos estáticos devem ser chamados na classe, os métodos de instância devem ser chamados nas instâncias da classe. Mas o que isso significa na realidade? Aqui está um exemplo útil:

Uma classe de carro pode ter um método de instância chamado Accelerate (). Você só pode acelerar um carro, se o carro realmente existir (foi construído) e, portanto, esse seria um método de instância.

Uma classe de carro também pode ter um método de contagem chamado GetCarCount (). Isso retornaria o número total de carros criados (ou construídos). Se nenhum carro foi construído, esse método retornaria 0, mas ainda assim poderia ser chamado e, portanto, teria que ser um método estático.

Na verdade, usamos propriedades e métodos estáticos em uma classe, quando queremos usar alguma parte do nosso programa que deve existir lá até que o programa esteja em execução. E sabemos que, para manipular propriedades estáticas, precisamos de métodos estáticos, pois eles não fazem parte da variável de instância. E sem métodos estáticos, manipular propriedades estáticas é demorado.

Use um método estático quando desejar acessar o método sem uma instância da classe.

Estático: Obj.someMethod

Use staticquando desejar fornecer acesso no nível de classe a um método, ou seja, onde o método deve ser chamado sem uma instância da classe.

Os métodos estáticos não precisam ser invocados no objeto e é quando você o utiliza. Exemplo: seu Main () é estático e você não cria um objeto para chamá-lo.

Métodos e variáveis ​​estáticas são uma versão controlada das funções e variáveis ​​'Globais' em Java. Em que métodos podem ser acessados ​​como classname.methodName()ou classInstanceName.methodName(), ou seja, métodos e variáveis ​​estáticos podem ser acessados ​​usando o nome da classe, bem como instâncias da classe.

A classe não pode ser declarada como estática (porque não faz sentido. Se uma classe é declarada pública, pode ser acessada de qualquer lugar), as classes internas podem ser declaradas estáticas.

Métodos estáticos podem ser usados ​​se

• Não se deseja executar uma ação em uma instância (métodos utilitários)

  Como mencionado em algumas das respostas acima neste post, converter milhas em quilômetros ou calcular a temperatura de Fahrenheit em Celsius e vice-versa. Com esses exemplos usando o método estático, não é necessário instanciar um objeto novo inteiro na memória heap. Considere abaixo

  1. new ABCClass(double farenheit).convertFarenheitToCelcium() 
  2. ABCClass.convertFarenheitToCelcium(double farenheit)

  o primeiro cria uma nova presença de classe para cada método invocado, Desempenho, Prático . Exemplos são a classe StringUtils da biblioteca Math e Apache-Commons abaixo:

  Math.random()
  Math.sqrt(double)
  Math.min(int, int)
  StringUtils.isEmpty(String)
  StringUtils.isBlank(String)

• Alguém quer usar como uma função simples. As entradas são explicitamente transmitidas e obtêm os dados do resultado como valor de retorno. Herança, a instanciação do objeto não entra em cena. Conciso, legível .

NOTA : Poucas pessoas argumentam contra a testabilidade de métodos estáticos, mas eles também podem ser testados! Com o jMockit, é possível zombar de métodos estáticos. Testabilidade . Exemplo abaixo:

new MockUp<ClassName>() {
    @Mock
    public int doSomething(Input input1, Input input2){
        return returnValue;
    }
};

Métodos estáticos são os métodos em Java que podem ser chamados sem criar um objeto de classe. É pertencer à classe.

Usamos o método estático quando não precisamos ser chamados pelo método instance.

Gostaria de saber quando usar métodos estáticos?

1. Um uso comum para staticmétodos é acessar staticcampos.

2. Mas você pode ter staticmétodos, sem referenciar staticvariáveis. Métodos auxiliares sem referenciar staticvariável podem ser encontrados em algumas classes java como java.lang.Math

   public static int min(int a, int b) {
       return (a <= b) ? a : b;
   }

3. No outro caso de uso, posso pensar nesses métodos combinados com o synchronizedmétodo é a implementação do bloqueio no nível de classe no ambiente multiencadeado.

Digamos se eu tenho uma classe com alguns getters e setters, um método ou dois, e quero que esses métodos sejam invocáveis ​​apenas em um objeto de instância da classe. Isso significa que eu deveria usar um método estático?

Se você precisar acessar o método em um objeto de instância da classe, seu método deverá ser não estático.

A página de documentação do Oracle fornece mais detalhes.

Nem todas as combinações de variáveis ​​e métodos de instância e classe são permitidas:

1. Os métodos de instância podem acessar variáveis ​​de instância e métodos de instância diretamente.
2. Os métodos de instância podem acessar variáveis ​​de classe e métodos de classe diretamente.
3. Os métodos de classe podem acessar variáveis ​​e métodos de classe diretamente.
4. Os métodos de classe não podem acessar variáveis ​​de instância ou métodos de instância diretamente - eles devem usar uma referência de objeto. Além disso, os métodos de classe não podem usar a palavra-chave this, pois não há instância para isso se referir.

Um método estático tem dois objetivos principais:

1. Para métodos utilitários ou auxiliares que não exigem nenhum estado de objeto. Como não há necessidade de acessar variáveis ​​de instância, ter métodos estáticos elimina a necessidade de o chamador instanciar o objeto apenas para chamar o método.
2. Para o estado que é compartilhado por todas as instâncias da classe, como um contador. Toda instância deve compartilhar o mesmo estado. Os métodos que apenas usam esse estado devem ser estáticos também.

No eclipse, você pode ativar um aviso que ajuda a detectar possíveis métodos estáticos. (Acima da linha destacada há outra que eu esqueci de destacar)

Sempre que você não desejar criar um objeto para chamar um método no seu código, apenas declare esse método como estático. Como o método estático não precisa de uma instância para ser chamada, mas a captura aqui nem todos os métodos estáticos são chamados pela JVM automaticamente. Esse privilégio é usufruído apenas pelo método main () "public static void main [String ... args]" em java porque, em tempo de execução, esse é o método Signature public "static" void main [] procurado pela JVM como um ponto de entrada para inicia a execução do código.

Exemplo:

public class Demo
{
   public static void main(String... args) 
   {
      Demo d = new Demo();

      System.out.println("This static method is executed by JVM");

     //Now to call the static method Displ() you can use the below methods:
           Displ(); //By method name itself    
      Demo.Displ(); //By using class name//Recommended
         d.Displ(); //By using instance //Not recommended
   }

   public static void Displ()
   {
      System.out.println("This static method needs to be called explicitly");
   }
} 

Saída: - Este método estático é executado pela JVM Este método estático precisa ser chamado explicitamente Este método estático precisa ser chamado explicitamente Este método estático precisa ser chamado explicitamente