Modificador Static em Java

    Quando e porquê usar static? static é uma das palavras-chave do Java, e é também motivo de muita confusão e dúvidas entre o pessoal que esta começando. Aliás, mesmo os mais experienciados confundem-se às vezes em usar ela. O método static mais famoso de todos é o main. É através dele que vimos nosso primeiro programa em Java nascer, e é sempre via main que nossos programas criam vida. Por definição da linguagem Java, o método main precisa necessariamente ter acesso public, ser static, não retornar coisa alguma ( void ) e receber como argumento um array de String ( String args[] ):

public static void main(String args[])  

Entendendo static

    Como regra geral, tenha isso em mente: dentro de métodos static somente é possível pode acessar outros métodos e variáveis que também sejam static. Dentro do método pode-se definir qualquer tipo de variável, static ou não. Caso seja necessário acessar algum método ou membro não-static, é necessário criar uma instância da classe e então chamar o que quiser. Já o contrario é um pouco diferente: dentro de membros não-static, é possível acessar tanto propriedades static quanto as não-static. O fato de ser preciso primeiramente criar uma instância da classe para só então chamar algum método não-static ou acessar uma variável comum dentro de um método static deve-se ao fato que dentro dele não existe uma referência para o ponteiro this. O ponteiro this é utilizado para referenciar propriedades da classe em que estamos trabalhando. Por exemplo:

...  
// Variável simples, para guardar o nome  
private String nome;  
  
// Algum método comum  
public void meuMetodo()  
{  
    this.nome = "Fulano";  
}  
...

    No exemplo acima, this.nome = "Fulano" diz que estamos atribuindo ao membro da classe chamado nome o valor "Fulano". O uso de this é automático, portando o exemplo acima poderia ser escrito simplesmente da forma
...

// Variável simples, para guardar o nome  
private String nome;  
  
// Algum método comum  
public void meuMetodo()  
{  
    nome = "Fulano";  
}  
...

    Note que agora não mais usamos this, e funciona da mesma maneira. Se o método meuMetodo fosse static, o código acima não funcionaria, pois como foi dito antes, métodos static não possuem this. Ao contrário do que o nome soa, static não significa que a variável ou método sera estática do ponto de vista que seu valor não pode mudar ( final é usado para estes casos ). static nos garante que somente haverá uma, e não mais que uma, referência para determinada variável ou método disponível em mémoria. Em outras palavras, declarando alguma coisa como static, todas as instâncias da classe irão compartilhar a mesma cópia da variável ou método. Declarar algo como static também permite você acessar as coisas diretamente, ou seja, sem precisar criar uma instância da classe. Existe inclusive um Design Patter baseado no uso de static: Singleton.

Exemplificando

    Para entender melhor tudo o que foi dito, nada melhor que alguns exemplos práticos para ver com os próprios olhos o funcionamento. O primeiro exemplo consiste em uma classe com 2 variáveis, uma static e outra não-static. A cada novo objeto criado, incrementados ambas variáveis e imprimimos o resultado na tela. Digite o seguinte código em um arquivo chamado "TesteStatic.java":

// TesteStatic.java  
class Classe1  
{  
    // Variavel static  
    public static int contador = 0;  
  
    // Variavel nao-static  
    public int outroContador = 0;  
  
    public Classe1() {}  
  
    // Precisa ser static porque "contador" é static  
    public static void incrementaContador()  
    {  
        contador++;  
  
        System.out.println("contador agora é "+ contador);  
    }  
  
    public void incrementaOutroContador()  
    {  
        outroContador++;  
  
        System.out.println("outroContador agora é "+ outroContador);  
    }  
}  
  
public class TesteStatic  
{  
    public static void main(String args[])  
    {  
        Classe1 c1 = new Classe1();                       
        c1.incrementaContador();  
        c1.incrementaOutroContador();  
  
        Classe1 c2 = new Classe1();  
        c2.incrementaContador();  
        c2.incrementaOutroContador();  
          
        Classe1 c3 = new Classe1();  
        c3.incrementaContador();  
        c3.incrementaOutroContador();  
  
        Classe1 c4 = new Classe1();  
        c4.incrementaContador();  
        c4.incrementaOutroContador();  
    }  
}  

    A saida gerada por este programa será

1. contador agora é 1  
2. outroContador agora é 1  
3. contador agora é 2  
4. outroContador agora é 1  
5. contador agora é 3  
6. outroContador agora é 1  
7. contador agora é 4  
8. outroContador agora é 1  

    Note que a variavel "contador", que é static, não teve seu valor zerado a cada novo objeto criado da classe Classe1, mas sim incrementado, enquando "outroContador", que é uma variável comum, ficou sempre em 1, pois a zeramos o valor no construtor da classe.

Acesso direto

    Ao contrário de tipos de dados não-static, qualquer variável ou método static podem ser acessado diretamente, sem necessitar de uma instância da classe criada:

// TesteStatic2.java  
class Classe2  
{  
    // Escreve alguma frase na tela  
    public static void escreve(String msg)  
    {  
        System.out.println(msg);  
    }  
      
    // Retorna a multiplicação de dois números int  
    public static int multiplica(int n1, int n2)  
    {  
        return (n1 * n2);  
    }  
      
    // Construtor, apenas para mostrar que  
    // ele nem chega ser chamado  
    public Classe2()  
    {  
        System.out.println("Construtor de Classe2");  
    }  
}  
  
public class TesteStatic2  
{  
    public static void main(String args[])  
    {  
        Classe2.escreve("Multiplicando 3 vezes 3:");  
        int resultado = Classe2.multiplica(3, 3);  
        Classe2.escreve("Resultado: "+ resultado);  
    }  
}  

    Rode este programa e repare no resultado. Veja que o construtor da classe não foi chamado, pois não aparece na tela a string "Construtor de Classe2". Repare também que não criamos instância alguma de Classe2 para chamar seus métodos. Caso os métodos escreve e multiplica não fossem static, seria necessário fazer.

public class TesteStatic2  
{  
    public static void main(String args[])  
    {  
        Classe2 c2 = new Classe2();  
        c2.escreve("Multiplicando 3 vezes 3:");  
        int resultado = c2.multiplica(3, 3);  
        c2.escreve("Resultado: "+ resultado);  
    }  
}  

    Note que o código acima funciona perfeitamente mesmo com os métodos static. Isso funciona porque apesar de podermos chamar diretamente as coisas quando elas são static, não é obrigatório, podendo perfeitamente ser criada uma instância da classe e então chamar os métodos. O uso de static depende muito do caso, e conforme você vai pegando mais experiência, irá naturalmente identificar os lugares que precisam - ou que são mais convenientes - ao uso de tal palavra-chave

Para que serve um Modificador Abstract?

Modificador Abstract.

Um modificador abstract serve para impedir que uma classe de ser instanciada (criar uma nova instancia com new), os metodos abstratos não possuem  corpo.

Ex:  Uma classe com o modificador abstract;

   public class abstract Animal {

   public void come (String comida) {
  
     System.out.println(comida);

    }

}

public class TestAnimal {

public static void main (String [] args){

    Animal animal = new Animal();  // não será compilado porque a classe animal é abstrata;

    }

}


Um metodo abstrato  não tem corpo

Ex: 

 Se uma class tiver pelo menos um metodo abstrato a classe deve ser abstrata  e toda classe não abstrata que herdar da classe abstrata terá que implementar os metodos abstratos da Super classe.

  public class abstract Animal {  

   public abstract void come (); 

}

public class TestAnimal extends Animal {

public static void main (String [] args){

Neste caso como TestAnimal herda de Animal precisa implementar todos os metodos abstratos da superclasse Animal.

    public void come {
           // Aqui vai o codigo
        }
    }

}

O que são Tipos Primitivos em Java?

Tipos Primitivos do Java

Quando criamos um programa, devemos saber com que tipo de informação estamos lidando e para qual finalidade ela será útil. Afinal, devemos ter conhecimento disso para declararmos corretamente o tipo de dado que a variável irá suportar.

Java é uma linguagem de forte tipografia. Isso significa que as variáveis devem ser declaradas respeitando-se a sintaxe básica "tipo identificador;". Há oito tipos de dados primitivos em Java, que podem ser classificados em três categorias: lógicos, numéricos e de caracteres.

Vamos entender cada um delas:

Tipos lógicos
boolean	Representam apenas 1 bit de informação (0 ou 1). Podem assumir apenas os valorestrue e false.
Tipos caractere
char	Representam notação de caracteres de 16 bits (2 bytes) para formato Unicode UTF-16. Podem assumir caracteres entre '\u0000' a '\uffff' e valores numéricos entre 0a 65535.
Tipos numéricos inteiros
byte	Representam números inteiros de 8 bits (1 byte). Podem assumir valores entre -128 a127.
short	Representam números inteiros de 16 bits (2 bytes). Podem assumir valores entre-32.768 até 32.767.
Int	Representam números inteiros de 32 bits (4 bytes). Podem assumir valores entre-2.147.483.648 até 2.147.483.647.
long	Representam números inteiros de 64 bits (8 bytes). Podem assumir valores entre-9.223.372.036.854.775.808 até 9.223.372.036.854.775.807.
Tipos numéricos reais
float	Representam números reais de 32 bits com precisão simples. Podem assumir valores de ponto flutuante com formato definido pela especificação IEEE 754.
double	Representam números reais de 64 bits com precisão dupla. Assim como o float. Podem assumir valores de ponto flutuante com formato definido pela especificação IEEE 754.

Além dos tipos primitivos, existe o tipo String, que funciona como um container de chars, possibilitando a atribuição de uma sequência de caracteres delimitados por aspas duplas (""). Você provavelmente pensará nela como um tipo primitivo, mas uma String é uma classe especial fornecida pela linguagem para prover suporte à cadeia de caracteres. Veremos mais sobre classes e objetos mais adiante.

Vamos praticar um pouco agora: crie uma classe com o nome TiposPrimitivos.java e escreva o código conforme o exemplo abaixo:

public class TiposPrimitivos {
  public static void main(String[] args){
            
     
    // Tipos numéricos inteiros    
    
    byte   byteMinimo = -127; 
    byte   byteMaximo =  127;
    
    short  shortMaximo = -32768; 
    short  shortMinimo =  32767;
    
    int intMaximo = -32767;
    int intMinimo =  32767;
    
    long longMaximo  = -9223372036854775808l;
    long longMinimo  =  9223372036854775807l;
    
    // Tipos numéricos reais
    
    float floatNum = 78.88776f;
    double doubleNum = 922337.559874387184073645;
    
    // tipos lógicos
    
    boolean booleanTrue  = true;
    boolean booleanFalse = false;
    
    // tipos caractere
    
    char charMinimo  = 0;
    char charMaximo  = 65535; 
    char charLetra   = 'A';
    char charUnicode = '\u0065';
    
    String stringQualquer = "Uma string qualquer";
    
    //Apresentando os Resultados 
    
    System.out.println(byteMinimo);
    System.out.println(byteMaximo);
    System.out.println(shortMinimo);
    System.out.println(shortMaximo);
    System.out.println(intMinimo);
    System.out.println(intMaximo);
    System.out.println(longMinimo);
    System.out.println(longMaximo);
    
    System.out.println(floatNum);
    System.out.println(doubleNum);
    
    System.out.println(charMinimo);
    System.out.println(charMaximo);
    System.out.println(charLetra);
    System.out.println(charUnicode);
    
    System.out.println(stringQualquer);
    
  }
}

Ao executar o código acima, você verá que, mesmo que se atribua um número qualquer a uma variável do tipo char, ela será tratada pelo método println() como um caractere, não como um número. Também verá que uma letra "F" acompanha o valor atribuído à variável floatNumero e que a letra "L" acompanha o valor atribuído às variáveis longMinimo e longMaximo. Essas letras são sufixos de literais. Elas indicam o tipo do valor que você está passando para a variável.

O que são Arrays em Java?

O que são Arrays em Java?

Arrays são objetos que armazenam diversas variáveis do mesmo tipo. Eles podem conter variáveis de referência primitivas ou de objeto, mas o array propriamente dito sempre será um objeto da pilha, mesmo se for declarado para armazenar elementos primitivos. Em outras palavras, não existe algo como um array primitivo, mas você pode criar um array de elementos primitivos.

Array de 10 elementos 


Cada item em um array é chamado de elemento, e cada elemento é acessado pela posição numérica. Como na ilustração acima as posições são nu*****s a partir do 0. O 9th elemento, por exemplo, é acessado na posição 8.

O programa a seguir cria um array de inteiros, atribui algumas posições a ele, e imprime cada valor à saída padrão.

class ArrayDemo {

public static void main(String[] args) {

int[] meuArray; // declara um array de inteiros

meuArray = new int[10]; // aloca a memória para 10 inteiros

meuArray[0] = 100; // inicializa o primeiro elemento
meuArray[1] = 200; // inicializa o segundo elemento
meuArray[2] = 300; // etc.
meuArray[3] = 400;
meuArray[4] = 500;
meuArray[5] = 600;
meuArray[6] = 700;
meuArray[7] = 800;
meuArray[8] = 900;
meuArray[9] = 1000;

System.out.println("Elemento na posicao 0: " + meuArray[0]);
System.out.println("Elemento na posicao 1: " + meuArray[1]);
System.out.println("Elemento na posicao 2: " + meuArray[2]);
System.out.println("Elemento na posicao 3: " + meuArray[3]);
System.out.println("Elemento na posicao 4: " + meuArray[4]);
System.out.println("Elemento na posicao 5: " + meuArray[5]);
System.out.println("Elemento na posicao 6: " + meuArray[6]);
System.out.println("Elemento na posicao 7: " + meuArray[7]);
System.out.println("Elemento na posicao 8: " + meuArray[8]);
System.out.println("Elemento na posicao 9: " + meuArray[9]);
}
}

A saída desse programa é:

Elemento na posicao 0: 100
Elemento na posicao 1: 200
Elemento na posicao 2: 300
Elemento na posicao 3: 400
Elemento na posicao 4: 500
Elemento na posicao 5: 600
Elemento na posicao 6: 700
Elemento na posicao 7: 800
Elemento na posicao 8: 900
Elemento na posicao 9: 1000


Em uma situação de programação real, você provavelmente utilizaria umas das construções fazendo loopings (laços) para preencher o seu array, pois seria melhor do que escrever cada linha individualmente como mostrado acima. Entretanto, este exemplo ilustra claramente a sintaxe da disposição

O que é um Método em java

O que é um Método em Java

Método é uma coleção de declarações que são agrupadas juntas para fazer uma operação. Quando você chama o método System.out.println por exemplo , o sistema na realidade executa varias declarações para poder imprimir na tela o que foi exigido.

Exemplo : 

public class Metodos {

/*
* public é o modificador
* nesse caso int é o tipo de retorno
* soma é o nome do método
* dentro dos parenteses ficam os parametros
* os parametros são o tipo de informação que é pedido pelo método
* */
public int soma (int numero1 , int numero2){
// criamos uma variavel com o nome de resultado

int resultado = numero1 + numero2;

//return é o valor que o método vai retornar
return resultado;
}

public static void main(String [] args){
Metodos metodos = new Metodos();

//aqui chamamos o método e colocamos dois inteiros

metodos.soma(5,5);

// aqui imprimimos na tela o valor que o nosso método retorna
System.out.println(metodos.soma(5, 5));

//o resultado vai ser 10


}

}