Pausa para el café #107. Método constructor en Java I Sobrecarga del constructor. Clases e interfaces abstractas de Java

Método constructor en Java I Sobrecarga del constructor

Fuente: Programación orientada a objetos77 ¿ Qué es Constructor ? Este es un tipo especial de método cuyo nombre es el mismo que el nombre de la clase, que determina cómo se inicializa el objeto cuando se crea. Al igual que otros métodos, también podemos definir un método Constructor en nuestro programa Java, pero a diferencia de otros métodos, no podemos llamar al Constructor directamente; Java llama al constructor automáticamente cuando se crea un objeto. Cuando usamos la palabra clave new para crear un objeto de una clase, Java hace tres cosas:

• Asigna memoria para un objeto.
• Inicialice esta variable de instancia de objeto con su valor inicial o predeterminado.
• Llama al constructor del método de la clase.

Si una clase no define ningún método Constructor , igualmente crearemos un objeto de esa clase, pero debemos establecer una variable de instancia o llamar a otros métodos, que posteriormente deben inicializar el objeto con ese objeto. Al definir un método Constructor en nuestras propias clases, podemos establecer los valores iniciales de una variable de instancia, llamar a un método basado en esa variable, o llamar a métodos en otros objetos, o calcular las propiedades iniciales de nuestro objeto. También podemos sobrecargar Constructor como métodos normales para crear un objeto que tenga ciertas propiedades basadas en el argumento que le pasamos a new .

Constructor básico

Por definición, Constructor parece un método normal con dos diferencias principales.

• El constructor y el nombre de la clase son siempre los mismos.
• No tiene tipo de devolución

Por ejemplo, la siguiente tabla muestra una clase Persona simple con un constructor que inicializa su variable de instancia en función del nuevo argumento . La clase también incluye un método mediante el cual un objeto puede presentarse y un método main() para probar cada una de estas clases.

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();

Obtenemos la salida:

Sobrecarga de constructores

Al igual que otros métodos, Constructor también puede aceptar diferentes números y tipos de parámetros, lo que permite crear objetos con propiedades específicas o permitir que Constructor calcule propiedades en función de diferentes tipos de entrada. Por ejemplo, la clase MyRectone en una tabla determinada crea un constructor MyRectone y pasa un parámetro diferente en lugar de crear métodos diferentes para los argumentos dados.

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();

Conclusión:

Llamar a otro constructor

Un constructor puede ser un superconjunto de otro constructor definido en tu clase; es decir, pueden comportarse igual y un poquito más. En lugar de duplicar un comportamiento idéntico en múltiples métodos constructores de nuestra clase, tiene sentido poder simplemente llamar a ese primer constructor desde el cuerpo del segundo constructor. Java proporciona una sintaxis especial para esto. Para llamar a un constructor definido en la clase actual, utilice este formulario:

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

Los argumentos de esto son, por supuesto, los argumentos del constructor.

Clases e interfaces abstractas de Java

Fuente: Dev.to Una clase abstracta es una clase que tiene algunos métodos sin una definición completa y tiene el modificador abstracto .

• No se puede crear un objeto utilizando el constructor de una clase abstracta.
• Puede utilizar una clase abstracta como clase base para definir una clase derivada.
• Una clase abstracta tiene al menos un método abstracto.
• Método abstracto : tiene un encabezado como un método normal, pero sin cuerpo, y requiere el modificador abstracto y un punto y coma.
• Un método abstracto no puede ser privado.
• Una clase abstracta puede ser un tipo.

Ejemplo:

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

public abstract double getPay();
}

Interfaz : Define un conjunto de métodos que debe tener cualquier clase que implemente esta interfaz.

• Una interfaz es un tipo.
• Contiene encabezados de métodos sin definición ni variables de instancia:

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

Para implementar una interfaz, una clase debe hacer dos cosas:

• Incluye implementos InterfaceName .
• La clase debe implementar todos los encabezados de métodos enumerados en la interfaz.

public class Implementer implements Interface1 {

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

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

}

• Los encabezados de los métodos se declaran públicos .
• Una clase abstracta también puede implementar una interfaz; esta clase proporciona definiciones para algunos de los encabezados de los métodos en la interfaz.
• Las interfaces Java también pueden contener constantes , por ejemplo:

public interface Constant {

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

• Cualquier clase que implemente la interfaz Constant tendrá automáticamente estas constantes, por ejemplo:

public class Constants implements Constant {

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

}

• Puede combinar el uso de interfaces incluyendo constantes y encabezados de métodos en una sola interfaz.
• Java no admite herencia múltiple, por lo que una clase sólo puede extender una clase base. Sin embargo, al utilizar interfaces, una clase puede implementar múltiples interfaces:

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

}

• La razón por la cual una clase Java solo puede extender una clase base es porque si Java permite dos clases base, las dos clases pueden tener el mismo encabezado de método con una definición diferente, lo que resulta en inconsistencia.
• Dos interfaces pueden ser incompatibles si define dos constantes con el mismo nombre y valores diferentes:

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

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