Métodos Java e Fundamentos de POO: Laboratório Prático

Introdução

Este laboratório aprimorará suas habilidades em Java, introduzindo métodos e os fundamentos da programação orientada a objetos (POO). Esses conceitos são essenciais para escrever código bem estruturado, reutilizável e eficiente. Abordaremos:

Criação e utilização de métodos para organizar o código e facilitar a reutilização.
Compreensão das ideias centrais por trás de classes e objetos.
Implementação de uma classe básica que inclui métodos e atributos.

Ao final deste laboratório, você será capaz de escrever programas Java que utilizam métodos para dividir problemas complexos em segmentos menores e mais gerenciáveis. Você também obterá uma compreensão de como a programação orientada a objetos opera em Java, uma habilidade crucial para construir aplicações maiores e mais complexas. Se esses conceitos parecerem inicialmente intrincados, não se preocupe — abordaremos passo a passo, e ao final do laboratório, você apreciará como essas ideias contribuem para um código mais organizado e poderoso.

Vamos começar!

Entendendo e Criando Métodos

Métodos são essencialmente pequenos programas dentro do seu programa principal. Eles ajudam a organizar seu código, melhorar sua legibilidade e possibilitar a reutilização de código sem a necessidade de escrever o mesmo código repetidamente. Considere os métodos como ferramentas especializadas em um kit de ferramentas — cada uma projetada para um propósito específico.

Comece abrindo o arquivo MethodDemo.java no WebIDE. Você deve ver este código inicial:
```
public class MethodDemo {
    public static void main(String[] args) {
        System.out.println("Welcome to the Method Demo!");

        // TODO: Call methods here
    }

    // TODO: Add methods here
}
```
Esta é a estrutura fundamental do nosso programa Java. O método main é o ponto de entrada onde a execução do nosso programa começa.
Agora, vamos criar nosso primeiro método. Faremos um método simples que imprime uma saudação. Adicione este método fora e após o método main, no nível da classe:
```
public class MethodDemo {
    public static void main(String[] args) {
        System.out.println("Welcome to the Method Demo!");

        // TODO: Call methods here
    }

    // Add the new method here, outside and after the main method
    public static void printGreeting(String name) {
        System.out.println("Hello, " + name + "! Welcome to Java methods.");
    }
}
```
Vamos detalhar o que isso significa:
- public: Esta palavra-chave indica que o método pode ser acessado de outras classes.
- static: Isso significa que o método pertence à própria classe, não a uma instância específica da classe. Vamos nos aprofundar nesse conceito mais tarde; por enquanto, pense nisso como um requisito para métodos que queremos usar sem criar um objeto.
- void: Isso significa que nosso método não retorna nenhum valor. Ele realiza uma ação — imprimir uma saudação — mas não retorna nenhum dado.
- printGreeting: Este é o nome que atribuímos ao nosso método. Usaremos este nome para invocar ou chamar o método.
- (String name): Este é um parâmetro — um pedaço de dados que nosso método aceita. Ele espera uma String, que nomeamos name. Quando chamarmos este método, precisaremos fornecer um valor para este parâmetro.
Ótimo! Agora que criamos um método, vamos usá-lo. Dentro do método main, substitua o comentário // TODO: Call methods here por:
```
printGreeting("Alice");
```
Esta linha chama ou invoca nosso método printGreeting e passa a ele o nome "Alice" como um argumento. O argumento fornece a entrada específica que o método precisa para realizar sua ação.
Salve o arquivo e vamos compilar e executar o programa. No terminal na parte inferior do seu WebIDE, digite estes comandos:
```
javac ~/project/MethodDemo.java
java -cp ~/project MethodDemo
```
O primeiro comando compila nosso arquivo Java, traduzindo-o em bytecode que a Java Virtual Machine pode entender. O segundo comando executa o programa compilado. Você deve ver uma saída semelhante a esta:
```
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
```
Excelente! Você acabou de criar e utilizar seu primeiro método Java. Vamos chamá-lo novamente com um nome diferente. Adicione esta linha no método main, logo após a primeira chamada printGreeting:
```
printGreeting("Bob");
```
Salve, compile e execute o programa novamente. Você deve ver agora:
```
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
Hello, Bob! Welcome to Java methods.
```
Perceba como podemos reutilizar nosso método com diferentes entradas? Este é um benefício significativo do uso de métodos.
Agora, vamos criar um método que retorna um valor. Adicione este método à sua classe, abaixo do método printGreeting:
```
public static int sumNumbers(int a, int b) {
    return a + b;
}
```
Este método aceita dois inteiros, soma-os e retorna o resultado. Observe que, em vez de void, usamos int para indicar que este método retorna um valor inteiro.
Vamos usar este novo método em nosso método main. Adicione estas linhas no final do método main:
```
int result = sumNumbers(5, 7);
System.out.println("The sum of 5 and 7 is: " + result);
```
Aqui, estamos invocando nosso método sumNumbers, fornecendo os valores 5 e 7 como argumentos. O valor de retorno do método é então armazenado em uma variável chamada result. Após armazenar o valor de retorno, imprimimos o valor no console.
Salve, compile e execute o programa mais uma vez. Você deve ver agora a saída adicional:
```
The sum of 5 and 7 is: 12
```
Parabéns! Você criou e usou seus primeiros métodos Java. Você viu como os métodos podem realizar ações (como exibir saudações) e fornecer valores de retorno (como a soma de dois números). Os métodos permitem que você estruture seu código em pedaços menores e reutilizáveis, tornando seus programas mais fáceis de entender e manter.

Introdução a Classes e Objetos

Agora que entendemos os métodos, vamos dar um passo na programação orientada a objetos, criando uma classe simples. Na programação orientada a objetos, usamos classes como modelos para criar objetos. Pense em uma classe como um cortador de biscoitos e nos objetos como os biscoitos que você faz com ele.

Abra Car.java e vamos começar a construir nossa classe. Primeiro, definiremos a classe e adicionaremos alguns atributos:
```
public class Car {
    // Attributes
    private String make;
    private String model;
    private int year;
}
```
Esses atributos (também chamados de campos ou propriedades) definem o que cada objeto Car possuirá. Cada carro terá uma marca, um modelo e um ano de fabricação.

A palavra-chave private significa que esses atributos só podem ser acessados de dentro da própria classe. Este é um exemplo de encapsulamento, um conceito que ajuda a proteger a integridade dos dados dentro de nossos objetos.
Agora, vamos adicionar um construtor à nossa classe. Um construtor é um método especial que é chamado automaticamente quando criamos um novo objeto. Ele é usado principalmente para inicializar os atributos do objeto. Adicione este construtor à sua classe Car:
```
// Constructor
public Car(String make, String model, int year) {
    this.make = make;
    this.model = model;
    this.year = year;
}
```
Este construtor recebe três parâmetros e os usa para definir os valores de nossos atributos. A palavra-chave this é usada para se referir aos atributos do objeto atual — ela ajuda a diferenciar entre o atributo do objeto e o parâmetro passado para o construtor quando seus nomes são idênticos.
Em seguida, vamos adicionar um método à nossa classe que exibirá informações sobre o carro. Adicione este método à sua classe Car:
```
// Method
public void displayInfo() {
    System.out.println("Car Information:");
    System.out.println("Make: " + make);
    System.out.println("Model: " + model);
    System.out.println("Year: " + year);
}
```
Este método não recebe nenhum parâmetro e não retorna nenhum valor. Ele simplesmente imprime as informações do carro no console.
Ótimo! Criamos nossa classe Car. Agora, vamos abrir CarDemo.java e adicionar o seguinte código:
```
public class CarDemo {
    public static void main(String[] args) {
        // We'll add code here in the next step
    }
}
```
Isso estabelece a estrutura básica para nosso programa de demonstração.
Agora, vamos criar alguns objetos Car e usá-los. Adicione este código dentro do método main:
```
Car myCar = new Car("Toyota", "Corolla", 2022);
myCar.displayInfo();

Car friendsCar = new Car("Honda", "Civic", 2023);
friendsCar.displayInfo();
```
Aqui, estamos criando dois objetos Car. A palavra-chave new é usada para criar um novo objeto, e estamos chamando o construtor que definimos anteriormente para definir a marca, o modelo e o ano. Em seguida, estamos chamando o método displayInfo em cada objeto carro para exibir suas propriedades.
Antes de compilar e executar nosso programa, é importante notar que estamos trabalhando com vários arquivos Java (Car.java e CarDemo.java). Ao compilar vários arquivos que têm dependências, precisamos compilá-los juntos. Além disso, certifique-se de que CarDemo.java e Car.java estejam localizados no mesmo diretório, caso contrário, você precisará importar a classe Car no início de CarDemo.java, conforme mostrado abaixo.

Se CarDemo.java e Car.java estiverem localizados em diretórios diferentes, pode ser necessário adicionar uma instrução de importação no topo de CarDemo.java:
```
import packagename.Car;  // Replace 'packagename' with the actual package name if applicable
```
Agora, vamos compilar e executar o programa CarDemo:
```
javac ~/project/Car.java ~/project/CarDemo.java
java -cp ~/project CarDemo
```
O primeiro comando compila nossos dois arquivos Java juntos, garantindo que todas as dependências sejam tratadas. O segundo comando executa nossa classe CarDemo.

Você deve ver uma saída como esta:
```
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
Car Information:
Make: Honda
Model: Civic
Year: 2023
```
Parabéns! Você acabou de criar sua primeira classe Java e usá-la para criar objetos. Esta é a base da programação orientada a objetos em Java. Você definiu um modelo (a classe Car) e o usou para criar instâncias específicas (os objetos Car). Cada objeto tem seu próprio conjunto exclusivo de atributos, mas todos compartilham a estrutura e o comportamento definidos pela classe.

Aprimorando Nossa Classe com Mais Métodos

Agora que temos uma compreensão fundamental de classes e objetos, vamos aprimorar nossa classe Car com mais métodos para aumentar sua utilidade. Adicionaremos métodos que representam ações que um carro pode realizar e propriedades sobre as quais podemos querer nos informar sobre um carro.

Abra o arquivo Car.java. Vamos adicionar um método que representa a aceleração do carro. Adicione este método à classe Car:
```
public void accelerate() {
    System.out.println("The " + make + " " + model + " is accelerating.");
}
```
Este método não modifica nenhum dos atributos do carro; ele simplesmente exibe uma mensagem sobre a aceleração do carro.
Agora, vamos adicionar um método para frear. Adicione este método à classe Car:
```
public void brake() {
    System.out.println("The " + make + " " + model + " is braking.");
}
```
Este método também apenas exibe uma mensagem sobre a ação do carro, como o método accelerate anterior.
Em seguida, vamos adicionar um método que fornece informações sobre o carro. Adicione este método:
```
public String getMakeAndModel() {
    return make + " " + model;
}
```
Este método combina a marca e o modelo em uma única string e a retorna. Observe que o tipo de retorno é String, não void, pois este método está nos fornecendo informações.
Finalmente, vamos adicionar um método que determina se um carro é classificado como antigo. Em muitos lugares, um carro é considerado antigo se tiver mais de 25 anos. Adicione este método:
```
 public boolean isAntique() {
     int currentYear = java.time.Year.now().getValue();
     return (currentYear - year) > 25;
 }
```
Este método usa a classe Year embutida do Java para obter o ano atual. Em seguida, ele calcula a idade do carro e retorna true se tiver mais de 25 anos e false caso contrário.

Com esses métodos adicionais adicionados à nossa classe Car, vamos atualizar nosso arquivo CarDemo.java para usá-los. Abra CarDemo.java e substitua seu conteúdo por:

public class CarDemo {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", "Corolla", 2022);
        Car classicCar = new Car("Ford", "Mustang", 1965);

        myCar.displayInfo();
        myCar.accelerate();
        myCar.brake();

        System.out.println(classicCar.getMakeAndModel() + " is an antique: " + classicCar.isAntique());

        Car[] carArray = {myCar, classicCar};
        for (Car car : carArray) {
            System.out.println(car.getMakeAndModel() + " is an antique: " + car.isAntique());
        }
    }
}

Este novo método main realiza várias coisas:

Ele cria dois objetos Car: um carro moderno e um carro clássico.
Ele chama nossos métodos accelerate e brake recém-adicionados no objeto carro moderno.
Ele usa os métodos getMakeAndModel e isAntique no objeto carro clássico.
Ele cria um array de objetos Car e usa um loop for-each para iterar sobre eles, demonstrando como podemos lidar com coleções de objetos.

Salve ambos os arquivos e, em seguida, compile e execute o programa CarDemo:
```
javac ~/project/Car.java ~/project/CarDemo.java
java -cp ~/project CarDemo
```
Você deve ver uma saída semelhante a esta:
```
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
The Toyota Corolla is accelerating.
The Toyota Corolla is braking.
Ford Mustang is an antique: true
Toyota Corolla is an antique: false
Ford Mustang is an antique: true
```
Parabéns! Você estendeu significativamente sua classe Car e criou um programa mais intrincado usando objetos. Isso demonstra como a programação orientada a objetos pode ser usada para modelar conceitos do mundo real em código. Cada objeto carro agora possui seus próprios dados (marca, modelo, ano) e ações (acelerar, frear, etc.), assim como os carros reais.
Adicionamos métodos à nossa classe Car que representam ações (accelerate() e brake()). Embora esses métodos não alterem o estado do carro em nossa implementação atual, em um programa mais complexo, eles poderiam modificar atributos como velocidade ou nível de combustível.
Adicionamos getMakeAndModel(), que combina duas informações em uma única string. Este é um padrão comum na programação orientada a objetos — criar métodos que oferecem acesso conveniente aos dados do objeto.
O método isAntique() mostra como os dados do objeto (o ano do carro) podem ser combinados com informações externas (o ano atual) para derivar novas informações sobre um objeto.
Em nossa classe CarDemo, demonstramos como criar e usar vários objetos, como chamar vários métodos nesses objetos e como iterar em um array de objetos.

Este exemplo demonstra o poder da programação orientada a objetos. Criamos uma classe Car que encapsula dados (marca, modelo, ano) e comportamento (acelerar, frear, isAntique). Cada objeto Car que criamos é independente, com seu próprio conjunto exclusivo de dados, mas todos seguem o mesmo conjunto de ações conforme definido pela classe.

Resumo

Neste laboratório, fizemos um progresso substancial em nossa jornada de programação Java. Cobrimos alguns conceitos básicos, mas essenciais, que são fundamentais para escrever programas Java mais complexos e organizados. Vamos resumir o que aprendemos:

Métodos:
- Criamos e usamos métodos para estruturar nosso código e torná-lo mais reutilizável.
- Exploramos como os métodos podem aceitar parâmetros e retornar valores, permitindo que dividamos problemas complexos em tarefas menores e gerenciáveis.
- Os métodos nos ajudam a reduzir a repetição de código e tornam nossos programas mais fáceis de compreender e manter.
Classes e Objetos:
- Apresentamos o conceito de classes como modelos para criar objetos.
- Construímos uma classe Car com atributos (marca, modelo, ano) e métodos (displayInfo, accelerate, brake, etc.).
- Aprendemos como instanciar objetos (instâncias de uma classe) e invocar métodos nesses objetos.
Programação Orientada a Objetos:
- Observamos como a programação orientada a objetos nos permite modelar ideias do mundo real em nosso código.
- Encapsulamos dados (atributos) e comportamento (métodos) dentro de nossa classe Car.
- Criamos vários objetos Car, demonstrando como cada objeto tem seu próprio conjunto de dados, mas compartilha as mesmas ações definidas pela classe.
Funcionalidade de Classe Aprimorada:
- Expandimos nossa classe Car com métodos mais complexos, incluindo um que utiliza as ferramentas de data integradas do Java para determinar se um carro é antigo.
- Vimos como os métodos podem interagir com dados de objetos e informações externas para gerar novas informações.
Trabalhando com Vários Objetos:
- Criamos um array de objetos Car, demonstrando como trabalhar com coleções de objetos em nossos programas.

Esses conceitos formam a base da programação Java e são essenciais para criar aplicativos maiores e mais complexos. À medida que você continua sua jornada Java, você se verá utilizando esses conceitos repetidamente.

Lembre-se, dominar a programação requer prática consistente. Aqui estão algumas ideias para estender seu aprendizado:

Tente adicionar mais atributos à classe Car, como color ou mileage.
Crie métodos que modifiquem esses atributos, como paint(String newColor) ou drive(int miles).
Crie uma classe Garage que possa armazenar vários objetos Car. Adicione métodos para adicionar carros à garagem, remover carros e exibir todos os carros na garagem.
Experimente criar classes para outros tipos de objetos, como Book ou Student.

Continue codificando, continue explorando e, o mais importante, continue se divertindo! Você está no caminho certo para se tornar um programador Java proficiente.

Métodos Java e Programação Orientada a Objetos Básica

Introdução

Entendendo e Criando Métodos

Introdução a Classes e Objetos

Aprimorando Nossa Classe com Mais Métodos

Resumo