Pausa para café #107. Método Construtor em Java I Sobrecarga de Construtor. Classes e interfaces Java abstratas

Método Construtor em Java I Sobrecarga de Construtor

Fonte: Programação Orientada a Objetos77 O que é Construtor ? Este é um tipo especial de método cujo nome é igual ao nome da classe, que determina como o objeto é inicializado quando é criado. Como outros métodos, também podemos definir um método Construtor em nosso programa Java, mas diferentemente de outros métodos, não podemos chamar o Construtor diretamente; Java chama o construtor automaticamente quando um objeto é criado. Quando usamos a palavra-chave new para criar um objeto de uma classe, Java faz três coisas:

• Aloca memória para um objeto.
• Inicialize esta variável de instância de objeto com seu valor inicial ou padrão.
• Chama o construtor Method da classe.

Se uma classe não definir nenhum método Construtor , ainda assim criaremos um objeto dessa classe, mas devemos definir uma variável de instância ou chamar outros métodos, que posteriormente deverão inicializar o objeto com aquele objeto. Ao definir um método Construtor em nossas próprias classes, podemos definir os valores iniciais de uma variável de instância, chamar um método baseado nessa variável ou chamar métodos em outros objetos ou calcular as propriedades iniciais de nosso objeto. Também podemos sobrecarregar o Construtor como métodos normais para criar um objeto que possui certas propriedades com base no argumento que passamos para new .

Construtor Básico

Por definição, o Construtor parece um método regular com duas diferenças principais.

• O construtor e o nome da classe são sempre iguais.
• Não tem tipo de retorno

Por exemplo, a tabela abaixo mostra uma classe Person simples com um construtor que inicializa sua variável de instância com base no novo argumento . A classe também inclui um método pelo qual um objeto pode se apresentar e um método main() para testar cada uma dessas classes.

class Person
{
    String name;
    int age;

    Person (String n, int a)
{
    name = n;
    age = a;
}

void printPerson ()
{
System.out.print("Hi, I am " +name);
System.out.println(" I am "+ age + " years old.");
}

public static void main(String args[])
{

    Person p;

    p = new Person ("Ajab", 20);
    p.printPerson();

    p = new Person ("Rizwan", 30);
    p.printPerson();

Obtemos a saída:

Sobrecarga do construtor

Como outros métodos, o Construtor também pode aceitar diferentes números e tipos de parâmetros, permitindo que objetos sejam criados com propriedades especificadas ou permitindo que o Construtor calcule propriedades com base em diferentes tipos de entrada. Por exemplo, a classe MyRectone em uma determinada tabela cria um construtor MyRectone e passa um parâmetro diferente em vez de criar métodos diferentes para os argumentos fornecidos.

class MyRectone
 {

    int x1 = 0;
    int y1 = 0;
    int x2 = 0;
    int y2 = 0;

MyRectone ( int x1, int x2, int x2, int y2)
 {

    this.x1 = x1;
    this.y1 = y1;
    this.x2 = x2;
    this.y2 = y2;

}

MyRectone (Point topLeft, Point bottomRight)
 {

    x1 = topLeft.x;
    y1 = topLeft.y;
    x2 = bottomRight.x;
    y2 = bottomRight.y;

}

MyRectone ( Point topLeft, int w, int h)
{

    x1 = topLeft.x;
    y1 = top left.y;
    x2 = ( x1 + w);
    y2 = (y1 + h);

}

void printRect ()
{

    System.out.print ("MyRectone: <" + x1 + ", " + y1);
    system.out.println (", " + x2 + " ,"+ y2 + ">");

}

public static void main (String args [] )
{

    MyRectone rect;
    System.out.println ("Calling MyRectone with coordinates 35,35 70,70");

    rect = new MyRectone (35,35,70,70);
    rect.printRect();

    System.out.println ("Calling MyRectone with coordinates (15,15) (30,30)");
    rect = new MyRectone (15,15,30,30);
    rect.printRect();

    System.out.print (" Calling buildRect w/1 point (10,10),");
    System.out.println ("width (50) and height (50)");
    rect = new MyRectone ( new Point (10,10), 50, 50);
    rect.printRect();

Conclusão:

Chamando outro construtor

Um construtor pode ser um superconjunto de outro construtor definido na sua classe; isto é, eles podem se comportar da mesma forma e um pouco mais. Em vez de duplicar o comportamento idêntico em vários métodos construtores em nossa classe, faz sentido poder simplesmente chamar o primeiro construtor a partir do corpo do segundo construtor. Java fornece uma sintaxe especial para isso. Para chamar um construtor definido na classe atual, use este formulário:

this (arg1, arg2, arg3… ..);

Os argumentos para isso são, obviamente, os argumentos para o construtor.

Classes e interfaces Java abstratas

Fonte: Dev.to Uma classe abstrata é uma classe que possui alguns métodos sem uma definição completa e possui o modificador abstrato .

• Você não pode criar um objeto usando um construtor de classe abstrata.
• Você pode usar uma classe abstrata como classe base para definir uma classe derivada.
• Uma classe abstrata possui pelo menos um método abstrato.
• Método abstrato : possui um cabeçalho como um método regular, mas sem corpo, e requer o modificador abstrato e ponto e vírgula.
• Um método abstrato não pode ser privado.
• Uma classe abstrata pode ser um tipo.

Exemplo:

public abstract class Example{
  private String data1;
  private double data2;

public abstract double getPay();
}

Interface : Define um conjunto de métodos que qualquer classe que implemente esta interface deve ter.

• Uma interface é um tipo.
• Ele contém cabeçalhos de métodos sem definição e sem variáveis ​​de instância:

public interface Interface1{
public void method1();
public int method2();
}

Para implementar uma interface, uma classe deve fazer duas coisas:

• Inclui implementos InterfaceName .
• A classe deve implementar todos os cabeçalhos de métodos listados na interface.

public class Implementer implements Interface1 {

    @Override
    public void method1() {
    //definition
    }

    @Override
    public int method2() {
    //definition
    }

}

• Os cabeçalhos dos métodos são declarados public .
• Uma classe abstrata também pode implementar uma interface; esta classe fornece definições para alguns dos cabeçalhos de métodos na interface.
• As interfaces Java também podem conter constantes , por exemplo:

public interface Constant {

    public static final int JANUARY = 1, FEBRUARY = 2, MARCH = 3;
}

• Qualquer classe que implemente a interface Constant terá automaticamente estas constantes, por exemplo:

public class Constants implements Constant {

    public static void main(String[] args) {
        System.out.println(JANUARY);
    }

}

• Você pode combinar o uso de interfaces incluindo constantes e cabeçalhos de métodos em uma única interface.
• Java não suporta herança múltipla, portanto uma classe só pode estender uma classe base. Entretanto, usando interfaces, uma classe pode implementar múltiplas interfaces:

public class Implementer implements Interface1, Interface2, .. InterfaceN{

}

• A razão pela qual uma classe Java só pode estender uma classe base é porque se Java permitir duas classes base, as duas classes podem ter o mesmo cabeçalho de método com uma definição diferente, resultando em inconsistência.
• Duas interfaces podem ser incompatíveis se você definir duas constantes com o mesmo nome e valores diferentes:

public interface Interface1{
public static final int ANSWEAR = 0;
}

public interface Interface1{
public static final int ANSWEAR = 3;
}