Mas o que diabos é Java?

Ok, decidi que vou aprender Java. Me dediquei mais uma semana no bootcamp que selecionei e fiz anotações. Show. Ótimo.

Mas o que é Java, na real?
Confesso que escrever sobre isso faz com que eu me sinta um pouco bobo, porque a maior parte das pessoas que tem contato com programação tem uma ideia sobre o que é Java, mas vem comigo: O começo dessa viagem pode ser lento, mas prometo que vai ficar melhor mais pra frente.

Java é uma linguagem de alto nível, orientada a objetos, com tipagem forte e estática, que é compilada e interpretada.

Também é conhecida por ter o mascote mais horroroso do mundo.

Mas o que esse monte de palavras quer dizer na prática?
Ela ser orientada a objetos quer dizer que, além de seguir os pilares do paradigma, para qualquer coisa que queira fazer, é necessário definir uma classe.
Ou seja, para escrever o famoso Hello world, em vez de fazer algo assim:

console.log("Hello world")

É necessário fazer assim:

public class HelloWorld(){
    public static void main(String[] args){
        System.out.println("Hello world")
    }
}

Parece um contrassenso com o que eu disse no primeiro post, de economizar palavras sempre que possível -- e é mesmo: uma das coisas que mais me incomodam no Java é essa verbosidade excessiva. Mas vamos ignorar isso por enquanto e focar nas coisas boas da linguagem: a definição de tipos e regras claras e estruturadas para o desenvolvimento.

Enquanto que as variáveis em linguagens com tipagem fraca e dinâmica podem ser alteradas ao bel prazer do desenvolvedor, no caso de linguagens com tipagem forte e estática as variáveis devem ter seus tipos definidos no ato da declaração, e não podem ter esse valor alterado durante o ciclo de vida do algoritmo. Por exemplo, enquanto que no JavaScript isso é perfeitamente válido:

let myString = "Hello";

myString = 10;

Para declarar uma variável em Java, a sintaxe é essa:

String myString = "Henlo fren";

myString = 10 //Required type: String, Provided: int

Esse tipo de alteração de tipos não é permitido e quando algo assim é feito, o compilador do Java reclama e aponta um erro. Esse tipo de verificação estática (o mesmo tipo de verificação que o TypeScript faz, por exemplo) é ótima porque salva o desenvolvedor de cometer erros que só seriam descobertos quando a aplicação estivesse rodando.

Mas o negócio de ser compilado e interpretado deu um nó na minha cabeça. Durante muito tempo eu tinha uma visão mais simples das coisas, que as linguagens se dividiam em "interpretadas" (como JavaScript e Python) e "compiladas" (como Java e C). Mas o lance do Java é que o código-fonte (ou seja, o que o dev escreve) é compilado para um código intermediário, que será lido por uma máquina virtual e interpretado, "traduzindo" para linguagem de máquina.

Mais ou menos isso aí.

Esse ciclo foi o que possibilitou o famoso slogan do Java Write Once, Run Everywhere (Escreva uma vez, rode em todos os lugares). A JVM (Java Virtual Machine) pode ser colocada em qualquer lugar para rodar programas em Java, como caixas eletrônicos, computadores de bordo e até em leitores de Blu-ray.

Mas claro que para poder estar presente em tantos dispositivos assim, o que o desenvolvedor escreve precisa estar bem padronizado para que o processo de compilação ocorra sem problemas -- e essa é uma das características do Java: existem muitas regras e convenções que estão lá para tornar o código mais simples e limpo. Por exemplo, as classes precisam ser definidas dentro do diretório src do projeto. O nome da classe precisa ser o mesmo nome do arquivo .java. As variáveis e métodos devem seguir camelCase, mas os nomes de classe devem seguir PascalCase.
Muitas regrinhas que parecem bestas, mas quando somadas fazem com que tudo seja mais organizado.

Para fechar o módulo introdutório e sair só da teoria, foi passado um exercício: Criar uma classe para representar uma smart TV, com as seguintes características:

1. Ela teve ter as propriedades ligada (boolean), canal (int) e volume (int);
2. A TV deve poder ligar e desligar, alterando a propriedade ligada;
3. A TV poderá aumentar e diminuir o volume, em incrementos de 1;
4. A TV poderá aumentar e diminuir o canal atual, em incrementos de 1 ou definir um número específico para o canal.

Essa classe (muito criativamente chamada de SmartTv) deve ser definida em um arquivo SmartTv.java. Não tenho muito o que falar sobre ela, é uma classe relativamente simples de entender.

/**  
 * The SmartTv class represents a smart TV device. 
 * It allows the user to control the power state, channel number, and volume of the TV. 
 * 
 * @author Lucas Nabesima  
 * @version 1.0  
 * @since 31/07/2024  
 */
public class SmartTv {  
    private boolean isOn;  
    private int channelNumber;  
    private int volume;  

    public SmartTv() {  
        this.isOn = false;  
        this.channelNumber = 1;  
        this.volume = 1;  
    }  

    public void turnOn() {  
        System.out.println("TV is turning on...");  
        this.isOn = true;  
        System.out.println("TV is on.");  
    }  

    public void turnOff() {  
        System.out.println("TV is turning off...");  
        this.isOn = false;  
        System.out.println("TV is off.");  
    }  

    public void channelUp() {  
        this.channelNumber++;  
        System.out.println("Channel changed to: " + this.channelNumber);  
    }  

    public void channelDown() {  
        if (this.channelNumber <= 1) {  
            System.out.println("Can't lower channel number.");  
            return;  
        }  
        this.channelNumber--;  
        System.out.println("Channel changed to: " + this.channelNumber);  
    }  

    public void setChannelNumber(int channelNo) {  
        this.channelNumber = channelNo;  
        System.out.println("Channel changed to: " + this.channelNumber);  
    }  

    public void volumeUp() {  
        this.volume++;  
        System.out.println("Volume changed to: " + this.volume);  
    }  

    public void volumeDown() {  
        if (this.volume <= 0) {  
            System.out.println("Can't lower volume.");  
            return;  
        }  
        this.volume--;  
        System.out.println("Volume changed to: " + this.volume);  
    }  
}

"Ain Lucas o que são esses public e void?
public é um modificador de acesso. Isso quer dizer que o que quer que esteja acompanhado por ele é público, então qualquer um pode passar a mão está acessível para outras classes e métodos. Outros modificadores incluem private, que indica que somente aquela classe tem acesso e protected. Nesse último caso, somente a classe e seus descendentes têm acesso.

Já o void nesses métodos indicam que essas funções não tem retorno. Todos os métodos precisam ter uma anotação que informa qual o tipo de seu retorno. Pode ser um dos tipos primitivos da linguagem (int, byte, short, long, float, double, boolean ou char), pode ser void indicando que aquele método não tem retorno, um objeto padrão (como String) ou outra coisa completamente diferente -- como um objeto definido pelo dev.

Para utilizar essa classe, basta instanciar no nosso método main:

public class Main {  
    public static void main(String[] args) {  
        SmartTv tv = new SmartTv();  

        tv.turnOn();  

        tv.channelUp();  
        tv.channelDown();  
        tv.channelDown();  

        tv.volumeUp();  
        tv.volumeDown();  
        tv.volumeDown();  
        tv.volumeDown();  

        tv.setChannelNumber(13);  

        tv.turnOff();  
    }  
}

E o resultado será esse:

Até a semana que vem, com mais um módulo!