Pausa para café #111. Polimorfismo e ligação dinâmica em Java. For loop em Java + exemplo de sintaxe de loop forEach

Polimorfismo e ligação dinâmica em Java

Fonte: DZone Polimorfismo é um dos conceitos centrais da programação orientada a objetos. Quer você seja novo em programação Java ou um desenvolvedor experiente, você deve saber o que é polimorfismo e como funciona. A maioria dos desenvolvedores afirma ser bem versada neste tópico, mas quando se trata de outros recursos complexos, como vinculação estática e dinâmica, muitos deles perdem a confiança.

O que é polimorfismo em Java?

Polimorfismo significa ter muitas formas. Na programação, refere-se à capacidade de um sinal ou mensagem aparecer em mais de uma forma.

Exemplo da vida real

Uma pessoa pode apresentar muitas características ao mesmo tempo. Por exemplo, uma mãe pode ser simultaneamente esposa, filha, irmã, funcionária de uma empresa e assim por diante. Portanto, uma pessoa pode apresentar características diferentes em condições diferentes. Isso é conhecido como polimorfismo.

A importância do polimorfismo

O polimorfismo é um dos recursos mais importantes de qualquer linguagem de programação orientada a objetos (por exemplo, Java). Com a ajuda do polimorfismo, a mesma tarefa pode ser realizada de diferentes maneiras.

Tipos de polimorfismo

Em Java, o polimorfismo pode ser dividido em duas categorias:

1. Polimorfismo em tempo de compilação (vinculação estática)
2. Polimorfismo de tempo de execução (tempo de execução, ligação dinâmica)

Polimorfismo em tempo de compilação

O polimorfismo em tempo de compilação também é conhecido como vinculação estática. Este tipo de polimorfismo pode ser alcançado através de sobrecarga de função ou sobrecarga de operador. Mas em Java, isso é limitado à sobrecarga de funções, pois Java não suporta sobrecarga de operadores. Sobrecarga de função Quando há pelo menos duas funções ou métodos com o mesmo nome de função, mas o número de parâmetros que eles contêm é diferente ou pelo menos um tipo de dados do parâmetro correspondente é diferente (ou ambos), então é chamado de função ou sobrecarga de método, e essas funções são conhecidas como funções sobrecarregadas. Exemplo 1 Até agora estudamos o que é sobrecarga de função. Agora vamos tentar demonstrar a sobrecarga de funções de software.

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    // Method 2
    // having the same name but with 2 double parameters
    static double Addition(double a, double b)
    {
        // Returns sum of double numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Você pode executar o programa acima aqui . Explicação do programa:

• O programa acima consiste em duas funções estáticas com os mesmos nomes: Adição .

• Aqui, ambas as funções contêm o mesmo número de parâmetros, mas os parâmetros correspondentes são diferentes.

• O Método 1 aceita dois parâmetros inteiros, enquanto o Método 2 aceita dois parâmetros duplos .

• A partir da função principal, primeiro chamamos a função Addition(12, 14) . Os parâmetros passados ​​são inteiros (12 e 14), então o Método 1 será chamado aqui.

• Em seguida, chamamos a função Addition(15.2, 16.1) . Como os parâmetros passados ​​são do tipo de dados duplos (15.2 e 16.1), desta vez será chamado o Método 2 .

• É assim que a sobrecarga de funções é alcançada em Java com base em diferentes tipos de dados de parâmetros.

Exemplo 2 Considere o programa abaixo:

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {

        // Returns sum of integer numbers
        return a + b;
    }

    // Method 2
    // having the same name but with 3 integer parameters
    static double Addition(double a, double b)
    {

        // Returns sum of integer numbers
        return a + b;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(12, 14));
        System.out.println(Addition(15.2, 16.1));

    }
}

Você pode executar o programa acima aqui . Explicação do programa:

• O programa acima consiste em duas funções estáticas com os mesmos nomes: Adição .

• Aqui, ambas as funções contêm números diferentes de parâmetros, mas o tipo de dados dos dois primeiros parâmetros correspondentes é o mesmo (inteiro).

• O Método 1 usa dois parâmetros inteiros e o Método 2 usa três parâmetros de tipo de dados inteiros.

• A partir da função principal, primeiro chamamos a função Addition(2, 3) . Como os parâmetros passados ​​são inteiros (2 e 3), eles chamarão o Método 1 aqui .

• Em seguida, chamamos a função Addition(4, 5, 6) . Os parâmetros passados ​​são tipos de dados duplos (4, 5, 6), portanto desta vez eles chamarão o Método 2 .

• É assim que as funções são sobrecarregadas em Java com base em um número diferente de parâmetros.

Exemplo 3

class Main {

    // Method 1
    // Method with 2 integer parameters
    static int Addition(int a, int b)
    {
        // Return the sum
        return a + b;
    }
    // Method 2
    // having the same name but with 3 parameters
    // 1st parameter is of type double and other parameters
    // are of type integer
    static double Addition(double a, int b,  int c)
    {
        // Return the sum
        return a + b + c;
    }
    public static void main(String args[]) {

        // Calling method by passing
        // input as in arguments
        System.out.println(Addition(2, 4));
        System.out.println(Addition(4.2, 6, 10));

    }
}

Você pode executar o programa acima aqui . Explicação do programa:

• O programa acima consiste em duas funções estáticas com os mesmos nomes: Adição .

• Ambas as funções contêm um número diferente de parâmetros e o tipo de dados do primeiro elemento correspondente também é diferente.

• O Método 1 utiliza dois parâmetros inteiros, enquanto o Método 2 utiliza três parâmetros - o primeiro é do tipo double e os outros dois são tipos de dados inteiros.

• A partir da função principal, primeiro chamamos a função Addition(2, 4) . Como os parâmetros passados ​​são números inteiros (2 e 4), eles chamarão o Método 1 aqui .

• Em seguida, chamamos a função Addition(4.2, 6, 10) . O primeiro parâmetro passado é do tipo inteiro e os demais parâmetros são do tipo de dados duplo (4.2, 6, 10), portanto desta vez será chamado o Método 2 .

• É assim que Java atinge a sobrecarga de funções com base em diferentes números de parâmetros, bem como em diferentes tipos de dados dos parâmetros correspondentes.

Observação. Uma função não pode ser sobrecarregada com base apenas no tipo de retorno da função.

Polimorfismo de tempo de execução

Esta opção também é conhecida como vinculação dinâmica. Neste processo, chamar uma função criada para outra função só é permitida em tempo de execução. Podemos obter ligação dinâmica em Java usando substituição de método.

Substituição de método

A substituição de método em Java ocorre quando um método em uma classe base possui uma definição em uma classe derivada. Um método ou função de classe base é chamado de método substituído.

// Class 1
class Parent {

    // Print method
    void Print()
    {

        // Print statement
        System.out.println("Inside Parent Class");
    }
}

// Class 2
class Child1 extends Parent {

    // Print method
    void Print() { System.out.println("Inside Child1 Class"); }
}

// Class 3
class Child2 extends Parent {

    // Print method
    void Print()
    {
        // Print statement
        System.out.println("Inside Child2 Class");
    }
}

class Main {

    public static void main(String args[]) {

        // Creating an object of class Parent
        Parent parent = new Parent();
        parent.Print();

        // Calling print methods
        parent = new Child1();
        parent.Print();

        parent = new Child2();
        parent.Print();
    }
}

Você pode executar o programa acima aqui . Explicação do programa:

• O programa acima consiste em três classes: Parent ( class 1 ), Child1 ( class 2 ) e Child2 ( class 3 ). A classe 2 e a classe 3 herdam a classe 1 .

• Parent tem um método chamado Print() . Dentro desta função imprimimos " Inside Parent Class ". Child1 e Child2 também possuem funções Print() , que basicamente substituem a função Print() da classe Parent e imprimem " Inside Child1 Class " e " Inside Child2 Class " respectivamente no console.

• A partir da função principal, primeiro criamos um objeto da classe pai chamado parent. Em seguida, usamos esse objeto para chamar o método print da classe pai . Portanto " Inside Parent Class " será impresso no console.

• Depois disso, chamamos o construtor padrão da classe Child1 e chamamos a função Print() . Observe que o método Print() definido na classe Child1 agora será chamado porque substituímos o método Print() da classe pai . Portanto, " Inside Child1 Class " será impresso no console.

• Finalmente, chamamos o construtor padrão da classe Child2 e chamamos a função Print() . Aqui, o método Print() definido na classe Child2 será chamado porque substituímos o método Print() da classe pai . Portanto, “ Inside Child2 Class ” estará impresso no console.

• É assim que a substituição de método é obtida em Java.

Resultados

Neste artigo, aprendemos o que é polimorfismo em Java. Em seguida, nos aprofundamos no tópico e discutimos dois tipos de polimorfismo em Java: polimorfismo em tempo de compilação e polimorfismo em tempo de execução. Demonstramos por meio de programas como a ligação estática e dinâmica pode ser alcançada em Java.

For loop em Java + exemplo de sintaxe de loop forEach

Fonte: FreeCodeCamp Um Loop em programação é uma sequência de instruções que são executadas continuamente até que uma determinada condição seja atendida. Neste artigo, aprenderemos sobre os loops for e forEach em Java.

Sintaxe de loop For em Java

Aqui está a sintaxe para criar um loop for :

for (initialization; condition; increment/decrement) {
   // code to be executed
}

Vejamos algumas das palavras-chave no código:

• for indica que vamos criar um loop. É seguido por parênteses, que contêm tudo o que precisamos para fazer nosso loop funcionar.

• a inicialização define a variável inicial como o ponto inicial do loop, geralmente um número inteiro.

• condição especifica quantas vezes o loop deve ser executado.

• incrementar / decrementar incrementa/decrementa o valor da variável inicial cada vez que o loop é executado. À medida que o valor da variável aumenta/diminui, ela tende para a condição especificada.

• Observe que cada palavra-chave é separada por ponto e vírgula ( ; ).

aqui estão alguns exemplos:

for(int x = 1; x <=5; x++) {
  System.out.println(x);
}

/*
1
2
3
4
5
*/

No exemplo acima, a variável inicial é x com valor 1. O loop continuará a ser executado enquanto o valor de x for menor ou igual a 5 - esta é a condição. x++ incrementa o valor de x após cada execução. Continuamos imprimindo o valor de x que termina após 5 porque a condição foi atendida. Aumentar para 6 não é possível porque é maior e diferente de 5. No exemplo a seguir, usaremos um loop for para imprimir todos os valores em um array.

int[] randomNumbers = {2, 5, 4, 7};
for (int i = 0; i < randomNumbers.length; i++) {
  System.out.println(randomNumbers[i]);
}

// 2
// 5
// 4
// 7

Isso é quase igual ao último exemplo. Aqui usamos o comprimento do array como condição e o valor inicial da variável como zero porque o número ordinal do primeiro elemento do array é zero.

Sintaxe de loop forEach em Java

O loop forEach é usado especificamente para iterar pelos elementos de um array. Esta é a aparência de sua sintaxe:

for (dataType variableName : arrayName) {
  // code to be executed
}

Você notará que a sintaxe aqui é mais curta que a do loop for . E o loop forEach também começa com a palavra-chave for . Em vez de inicializar uma variável com um valor, primeiro especificamos o tipo de dados (deve corresponder ao tipo de dados do array). Isso é seguido pelo nome da nossa variável e pelo nome do array , separados por dois pontos. Aqui está um exemplo para ajudá-lo a entender melhor a sintaxe:

int[] randomNumbers = {2, 5, 4, 7};
for (int x : randomNumbers) {
  System.out.println(x + 1);
}

/*
3
6
5
8
*/

Neste exemplo, iteramos cada elemento e aumentamos seu valor inicial em 1. Por padrão, o loop para depois de iterar por todos os elementos do array. Isso significa que não precisamos passar nenhum valor para nossa variável ou especificar nenhuma condição para o loop terminar.

Conclusão

Neste artigo, aprendemos o que são loops e a sintaxe para criar loops for e forEach em Java. Também vimos alguns exemplos que nos ajudaram a entender quando e como usá-los. Boa codificação!