A programação orientada à objetos oferece uma forma sustentável de escrever código espaguete. Ela permite que você escreva programas como se fosse uma colcha de retalhos.
― Paul Graham

Princípios de programação orientada a objetos

A programação orientada a objetos é um paradigma de programação onde tudo é representado como um objeto.

Objetos passam mensagens uns para os outros. Cada objeto decide o que fazer com uma mensagem recebida. A POO (em inglês, OOP - Object Oriented Programming) foca nos estados e comportamentos de cada objeto.

O que são objetos?

Um objeto é uma entidade que possui estados e comportamentos.

Por exemplo, cão, gato e veículo. Para ilustrar, um cão possui estados como idade, cor, nome e comportamentos como comer, dormir e correr.

Os estados nos dizem como o objeto se parece ou quais propriedades ele possui.

O comportamento nos diz o que o objeto faz.

Podemos representar um cão do mundo real em um programa como um objeto de software definindo seus estados e comportamentos.

Objetos de software são uma representação de um objeto do mundo real. É alocado espaço em memória sempre que um objeto lógico é criado.

Um objeto pode também ser referenciado como uma instância de uma classe. Instanciar uma classe significa a mesma coisa que criar um objeto.

Algo importante de se lembrar quando estamos criando um objeto é: o tipo de referência deve ser do mesmo tipo ou um supertipo do tipo do objeto. Veremos o que é um tipo de referência mais a frente neste artigo.

O que são classes?

Uma classe é um template - algo como a "planta" de uma construção - a partir do qual os objetos são criados.

Imagine uma classe como um cortador de biscoitos e os objetos como os próprios biscoitos.

Classes definem estados como variáveis de instância e comportamentos como métodos de instância.

Variáveis de instância também são conhecidas como "variáveis membro".

Classes não consomem espaço em memória.

Para dar uma ideia sobre classes e objetos, vamos criar uma classe Cat (Gato) que representa estados e comportamentos de um gato no mundo real.

public class Cat {
    /*
    Variáveis de instancia: Estados do gato
     */
    String name;
    int age;
    String color;
    String breed;

    /*
    Métodos de instancia: Comportamento do gato
     */
    void sleep(){
        System.out.println("Dormindo");
    }
    void play(){
        System.out.println("Brincando");
    }
    void feed(){
        System.out.println("Comendo");
    }

}

Agora que definimos um template de gatos, vamos dizer que temos dois gatos, chamados Thor e Rambo.

Como podemos defini-los em nossos programas?

Primeiro, precisamos criar dois objetos da classe Cat.

public class Main {
    public static void main(String[] args) {
       Cat thor = new Cat();
       Cat rambo = new Cat();
    }
}

Agora, vamos definir seus estados e comportamentos.

public class Main {

    public static void main(String[] args) {
       /*
       Criando os objetos
        */
       Cat thor = new Cat();
       Cat rambo = new Cat();

       /*
       Definindo o gato Thor
        */
       thor.name = "Thor";
       thor.age = 3;
       thor.breed = "Azul russo";
       thor.color = "Marrom";

       thor.sleep();

       /*
       Definindo o gato Rambo
        */
       rambo.name = "Rambo";
       rambo.age = 4;
       rambo.breed = "Maine Coon";
       rambo.color = "Marrom";

       rambo.play();
    }

}

Como nos exemplos de código acima, podemos definir nossas classes, instanciá-las (criar objetos) e especificar os estados e comportamentos para esses objetos.

Até aqui já cobrimos o básico de orientação a objetos. Vamos avançar para os princípios da orientação a objetos.

Princípios da programação orientada a objetos

Esses são os quatro princípios fundamentais do paradigma de programação orientada a objetos. Entendê-los é essencial para se tornar um programador de sucesso.

1. Encapsulamento
2. Herança
3. Abstração
4. Polimorfismo

Agora, vamos dar uma olhada neles com mais detalhes.

Encapsulamento

Encapsulamento é um processo de envolver dados e código em uma única unidade.

É como uma capsula que possui uma mistura de diversos medicamentos, é uma técnica que ajuda a manter as variáveis de instância protegidas.

Essa proteção pode ser conquistada utilizando o modificador de acesso private, que indica que a variável ou dado não pode ser acessado de fora da classe. Para acessar estados privados de modo seguro, temos que providenciar métodos getters e setters públicos (em Java, esses métodos devem seguir os padrões de nomenclatura "JavaBeans").

Digamos que existe uma loja de discos que vende álbuns de músicas de diferentes artistas e um estoque para o gerenciamento.

Se você observar a figura 4, a classe StockKeeper pode acessar os estados da classe Album diretamente, já que os atributos da classe Album estão definidos como public (sinal de +).

Se o gerenciador de estoque criar um álbum e definir seus estados como negativos, ele pode acabar fazendo isso mesmo que sem intenção.

Para ilustrar, vamos ver um exemplo de um programa em Java que explica o diagrama e a afirmação acima.

Classe Album:

public class Album {
    public String name;
    public String artist;
    public double price;
    public int numberOfCopies;
    public void sellCopies(){
        if(numberOfCopies > 0){
            numberOfCopies--;
            System.out.println("Um album foi vendido!");
        }
        else{
            System.out.println("Não há albuns disponíveis!");
        }
    }
    public void orderCopies(int num){
        numberOfCopies += num;
    }
}

Classe StockKeeper:

public class StockKeeper {
    public String name;
    public StockKeeper(String name){
        this.name = name;
    }
    public void manageAlbum(Album album, String name, String artist, double price, int numberOfCopies){
      /*
       Definindo os estados e comportamentos para album
       */
        album.name = name;
        album.artist = artist;
        album.price = price;
        album.numberOfCopies = numberOfCopies;

       /*
       Imprimindo os detalhes do album
        */
        System.out.println("Album gerenciado por :"+ this.name);
        System.out.println("Detalhes do album::::::::::");
        System.out.println("Nome do album: " + album.name);
        System.out.println("Artista do Album : " + album.artist);
        System.out.println("Preço do Album : " + album.price);
        System.out.println("Número de cópias do album : " + album.numberOfCopies);
    }
}

Classe Main:

public class Main {
    public static void main(String[] args) {
       StockKeeper johnDoe = new StockKeeper("John Doe");
       /*
       O gerenciador de estoque cria um album e atribui valores negativos para o preço e o numero de cópias disponíveis
        */
       johnDoe.manageAlbum(new Album(), "Slippery When Wet", "Bon Jovi", -1000.00, -50);
    }
}

Saída:

Album gerenciado por :John Doe
Detalhes do album::::::::::
Nome do album : Slippery When Wet
Artista do Album : Bon Jovi
Preço do Album :  -1000.0
Número de cópias do album : -50

O preço do álbum e número de cópias não podem ser valores negativos. Como podemos evitar essa situação? Aqui é onde usamos o encapsulamento.

Neste cenário, podemos impedir o gerenciador de estoque de atribuir valores negativos. Se ele tentar atribuir valores negativos para o preço e o número de cópias do álbum, definiremos 0.0 como o valor e 0 como o número de cópias.

Classe Album:

public class Album {
    private String name;
    private String artist;
    private double price;
    private int numberOfCopies;
    public void sellCopies(){
        if(numberOfCopies > 0){
            numberOfCopies--;
            System.out.println("Um álbum foi vendido!");
        }
        else{
            System.out.println("Nenhum álbum disponível!");
        }
    }
    public void orderCopies(int num){
        numberOfCopies += num;
    }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getArtist() {
      return artist;
   }
   public void setArtist(String artist) {
      this.artist = artist;
   }
   public double getPrice() {
      return price;
   }
   public void setPrice(double price) {
      if(price > 0) {
         this.price = price;          
      }
      else {
         this.price = 0.0;
      }
   }
   public int getNumberOfCopies() {
      return numberOfCopies;
   }
   public void setNumberOfCopies(int numberOfCopies) {
      if(numberOfCopies > 0) {
         this.numberOfCopies = numberOfCopies;        
      }
      else {
         this.numberOfCopies = 0;
      }
   }
}

Classe StockKeeper:

public class StockKeeper {
    private String name;
    StockKeeper(String name){
        setName(name);
    }
    public void manageAlbum(Album album, String name, String artist, double price, int numberOfCopies){
         /*
          Definindo estados e comportamentos para o album
          */
        album.setName(name);
        album.setArtist(artist);
        album.setPrice(price);
        album.setNumberOfCopies(numberOfCopies);
          /*
          Imprimindo os detalhes do album
           */
        System.out.println("Album gerenciado por :"+ getName());
        System.out.println("Detalhes do album::::::::::");
        System.out.println("Nome do album : " + album.getName());
        System.out.println("Artista do Album : " + album.getArtist());
        System.out.println("Preço do Album : " + album.getPrice());
        System.out.println("Número de cópias do album : " + album.getNumberOfCopies());
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Classe Main:

public class Main {
    public static void main(String[] args) {
       StockKeeper johnDoe = new StockKeeper("John Doe");
       /*
       Gerenciador de estoque cria um album e atribui valores negativos para o preço e o número de cópias disponíveis do album
        */
       johnDoe.manageAlbum(new Album(), "Slippery When Wet", "Bon Jovi", -1000.00, -50);
    }
}

Saída:

Album gerenciado por :John Doe
Detalhes do album::::::::::
Nome do album : Slippery When Wet
Artista do Album : Bon Jovi
Preço do Album : 0.0
Número de cópias do album : 0

Com o encapsulamento, impedimos nosso gerenciador de estoque de definir valores negativos, o que significa que temos o controle sobre as informações.

Vantagens do encapsulamento em Java

1. Podemos fazer uma classe somente leitura ou somente escrita. Para uma classe somente leitura, temos que informar apenas os métodos getters. Para uma classe somente escrita, devemos informar apenas os métodos setters.
2. Controle sobre os dados: podemos controlar os dados adicionando lógica nos métodos setters, assim como fizemos para evitar que o gerenciador de estoques definisse valores negativos nos exemplos acima.
3. Proteção dos dados: outras classes não podem acessar membros privados de uma classe diretamente.

Herança

Consideremos que a loja de discos que falamos anteriormente também venda filmes em Blu-ray.

Como você pode ver no diagrama acima, existem muitos estados e comportamentos em comum (código duplicado) entre Album e Movie.

Quando for transformar esse diagrama de classes em código, você vai reescrever/copiar todo o código novamente para Movie? Caso você faça isso, você estará se repetindo. Como você pode evitar a duplicação de código?

Aqui é onde usamos a herança.

Herança é um mecanismo onde um objeto recebe todos os comportamentos e estados de um objeto pai.

A herança utiliza um relacionamento de pais e filhos (relacionamento "É um" ).

Então o que exatamente é herdado?

Visibilidade/modificadores de acesso impacta o que pode ser herdado de uma classe para a outra.

Em Java, como regra fundamental, tornamos as varáveis de instância private e os métodos de instância public.

Neste caso, certamente podemos dizer que o seguinte será herdado:

1. métodos públicos de instância.
2. variáveis de instância privadas (que podem ser acessadas apenas por meio de métodos getters e setters públicos) .

Tipos de herança no Java

Existem cinco tipos diferentes de herança no Java. Elas são:  simples, multinível, hierárquica, múltipla e híbrida.

Classes permitem heranças simples, multinível e hierárquicas. Interfaces permitem heranças múltiplas e híbridas.

Uma classe pode estender apenas uma classe. Entretanto, não há limite para a implementação de interfaces. Uma interface pode estender mais de uma interface.

Relacionamentos

I. Relacionamento É UM

Um relacionamento É UM refere-se à herança ou implementação.

a. Generalização

Generalização usa um relacionamento É UM de uma classe especializada para uma classe generalizada.

II. Relacionamento TEM UM

Uma instância de uma classe TEM UMA referência para uma instância de outra classe.

a. Agregação

Neste relacionamento, a existência de uma classe A e B não são dependentes umas das outras.

Para essa parte de agregação, vamos ver um exemplo da classe Student e da classe ContactInfo.

class ContactInfo {
    private String homeAddress;
    private String emailAddress;
    private int telephoneNumber; //12025550156
}
public class Student {
    private String name;
    private int age;
    private int grade;
    private ContactInfo contactInfo;//Student TEM UM ContactInfo
    public void study() {
        System.out.println("Study");
    }
}

Student (aluno) TEM UMA ContactInfo (informação de contato). ContactInfo pode ser usado em outros lugares – por exemplo, uma classe Employee (funcionário) de um companhia também poderia utilizar a classe ContactInfo. Assim, Student pode existir sem ContactInfo e ContactInfo pode existir sem Student. Este tipo de relacionamento é conhecido como agregação.

b. Composição

Neste relacionamento, a classe B não pode existir sem uma classe A – mas a classe A pode existir sem a classe B.

Para dar uma ideia sobre composição, vamos ver esse exemplo da classe Student e a classe StudentId.

class StudentId {
    private String idNumber;//A-123456789
    private String bloodGroup;
    private String accountNumber;
}
public class Student {
    private String name;
    private int age;
    private int grade;
    private StudentId studentId;//Student TEM UM StudentId
    public void study() {
        System.out.println("Study");
    }
}

Student TEM UM StudentId. Student pode existir sem StudentId, mas StudentId não pode existir sem Student. Esse tipo de relacionamento é conhecido como composição.

Agora, vamos voltar para nosso exemplo da loja de discos que discutimos acima.

Podemos implementar esse diagrama em Java para evitar duplicação de código.

Vantagens de se usar herança

1. Reaproveitamento de código: as classes filhas herdam todos os membros de instância da classe pai.
2. Você tem mais flexibilidade de mudar o código: mudar o código em um lugar é o suficiente.
3. Você pode usar polimorfismo: a sobrescrita de métodos requer um relacionamento É UM.

Abstração

Abstração é o processo de esconder os detalhes de implementação e exibir apenas as funcionalidades para o usuário.

Um exemplo comum de abstração é o acelerador do carro: pisando mais forte, você aumenta a velocidade. Os motoristas, no entanto, não sabem como essa ação altera a velocidade – eles não precisam saber.

Tecnicamente, abstrato significa algo incompleto ou a ser finalizado no futuro.

Em Java, podemos obter abstração de duas maneiras: classes abstratas (0% a 100%) e interfaces (100%).

A palavra-chave abstract pode ser aplicada à classes e métodos. abstract e final ou static nunca podem estar juntas.

I. Classes abstratas

Uma classe é abstrata quando ela contém a palavra reservada abstract.

Classes abstratas não podem ser instanciadas  (não é possível criar objetos de classes abstratas). Elas podem ter construtores, métodos estáticos e métodos finais.

II. Métodos abstratos

Um método é abstrato quando ele contém a palavra chave abstract.

Um método abstrato não possui implementação (não possui um corpo e termina com ponto e virgula). Métodos abstratos não devem ser marcados como private.

III. Classes abstratas e métodos abstratos

• Se pelo menos um método for abstrato dentro de uma classe, então toda a classe deve ser abstrata.
• É possível ter uma classe abstrata sem nenhum método abstrato.
• Podemos ter qualquer quantidade de métodos abstratos e não abstratos ao mesmo tempo na mesma classe.
• A primeira classe concreta que herde de uma classe abstrata deve prover implementação para todos os métodos abstratos.
• Caso a subclasse não implemente os métodos abstratos da superclasse, ela deve também ser marcada como abstrata.

Em um cenário real, a implementação vai ser feita por alguém desconhecido ao usuário final. Usuários não conhecem a classe de implementação nem os detalhes da implementação.

Vamos considerar um exemplo de uso do conceito de classes abstratas.

abstract class Shape {
    public abstract void draw();
}
class Circle extends Shape{
    public void draw() {
        System.out.println("Círculo!");
    }
}
public class Test {
    public static void main(String[] args) {
        Shape circle = new Circle();
        circle.draw();
    }
}

Quando vamos querer marcar uma classe como abstrata?

1. Para forçar subclasses a implementar métodos abstratos.
2. Para impedir que existam objetos daquela classe.
3. Para manter a referência à uma classe.
4. Para manter código comum.

Interface

Uma interface é um template (ou uma "planta" de construção) de uma classe.

Uma interface é 100 abstrata. Construtores não são permitidos aqui. A interface representa o relacionamento "É UM".

Observação: interfaces apenas definem quais os métodos necessários. Não podemos manter código comum.

Uma interface possui apenas métodos abstratos, não possui métodos concretos. Os métodos da interface são, por padrão, public e abstract. Então, dentro da interface, não precisamos especificar as palavras-chaves public e abstract.

Então, quando uma classe implementa um método da interface sem especificar os modificadores de acesso daquele método, o compilador vai lançar uma exceção dizendo "Cannot reduce the visibility of the inherited method from interface" (Não é possível reduzir a visibilidade de um método herdado de uma interface). Sendo assim, o modificador de acesso de um método implementado de uma interface deve ser public.

Por padrão, as variáveis de interface são public, static e final.

Por exemplo:

interface Runnable {
    int a = 10; //equivale a: public static final int a = 10;
    void run(); //equivale a: public abstract void run();
}
public class InterfaceChecker implements Runnable{
    public static void main(String[] args) {
        Runnable.a = 5;//o valor do campo final Runnable.a não pode ser reatribuido.
    }
}

Vamos ver um exemplo que explica o conceito de interface:

interface Drawable {
    void draw();
}
class Circle implements Drawable{
    public void draw() {
        System.out.println("Círculo!");
    }
}
public class InterfaceChecker {
    public static void main(String[] args) {
        Drawable circle = new Circle();
        circle.draw();
    }
}

Métodos default e métodos estáticos nas Interfaces

Normalmente, implementamos os métodos de uma interface em classes separadas. Digamos que seja necessário adicionar um novo método à interface. Então, deveremos implementar esse método em todas as outras classes que implementam essa interface também.

Para evitar esse tipo de problema, a partir do Java, 8 foi introduzida a possibilidade de implementar métodos default e estáticos dentro de uma interface, além dos métodos abstratos.

• Método default

public interface DefaultInterface {
    void sleep();
    default void run() {
        System.out.println("Estou correndo!");
    }
}
public class InterfaceCheckers implements DefaultInterface{
    public void sleep() {
        System.out.println("Dormindo...");
    }
    public static void main(String[] args) {
        InterfaceCheckers checker = new InterfaceCheckers();
        checker.run();
        checker.sleep();
    }
}
/*
Saída:
Estou correndo!
Dormindo...
 */

• Métodos estáticos

Assim como métodos estáticos de classes, nós podemos chamá-los usando o nome da interface.

public interface DefaultInterface {
    void sleep();
    static void run() {
        System.out.println("Estou correndo!");
    }
}
public class InterfaceCheckers implements DefaultInterface{
    public void sleep() {
        System.out.println("Dormindo...");
    }
    public static void main(String[] args) {
        InterfaceCheckers checker = new InterfaceCheckers();
        DefaultInterface.run();
        checker.sleep();
    }
}
/*
Saída:
Estou correndo!
Dormindo...
 */

• Interface de marcação

São interfaces vazias. Por exemplo as interfaces Serializable, Cloneable e Remote.

public interface Serializable 
{
  //Sem campos ou métodos
}

Vantagens das interfaces

• Nos ajudam a utilizar herança múltipla no Java.
• Elas fornecem abstração.
• Elas fornecem baixo acoplamento: os objetos são independentes uns dos outros.

Quando vamos querer mudar de uma classe para uma interface?

1. Para forçar subclasses a implementar métodos abstratos.
2. Para evitar a criação de objetos dessa classe.
3. Para manter a referência à uma classe.

Observação: lembre-se de que não podemos manter código comum dentro de uma interface.

Caso você queira definir métodos que podem ser necessários e código comum, use uma classe abstrata.

Caso queira apenas definir métodos necessários, use uma interface.

Polimorfismo

Polimorfismo é a habilidade de um objeto de assumir diversas formas.

Polimorfismo em POO acontece quando uma superclasse faz referência a um objeto de uma subclasse.

Todos os objetos do Java são considerados polimórficos já que eles compartilham mais de um relacionamento É UM (pelo menos, todos os objetos vão passar no teste É UM para seu próprio tipo e para a classe Object).

Podemos acessar um objeto através de uma variável de referência. Uma variável de referência pode ser apenas de um tipo. Após declarada, o tipo da variável de referência não pode ser alterado.

Uma variável de referência pode ter uma classe ou uma interface como tipo.

Um único objeto pode ser referenciado por variáveis de referência de diversos tipos (desde que esses tipos estejam na mesma hierarquia), sendo o objeto do mesmo tipo da variável de referência ou de uma superclasse.

Sobrecarga de métodos

Se uma classe possui vários métodos, que possuem o mesmo nome mas parâmetros diferentes, isso é conhecido como sobrecarga de métodos (method overload).

Regras da sobrecarga de métodos:

1. Precisa ter uma lista de parâmetros diferente.
2. Pode possuir tipos de retorno diferentes.
3. Pode possuir modificadores de acesso diferentes.
4. Pode lançar exceções diferentes.

class JavaProgrammer{
    public void code() {
        System.out.println("Programando em C++");
    }
    public void code(String language) {
        System.out.println("Programando em " + language);
    }
}
public class MethodOverloader {
    public static void main(String[] args) {
        JavaProgrammer gosling = new JavaProgrammer();
        gosling.code();
        gosling.code("Java");
    }
}
/*
Saída:
Programando em C++
Programando em Java
 */

Observação: métodos estáticos também podem sofrer sobrecarga.

class Addition {
    public static int add(int a,int b) {
        return a+b;
    }
    public static int add(int a,int b,int c) {
        return a+b+c;
    }
}
public class PolyTest {
    public static void main(String[] args) {
        System.out.println(Addition.add(5, 5));
        System.out.println(Addition.add(2, 4, 6));
    }
}

Observação: podemos sobrecarregar o método main(), mas a JVM (Java Virtual Machine) vai chamar o método main() que recebe um array de strings como parâmetro.

public class PolyTest {
    public static void main() {
        System.out.println("main()");
    }
    public static void main(String args) {
        System.out.println("String args");
    }
    public static void main(String[] args) {
        System.out.println("String[] args");
    }
}
//Saída: String[] args

Regras a seguir para o polimorfismo

Regras de tempo de compilação

1. O compilador conhece apenas tipos de referência.
2. Ele só pode procurar métodos em tipos de referência.
3. Gera uma assinatura de método.

Regras de tempo de execução

1. Em tempo de execução, a JVM segue o tipo de tempo de execução exato (tipo de objeto) para localizar o método.
2. Deve corresponder a assinatura do método de tempo de compilação ao método na classe real do objeto.

Sobrescrita de métodos

Se uma subclasse tem o mesmo método que foi declarado na superclasse, isso é conhecido como sobrescrita de métodos (method override).

Regras da sobrescrita de métodos:

1. Deve possuir a mesma lista de parâmetros.
2. Deve possuir o mesmo tipo de retorno: embora um retorno covariante nos permita alterar o tipo de retorno do método sobrescrito.
3. Não pode possuir um modificador de acesso mais restritivo: deve possuir um modificador de acesso menos restritivo.
4. Não deve lançar uma exceção verificada (checked exception) nova ou mais ampla: pode lançar exceções verificadas mais restritas e pode lançar qualquer exceção não verificada.
5. Apenas métodos herdados podem ser sobrescritos (é necessário um relacionamento É UM).

Exemplo de sobrescrita de método:

public class Programmer {
    public void code() {
        System.out.println("Programando em C++");
    }
}
public class JavaProgrammer extends Programmer{
    public void code() {
        System.out.println("Programando em Java");
    }
}
public class MethodOverridder {
    public static void main(String[] args) {
        Programmer ben = new JavaProgrammer();
        ben.code();
    }
}
/*
Saída:
Programando em Java
 */

Observação: métodos estáticos não podem ser sobrescritos porque métodos são sobrescritos em tempo de execução (runtime). Métodos estáticos são associados com classes, enquanto métodos de instância são associados com objetos. Então, em Java, o método main() não pode ser sobrescrito.

Observação: construtores podem ser sobrecarregados mas não podem ser sobrescritos.

Tipos de objeto e tipos de referência

class Person{
    void eat() {
        System.out.println("A pessoa está comendo");
    }
}
class Student extends Person{
    void study() {
        System.out.println("O estudante está estudando");
    }
}
public class InheritanceChecker {
    public static void main(String[] args) {
        Person alex = new Person();//New Person "É UMA" Person
        alex.eat();
        Student jane = new Student();//New Student "É UM" Student
        jane.eat();
        jane.study();
        Person mary = new Student();//New Student "É UM" Person
        mary.eat();
        //Student chris = new Person(); //New Person não É UM Student.
    }
}

Em Person mary = new Student(); esse modo de criar o objeto está correto.

mary é uma variável de referência do tipo Person e new Student() criará um novo objeto do tipo Student.

mary não pode acessar study() em tempo de compilação porque o compilador conhece apenas o tipo de referência. Já que study() não existe na classe do tipo de referência, não é possível acessá-lo. Em tempo de execução, no entanto, mary será do tipo Student (tipo de tempo de execução/tipo de objeto).

Veja esse artigo (texto em inglês) para entender melhor sobre tipos de tempo de execução.

Neste caso, podemos convencer o compilador dizendo "em tempo de execução, mary será do tipo Student, então permita-me chamar o método study()". Como podemos convencer o compilador a fazer isso? Aqui é onde usaremos o casting.

Podemos converter mary ao tipo Student em tempo de compilação e chamar study() se utilizarmos o casting.

((Student)mary).study();

Aprenderemos sobre casting a seguir.

Casting de tipos de objeto

O casting no Java é classificado em dois tipos:

1. Casting de ampliação (widening casting, implícito): conversão automática de tipos.
2. Casting de restrição (narrowing casting, explícito): precisa de uma conversão explícita.

Com primitivos, long é um tipo mais abrangente que int. Assim como ocorre com os objetos, a classe mãe é mais abrangente que a classe filha.

A variável de referência apenas faz referência a um objeto. Utilizar casting em uma variável de referência não muda o tipo do objeto em memória, mas rotula o mesmo objeto de uma outra maneira para se ter acesso aos membros de instância.

I. Widening casting (casting de ampliação)

Superclass superRef = new Subclass();

II. Narrowing casting (casting de restrição)

Subclass ref = (Subclass) superRef;

Temos que tomar cuidado quando utilizamos um casting restritivo. Quando utilizamos o casting restritivo, convencemos o compilador a compilar sem erros. Caso estejamos errados, receberemos um erro em tempo de execução (geralmente, ClassCastException).

Para executar um casting restritivo corretamente, usamos o operador instanceof. Com ele, podemos verificar se o relacionamento é do tipo É UM.

class A {
    public void display(){
        System.out.println("Class A");
    }
}

class B extends A{
    public void display(){
        System.out.println("Class B");
    }
}

public class Test {
    public static void main(String[] args) {
        A objA = new B();
        if(objA instanceof B){
            ((B)objA).display();
        }
    }
}
/**
 * Saída: Class B
 */

Como eu disse anteriormente, devemos sempre nos lembrar de uma coisa muito importante quando criamos um objeto utilizando a palavra-chave new: o tipo de referência deve ser do mesmo tipo ou de um supertipo do objeto sendo criado.

Conclusão

Obrigado por ler este artigo. Espero que ele tenha ajudado.

Recomendo fortemente a leitura de mais artigos relacionados à POO.

Confira, também, a série original de artigos do autor no medium: Princípios de orientação a objetos em Java (texto em inglês).

Sonhos não são o que você vê quando está dormindo. Eles são o que não deixa você dormir.
― A P J Abdul Kalam, Asas de fogo: autobiografia

Obrigado.

Bons estudos!

Você provavelmente já ouviu falar da Amazon Web Services e do desafio #AWSCertified. Mas você sabia que a Microsoft também é uma cloud provider?

Após passar em 3 certificações da AWS, eu queria aprender novas coisas e começar com um novo cloud provider: o Azure.

Meus objetivos eram compreender como o Azure funciona e também obter uma nova certificação. Eu resolvi fazer a primeira prova, AZ-900: Microsoft Azure Fundamentals, para ter uma transição tranquila da AWS para o Azure.

Neste artigo, eu vou explicar as certificações Azure e também como obter uma certificação Microsoft.

Vamos começar.

O que é Azure?

Antes de explicar as certificações Microsoft, farei uma breve introdução ao Azure.

Azure é a plataforma de computação em nuvem da Microsoft. Com ela, você tem a liberdade de construir, gerenciar e publicar aplicações em uma gigantesca rede mundial usando suas ferramentas e frameworks preferidos.

As capacidades do Azure podem ser divididas em 8 principais categorias:

1. Compute Services (Serviços de computação)
2. Cloud Storage (Armazenamento em nuvem)
3. Networking (Redes)
4. App Hosting (Hospedagem de aplicativos)
5. Artificial Intelligence (Inteligência artificial)
6. Internet of Things (Internet das coisas)
7. Integration (Integrações)
8. Security (Segurança)

Certificações Microsoft

A Microsoft oferece certificações em diversos produtos: Azure, Dynamics 365, Microsoft 365, Office, Power Platform, SQL Server e Windows.

Se considerarmos apenas o Azure, nós temos 13 certificações diferentes, agrupadas em duas categorias:

• Aplicativos e Infraestrutura
• Dados e Inteligência Artificial

Referentes aos seguintes cargos técnicos:

• Administração
• Engenharia de IA
• Engenharia de Dados
• Ciência de Dados
• Administração de Base de Dados
• Desenvolvimento
• Engenharia DevOps
• Engenharia de Segurança
• Arquitetura de soluções

Trilha de Certificação developer

Para cada certificação, você pode encontrar a trilha associada na documentação.

A trilha de certificação developer requer dois exames:

1. Exame AZ-900: Microsoft Azure Fundamentals (opcional)
2. Exame AZ-204: Developing Solutions for Microsoft Azure

Trilha de certificação Solutions Architect

A trilha de certificação Solutions Architect requer três exames:

• Exame AZ-900: Microsoft Azure Fundamentals (opcional)
• Exame AZ-300: Microsoft Azure Architect Technologies
• Exame AZ-301: Microsoft Azure Architect Design

Caso você esteja familiarizado com os exames da AWS, você provavelmente notou que, no Azure, não há o nível associado para o papel de arquiteto de soluções. Na tabela abaixo, eu mostro quais seriam os exames equivalentes entre a AWS e o Azure:

Foco na AZ-900: Microsoft Azure Fundamentals

A Microsoft diz que o objetivo deste exame é demonstrar um nível de conhecimento básico sobre serviços em nuvem e sobre como o Azure disponibiliza esses serviços.

Não é necessário ter experiência em TI pra fazer o exame. Tanto pessoas com experiência técnica, quanto pessoas sem experiência técnica podem fazer esse exame.

Quais habilidades são avaliadas durante o exame?

De acordo com a ementa da prova, as habilidades que serão testadas são as seguintes:

Descrever os conceitos de nuvem (15-20%)

• Descreva os benefícios e considerações de se utilizar serviços de nuvem
• Descreva as diferenças entre Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS) e Software-as-a-Service (SaaS)
• Descreva a diferença entre os modelos de nuvem Pública, Privada e Híbrida

Descrever os principais serviços do Azure (30-35%)

• Descreva os principais componentes arquiteturais do Azure
• Descreva alguns dos principais produtos disponibilizados pelo Azure
• Descreva algumas soluções disponibilizadas pelo Azure
• Descreva as ferramentas de gestão do Azure

Descrever segurança, privacidade, conformidade e confiança (25-30%)

• Descreva a proteção de conectividade de rede no Azure
• Descreva os principais serviços de Identidade do Azure
• Descreva as ferramentas e funcionalidade de segurança do Azure
• Descreva as metodologias de governança do Azure
• Descreva as opções de relatórios e monitoramento do Azure
• Descreva privacidade, conformidade e padrões de proteção de dados do Azure

Descreva os preços, contratos de nível de serviço e os ciclos de vida do Azure (20-25%)

• Descreva as assinaturas do Azure
• Descreva o planejamento e gerenciamento de custos
• Descreva os contratos de nível de serviço - Service Level Agreements (SLAs)
• Compreenda o ciclo de vida dos serviços no Azure

Quanto custa o exame?

Caso você tenha dado sorte de participar de algum Microsoft Azure Virtual Training Day: Fundamentals, você provavelmente ganhou um voucher que permite realizar a prova gratuitamente.

Caso contrário, atualmente, a prova custa US$ 60,00* (60 dólares americanos), e você pode agendar o exame utilizando a Pearson VUE.
* O preço é baseado no país ou na região em que o exame é realizado.

Como é o exame?

De acordo com o FAQ, você terá 60 minutos para responder entre 40 e 60 questões. Eu, no entanto, tive apenas 32 questões no meu exame. Foi uma bela surpresa!

O exame contém diversos tipos de questões:

• Diversas formas de múltipla escolha: uma resposta correta e três erradas, selecione a descrição correta, duas ou mais respostas corretas dentre cinco ou mais opções
• Arraste e solte: selecione a resposta e arraste para a descrição correta
• Área quente: responda as perguntas de uma maneira gráfica (capturas de tela, imagens ou diagramas)

Como se preparar para a prova?

Existem diversos recursos para ajudar você durante a preparação para a prova. A Microsoft recomenda utilizar sua plataforma on-line, o Microsoft Learn, onde são disponibilizadas diversas trilhas de aprendizados e módulos que você pode ler no seu ritmo gratuitamente.

A trilha de aprendizado Azure fundamentals é o curso recomendado para se preparar para o exame AZ-900. É um curso de 10 horas que contém 12 módulos:

1. Conceitos de Nuvem - Princípios de computação em nuvem
2. Criando uma conta no Azure
3. Principais Serviços de Nuvem - Introdução ao Azure
4. Principais Serviços de Nuvem - Arquitetura do Azure e garantias de serviço
5. Principais Serviços de Nuvem - Gerencie serviços com o portal do Azure
6. Principais Serviços de Nuvem - Opções de computação no Azure
7. Principais Serviços de Nuvem - Opções de armazenamento de dados no Azure
8. Principais Serviços de Nuvem - Opções de rede no Azure
9. Segurança, responsabilidade e confiabilidade no Azure
10. Aplique e monitore padrões de infraestrutura com as políticas do Azure
11. Controle e organize os serviços do Azure com o Azure Resource Manager
12. Preveja custos e otimize seus gastos com o Azure

Se você costuma assistir os cursos de Andrew Brown, vai se desapontar com o Microsoft Learn. Os módulos são texto puro sem nenhum vídeo. Esteja pronto para ler e fazer anotações!

Eu recomendo fortemente que você:

1. Crie uma conta gratuita
2. Leia a visão geral dos serviços Azure
3. Pratique por conta própria no Azure quickstarts
4. Monitore seu progresso com o skills outline
5. Faça exames práticos

A Microsoft explica o que você precisa saber para cada serviço em sua documentação. As explicações incluem, entre outras coisas, uma visão geral do serviço e quickstarts onde você pode experimentar para ter uma melhor visão do serviço.

Observação: utilizar o portal do Azure é o suficiente para praticar, já que esse não é um exame muito aprofundado.

Todos esses passos são suficientes para me fazer passar na AZ-900?

Esse exame não é difícil de passar! É preciso tempo e prática para se preparar, mas nada é impossível. O ponto chave é encontrar uma boa rotina de aprendizado e progredir passo a passo.

Diferenças do exame AWS Certified Cloud Practitioner

Você não deve subestimar o quanto de preparação é necessário só porque você já passou no exame AWS Certified Cloud Practitioner.

Você deve começar do começo porque 80% do exame valida o ecossistema do Azure, que é bem diferente daquele do AWS.

Não quero que você cometa os mesmos erros que eu cometi. Não compare cada novo serviço que você aprende com os da AWS. Isso vai deixar você mais confuso do que ajudar. Alguns serviços do Azure não possuem um equivalente na AWS e vice-versa.

Esqueça a AWS (enquanto estiver estudando) para aprender o Azure!

Alguma dúvida? Fique à vontade para conversar com o autor no Twitter ou diretamente no canal do Discord do freeCodeCamp. Ele ajudará você da melhor maneira possível.

Neste artigo, você vai aprender como configurar um ambiente de desenvolvimento com o live-reload habilitado. Com isso, você poderá fazer com que aplicações legadas usem Docker, volumes do Docker e o docker-compose.

Alguns desenvolvedores torcem o nariz quando o assunto é utilizar o Docker em seus ambientes de desenvolvimento. Eles dizem que o Docker não é bom para desenvolvimento, pois é preciso reconstruir a imagem toda hora para refletir as novas alterações. Isso torna o trabalho improdutivo e lento.

Neste artigo, nosso objetivo é combater esse pensamento, demonstrando como algumas configurações simples podem trazer muitos benefícios, como a possibilidade de ter um ambiente confiável, tanto em produção, como em desenvolvimento.

Ao final deste artigo, você terá aprendido a:

• Configurar aplicações legadas para rodar em contêineres do Docker;
• Habilitar o cache de dependências em módulos do Node.js;
• Habilitar o live-reload utilizando volumes do Docker;
• Agregar todos os serviços utilizando o docker-compose.

Requisitos

Nos próximos passos, você vai clonar um projeto existente para executar todos os exemplos deste artigo. Antes de começar a escrever código, certifique-se de que você possui as seguintes ferramentas instaladas no seu computador:

• Docker e Docker compose
• Node.js 10+
• Git

Por que usar o Docker?

A todo momento, vemos na internet o surgimento de novas tecnologias de ponta. Elas são estáveis, e é divertido trabalhar com coisas novas, mas elas não são tão previsíveis quando estamos trabalhando nos mais diversos ambientes. Então, um grupo de desenvolvedores criou o Docker para reduzir as chances de possíveis erros nestes cenários de mudança de ambiente.

O Docker é uma das minhas ferramentas favoritas e eu o utilizo para trabalhar com aplicações desktop, web ou IoT. Agora, eu tenho o poder de mover minhas aplicações para os mais diversos ambientes, podendo também manter meu ambiente local sempre limpo.

Desenvolvedores que trabalham com tecnologias de ponta estão sempre mexendo com algo novo. Mas, e quanto às aplicações legadas? Deveríamos simplesmente reescrever tudo com uma nova tecnologia? Eu sei que isso não é tão simples quanto parece. Nós devemos trabalhar com coisas novas, mas também devemos sempre manter e aprimorar as aplicações existentes.

Vamos dizer que você decidiu trocar de servidores baseados em Windows para servidores baseados em Unix. Como isso deveria ser feito? Você sabe todas as dependências que seu aplicativo precisa para funcionar?

Como um ambiente de desenvolvimento deveria ser?

Desenvolvedores estão sempre tentando ser mais produtivos. Para isso, muitas vezes, tentamos adicionar plugins, boilerplates e bases de códigos prontas em nossas IDEs/editores/terminais. Na minha opinião, porém, o ambiente de desenvolvimento ideal deveria ser:

1. Fácil de executar e testar;
2. Agnóstico ao ambiente;
3. Rápido de avaliar/testar modificações;
4. Fácil de replicar em qualquer computador.

Nas próximas seções deste artigo, nós configuraremos uma aplicação que tem como base os princípios citados acima. Caso você ainda não tenha ouvido falar de live-reload (ou hot reload), sua tradução literal seria "atualização em tempo real", que nada mais é do que uma funcionalidade que fica observando as modificações que são feitas no código e reinicia a aplicação automaticamente. Com isso, você não precisa ficar toda hora fazendo o build e reiniciando sua aplicação.

Começando

Primeiro, você vai precisar de uma pasta vazia chamada post-docker-livereload, que será nosso local de trabalho. Acesse este repositório do Github e faça um clone dentro dele na pasta post-docker-live-reload.

Após clonar o repositório no seu ambiente local, vamos analisar quais os requerimentos da aplicação. Dando uma rápida olhada no arquivo README.md, podemos ver algumas instruções de como executar a aplicação, como mostra a imagem abaixo:

É necessário ter o Node.js na versão 10 ou superior e o MongoDB. Ao invés de fazermos uma instalação do MongoDB no seu ambiente local, vamos instalá-lo utilizando o Docker. Você vai expor o MongoDB em localhost:27017. Assim, mesmo aplicações executadas fora do Docker poderão acessá-lo sem a necessidade de conhecer o IP interno que é utilizado no Docker.

Copie o comando abaixo e cole no seu terminal:

docker run --name mongodb -p 27017:27017 -d mongo:4

Com o comando acima, você baixará e executará uma instância do MongoDB. Observe que, caso você já tenha uma instância com o mesmo nome, o comando lançará um erro de nome inválido.

Caso ocorra o erro, você pode remover a instalação anterior rodando o comando docker rm mongodb. Com isso, você removerá qualquer instância anterior e poderá rodar o comando docker run novamente.

Explorando a aplicação

O arquivo README.md diz que, antes de rodar sua aplicação, você precisará de uma instância do MongoDB, juntamente com o Node.js.

Se você já tiver instalado o Node.js, vá para a pasta nodejs-with-mongodb-api-example e execute os seguintes comandos:

npm i 
npm run build 
npm start

Após executar esses comandos, vá até o navegador e acesse http://localhost:3000. Assim, você poderá visualizar a aplicação sendo executada, como mostra a imagem abaixo:

Tenha em mente que a aplicação já possui um comando para habilitar o live-reload que é o npm run dev:watch. O fluxo deve seguir os seguintes passos:

1. O desenvolvedor muda um arquivo Typescript;
2. Os arquivos Typescript são transpilados (convertidos) para JavaScript;
3. O servidor identifica as modificações nos arquivos JavaScript e reinicia o servidor Node.js.

Então, fazendo um espelhamento dos arquivos para os contêineres Docker, essas alterações serão refletidas para o contêiner também. O comando npm run build:watch vai capturar as alterações e gerar novos arquivos na pasta lib. Então, todas as vezes que o comando npm run dev:run for disparado, o servidor será reiniciado.

Dockerizando a aplicação

Caso o Docker seja um mundo completamente novo para você, não tenha medo! Você fará essa configuração do zero. Você vai precisar criar apenas alguns arquivos para começar:

1. Dockerfile - é como uma receita onde será descrito como instalar sua aplicação;
2. .dockerignore - um arquivo onde listamos quais arquivos não irão para a instância do contêiner.

Criando o Dockerfile

Dockerfile é o conceito chave aqui. Nele, você especifica os passos e dependências para preparar e executar a aplicação. Desde que você tenha lido o arquivo README.md, será muito fácil de implementar o arquivo de "receita".

Vou colocar todo arquivo aqui e, mais para a frente, vamos explorá-lo mais a fundo. Na sua pasta nodejs-with-mongodb-api-example, crie um arquivo com o nome Dockerfile e cole o código abaixo.

FROM node:14-alpine

WORKDIR /src

ADD package.json /src 

RUN npm i --silent

ADD . /src 

RUN npm run build 

CMD npm start

O que estamos fazendo no Dockerfile?

• Na primeira linha - utilizamos uma imagem base do Node.js 14 - versão alpine;
• Da linha 2 até a linha 4 - é feita a cópia e instalação das dependências do Node.js do host para o contêiner. Note que a ordem aqui é importante. Adicionar o package.json para a pasta src antes de restaurar as dependências vai criar um cache e evitar que toda a vez que você fizer o build da imagem os pacotes sejam baixados novamente;
• Da linha 6 até a linha 7 - é feita a compilação e logo após a execução do programa como mencionado no arquivo README.md;

Ignorando arquivos desnecessários com o .dockerignore

Atualmente, eu estou trabalhando com um sistema operacional baseado em OSX. O contêiner Docker vai executar em um sistema operacional baseado em Alpine Linux. Quando você executar o comando npm install, serão baixadas as dependências para o ambiente específico.

Agora, você vai criar um arquivo para ignorar o código gerado no seu ambiente local - por exemplo, a pasta node_modules e a pasta lib. Assim, garantimos que, quando você fizer a cópia dos arquivos do seu diretório atual para o contêiner, nenhuma dependência indesejada seja copiada também.

Na pasta nodejs-with-mongodb-api-example, crie um arquivo com o nome .dockerignore e cole o código abaixo:

node_modules/
lib/

Construindo a imagem Docker

Eu prefiro executar essa aplicação a partir da pasta raiz. Volte para a pasta post-docker-live-reload e execute os comandos a seguir para preparar a imagem para a utilizarmos mais adiante:

docker build -t app nodejs-with-mongodb-api-example

Repare que o comando acima utiliza a flag -t para definir o nome da imagem. Logo depois disso, é informada a pasta que contém o arquivo Dockerfile.

Trabalhando com volumes

Antes de executar a aplicação, vamos fazer alguns "hacks" para melhorar nossa experiência com os contêineres do Docker.

Os volumes no Docker nos permitem espelhar arquivos da nossa máquina local para o ambiente do Docker. Você também pode compartilhar volumes entre diversos contêineres e reaproveitá-los para criar um cache das dependências.

Nosso objetivo aqui é observar qualquer mudança nos nossos arquivos .ts do ambiente local e espelhar essas mudanças para o contêiner, mesmo que os arquivos e a pasta node_modules estejam no mesmo diretório.

Você se lembra quando eu disse que as dependências podem ser diferentes dependendo do sistema operacional? Para ter certeza que nosso ambiente local não vai afetar o ambiente do Docker quando espelharmos os arquivos, nós vamos isolar a pasta node_modules do container em um volume separado.

Consequentemente, quando a pasta node_modules for criada no contêiner, ela não será criada na nosso ambiente local. Execute o comando abaixo no terminal para criar o volume:

docker volume create --name nodemodules

Executando e habilitando o live-reload

Como você já sabe, o comando npm run dev:watch especificado no arquivo README.md mostra como habilitar o live-reload. O problema é que você está programando em sua máquina local e suas alterações devem se refletir no contêiner.

Executando o comando abaixo, você vai conectar seu ambiente local com o contêiner do Docker. Assim, qualquer alteração na pasta nodejs-with-mongodb-api-example será refletida na pasta src do contêiner.

docker run \
    --name app \
    --link mongodb \
    -e MONGO_URL=mongodb \
    -e PORT=4000 \
    -p 4000:4000 \
    -v `pwd`/nodejs-with-mongodb-api-example:/src \
    -v nodemodules:/src/node_modules \
    app npm run dev:watch

Vamos nos aprofundar no que está sendo feito aqui:

• --link - dá a permissão para a aplicação acessar a instância do MongoDB;
• -e - são as variáveis de ambiente. Como mencionado no arquivo README.md, você pode especificar a string de conexão da instância do MongoDB a qual você quer se conectar sobrescrevendo a variável MONGO_URL. Sobrescreva a variável PORT, caso queira que a aplicação seja executada em uma porta diferente. Observe que o valor de mongodb é o mesmo que usamos para criar a nossa instância do MongoDB nas seções anteriores. Este valor também é um apelido para o IP interno da instância do MongoDB;
• -v - mapeia o diretório atual para o contêiner do Docker utilizando um volume virtual. Utilizando o comando pwd, você tem acesso ao caminho absoluto para seu diretório de trabalho atual e, em seguida, para a pasta que você gostaria de espelhar no contêiner do Docker, que, no caso, é o diretório :/src. A pasta src representa a instrução WORKDIR, definida no arquivo Dockerfile, para que possamos espelhar nosso diretório local para a pasta src do contêiner do Docker;
• -v - este segundo volume serve para espelhar a pasta node_modules do contêiner de maneira individual;
• app - é o nome da imagem;
• npm run dev:watch - este último comando vai sobrescrever o comando CMD que está no Dockerfile.

Após executar o comando acima, você pode acessar o browser novamente e fazer algumas alterações no seu arquivo index.ts para ver os resultados (atente-se que utilizamos a porta 4000 no comando shell). O vídeo abaixo demonstra esses passos:

Finalizando

Você sabe que trabalhar com comandos shell funciona. Não é muito comum , no entanto, usá-los aqui. Também não é muito produtivo executar todos esses comandos, construir as imagens e gerenciar as instâncias manualmente. Então, vamos fazer uma composição!

O Docker Compose é uma forma de simplificar a agregação e a conexão entre os serviços. Você pode especificar os bancos de dados, os logs, as aplicações, os volumes, as redes e assim por diante.

Primeiro, será preciso remover todas as instâncias inativas para evitar conflito nas portas expostas. Execute o seguinte comando no seu terminal para remover os volumes, serviços e contêineres:

docker rm app 
docker volume rm nodemodules
docker stop $(docker ps -aq)
docker rm $(docker ps -aq)

O arquivo docker-compose

Crie um arquivo docker-compose.yml na sua pasta post-docker-livereload usando as informações abaixo:

version: '3'
services:
    mongodb:
        image: mongo:4
        ports:
            - 27017:27017
    app:
        build: nodejs-with-mongodb-api-example
        command: npm run dev:watch
        ports:
            - 4000:4000
        environment: 
            MONGO_URL: mongodb
            PORT: 4000
        volumes:
            - ./nodejs-with-mongodb-api-example:/src/
            - nodemodules:/src/node_modules
        links:
            - mongodb
        depends_on: 
            - mongodb

volumes:
    nodemodules: {}

O arquivo acima especifica os recursos por seções. Repare que, nele, você possui as seções links e depends_on. O campo links representa a mesma flag que você utilizou no comando shell. O campo depends_on vai garantir que o MongoDB é uma dependência necessária para executar a aplicação. Isso fará com que o MongoDB seja executado antes da aplicação magicamente!

Voltando ao terminal, para iniciar os serviços, construir a imagem do Docker, criar os volumes e os links, execute o seguinte comando:

docker-compose up --build

Caso você precise remover todos os serviços criados anteriormente pelo Dockerfile, também pode executar o comando docker-compose down.

O Docker é seu amigo!

É isso, meu amigo. O Docker pode te ajudar a prevenir muitos erros. Você pode utilizá-lo tanto em aplicações front-end como em aplicações back-end. Até mesmo com IoT, quando é necessário controlar um hardware, você pode especificar políticas utilizando o Docker.

Como um próximo passo, eu recomendo fortemente que você dê uma olhada em ferramentas de orquestração de contêineres, como o Kubernetes e o Docker swarm. Elas podem melhorar ainda mais suas aplicações existentes e ajudar você a atingir um outro nível.

Muito obrigado por ler até aqui

Eu fico muito grato por esse tempo que passamos juntos. Espero que esse conteúdo seja mais do que apenas texto. Espero que ele ajude você a se tornar um pensador melhor e também um programador melhor. Siga-me no Twitter e confira meu blog pessoal, onde eu compartilho muitos conteúdos especiais.

Até mais!