Classes e Objetos em Java

1. Escrevendo classes em Java

• public é um modificador de acesso (opcional) que garante que todas as classes do sistema podem ver a classe descrita;

• As classes em Java obedecem uma estrutura de pacotes (packages) de acordo com o caminho do código fonte dentro das pastas.

  • Se public ou outro modificador de acesso não for definido para a classe, o modificador de acesso default é package, ou seja, a classe pode ser acessada por todas as classes do pacote. Isso também acontece para atributos e métodos sem modificador de acesso declarados.

  • A declaração do pacote ao qual uma classe pertence vem antes da declaração da classe. 

  • Classes do mesmo pacote não precisam ser importadas.

Arquivo: NomeClasse.java

package alg3.exemplo;

public class NomeClasse {

//conteúdo da classe

}

Iremos ver mais sobre Modificadores de Acesso e importações ao longo da disciplina.

1.1. Tipos de Classe

• As classes em Java podem ser conceituais ou executáveis.

• Uma classe executável deve ter o método main (principal),  senão é uma classe conceitual.

• O  método main define por onde o algoritmo da aplicação irá começar a executar.

• Em um projeto, pode haver mais de um  método main (ainda que não seja comum), devendo na hora da execução ser definido qual método main será executado.

• Já uma classe conceitual, costuma definir atributos e métodos para representar um conceito que será utilizado por outras classes do sistema, funcionando como um "molde" para a criação de instâncias/objetos da classe.

• Todo conteúdo a ser executado pela classe principal precisa estar dentro do método main;

• Dentro deste método, irão ocorrer a criação de instâncias de objetos e a chamada de métodos de outras classes que permitirão a comunicação entre as classes do sistema para um programa mais robusto orientado a objetos;

• O  método main é sempre public e static, modificadores de métodos que indicam respectivamente que o método principal é público (visível para toda a aplicação) e estático (não depende de instâncias/objetos);

• O  método main tem sempre void como tipo de retorno do método, o que significa vazio/nada, ou seja, o método não possui retorno;

• Parâmetros de um método são declarados via parênteses (),  (String[] args) define que o método deve receber como parâmetro um array de String nomeado args, que pode ter seus valores acessados via colchetes [], ex.: args[0] acessa o valor na posição inicial do vetor. Nesse caso específico, este parâmetro serve para caso o programa precise receber algum valor como argumento, isso é muito comum quando o programa é iniciado por outro programa ou pelo terminal. Não é obrigatório para o método main(), mas é gerado por convenção em IDEs;

2. Atributos em Java

• Um atributo é uma característica/propriedade de uma classe/objeto.

• Um atributo possui um nome identificador, um tipo (primitivo ou não primitivo), um valor (declaração opcional) que pode variar de acordo com a identidade do objeto e um modificador de acesso que distingue quem pode acessar o valor do atributo.

• O nome e o tipo do atributo devem ser declarados obrigatoriamente.

Sintaxe:

modificador_de_acesso tipo nome = valor;

3. Tipos em Java

O Java possui dois tipos de dados que são divididos em por valor (tipos primitivos) e por referência (tipos não primitivos).

Os tipos primitivos em Java são boolean, byte, char, short, int, long, float e double. 

4. Métodos em Java

• Um método é um comportamento de uma classe/objeto, ou seja, uma ação que um objeto pode executar.

• Métodos são utilizados para promover a comunicação entre classes e objetos.

• Um método em Java é composto por:

  • • Nome de identificação do método;

    • Lista de parâmetros: atributos necessários para a execução do método;

    • Tipo de retorno: resposta da execução do método;

    • Modificador de acesso: distingue o escopo de chamada para o método;

• Na lista de parâmetros os atributos são separados por vírgula.

• Por hora, vamos usar os modificadores de acesso público (public) e privado (private) para os métodos.

• A instrução return é utilizada opcionalmente quando se deseja retornar a informação de saída do método e o valor passado deve ser do tipo de retorno do método.

Sintaxe:

modificador_de_acesso tipo_retorno nome(lista_de_parâmetros){

//instruções

return valor;

}

• Quando um método não tem um retorno, utiliza-se o termo void como tipo de retorno. 

Sintaxe:

modificador_de_acesso void nome(lista_de_parâmetros){

//instruções

}

• O método main é um exemplo de método sem retorno.

5. Criando instâncias/objetos ou usando classes conceituais...

• Para utilizar uma classe conceitual é necessário declarar e criar um objeto/instância dela.

• A instrução new cria um novo objeto da classe especificada.

• A instrução new é utilizada acompanhada de um método construtor. O método construtor sempre possui o mesmo nome da classe do objeto.

Sintaxe:

tipo_do_objeto nome_do_obejto = new método_construtor();

• O método construtor é o método responsável pela criação de um objeto e pela alocação de recursos necessários ao funcionamento do objeto (ex.: inicializar valores de atributos). 

• Veremos mais sobre métodos construtores nesta disciplina. Por enquanto, vamos assumir o método construtor default para uma classe conceitual que segue a sintaxe:  new NomeClasse()

Exemplos:

Scanner entrada = new Scanner(System.in);

Triangulo t1 = new Triangulo();

Pessoa alan = new Pessoa();

• Após a criação do objeto/instância, atributos e métodos podem ser acessados a partir da instância utilizando o nome do objeto seguido de um ponto.

Exemplo:

/* chama o método nextFloat() do objeto input e atribui a sua saída como valor para o atributo base do objeto t1 */

alan.nome = "Alan Turing";

t1.base = entrada.nextFloat();

t1.calcularArea(2.5, 3.0); 

• O objeto/classe que realiza a chamada do método é chamado de requisitante.

O exemplo a seguir descreve uma classe executável que utiliza a classe conceitual Triangulo para calcular a área de um triângulo.

Caso não houvesse a classe conceitual Triangulo, toda a responsabilidade recairia sobre a classe executável principal, fazendo com que o código lembrasse o paradigma imperativo, como é possível observar a seguir.

Arquivo único Main.java

import java.util.Scanner; //Importa a classe Scanner

class Main {

  public static void main(String[] args) {

    //Cria um Scanner para obter entrada a partir da janela da console

    Scanner entrada = new Scanner(System.in);

    //Cria atributos do tipo float para o cálculo

    float base, altura, area;

    //Imprime o texto na saída em uma única linha

    System.out.print("Informe o valor da base do triângulo:");

    //Lê a informação e armazena

    base = entrada.nextFloat();

    //Imprime o texto na saída em uma única linha

    System.out.print("Informe o valor da altura do triângulo:");

    //Lê a informação e armazena

    altura = entrada.nextFloat();

    //Cálculo da área do triângulo

    area = base * altura / 2;

    //Imprime resultado em texto concatenado na saída

    System.out.println("A área do triângulo é: " + Float.toString(area));

 }

}