Pausa caffè #107. Metodo del costruttore nel sovraccarico del costruttore Java I. Classi e interfacce Java astratte

Metodo del costruttore nel sovraccarico del costruttore Java I

Fonte: Programmazione orientata agli oggetti77 Cos'è Costruttore ? Questo è un tipo speciale di metodo il cui nome è uguale al nome della classe, che determina come viene inizializzato l'oggetto al momento della creazione. Come altri metodi, possiamo anche definire un metodo Costruttore nel nostro programma Java, ma a differenza di altri metodi, non possiamo chiamare direttamente il Costruttore ; Java chiama automaticamente il costruttore quando viene creato un oggetto. Quando utilizziamo la parola chiave new per creare un oggetto di una classe, Java fa tre cose:

• Alloca memoria per un oggetto.
• Inizializza questa variabile di istanza dell'oggetto con il suo valore iniziale o predefinito.
• Chiama il costruttore del metodo della classe.

Se una classe non definisce alcun metodo Costruttore , creeremo comunque un oggetto di quella classe, ma dovremo impostare una variabile di istanza o chiamare altri metodi, i quali dovranno successivamente inizializzare l'oggetto con quell'oggetto. Definendo un metodo Costruttore nelle nostre classi, possiamo impostare i valori iniziali di una variabile di istanza, chiamare un metodo basato su quella variabile, o chiamare metodi su altri oggetti, o calcolare le proprietà iniziali del nostro oggetto. Possiamo anche sovraccaricare Constructor come metodi normali per creare un oggetto che abbia determinate proprietà in base all'argomento che passiamo a new .

Costruttore di base

Per definizione, Constructor sembra un metodo normale con due differenze principali.

• Il costruttore e il nome della classe sono sempre gli stessi.
• Non ha un tipo di reso

Ad esempio, la tabella seguente mostra una semplice classe Person con un costruttore che inizializza la sua variabile di istanza in base al nuovo argomento . La classe include anche un metodo mediante il quale un oggetto può presentarsi e un metodo main() per testare ciascuna di queste classi.

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

Otteniamo l'output:

Sovraccarico del costruttore

Come altri metodi, Constructor può anche accettare diversi numeri e tipi di parametri, consentendo la creazione di oggetti con proprietà specificate o consentendo a Constructor di calcolare proprietà in base a diversi tipi di input. Ad esempio, la classe MyRectone in una determinata tabella crea un costruttore MyRectone e passa un parametro diverso invece di creare metodi diversi per gli argomenti specificati.

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

Conclusione:

Chiamare un altro costruttore

Un costruttore può essere un superset di un altro costruttore definito nella tua classe; cioè, possono comportarsi allo stesso modo, più un po' di più. Piuttosto che duplicare un comportamento identico su più metodi di costruzione nella nostra classe, ha senso poter chiamare semplicemente il primo costruttore dal corpo del secondo costruttore. Java fornisce una sintassi speciale per questo. Per chiamare un costruttore definito nella classe corrente, utilizzare questo formato:

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

Gli argomenti a riguardo sono, ovviamente, gli argomenti per il costruttore.

Classi e interfacce Java astratte

Fonte: Dev.to Una classe astratta è una classe che ha alcuni metodi senza una definizione completa e ha il modificatore abstract .

• Non è possibile creare un oggetto utilizzando il costruttore di una classe astratta.
• È possibile utilizzare una classe astratta come classe base per definire una classe derivata.
• Una classe astratta ha almeno un metodo astratto.
• Metodo astratto : ha un'intestazione come un metodo normale, ma senza corpo e richiede il modificatore astratto e un punto e virgola.
• Un metodo astratto non può essere privato.
• Una classe astratta può essere un tipo.

Esempio:

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

public abstract double getPay();
}

Interfaccia : Definisce un insieme di metodi che qualsiasi classe che implementa questa interfaccia deve avere.

• Un'interfaccia è un tipo.
• Contiene intestazioni di metodo senza definizione e senza variabili di istanza:

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

Per implementare un'interfaccia, una classe deve fare due cose:

• Include implementa InterfaceName .
• La classe deve implementare tutte le intestazioni del metodo elencate nell'interfaccia.

public class Implementer implements Interface1 {

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

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

}

• Le intestazioni dei metodi sono dichiarate pubbliche .
• Una classe astratta può anche implementare un'interfaccia; questa classe fornisce le definizioni per alcune intestazioni dei metodi nell'interfaccia.
• Le interfacce Java possono anche contenere costanti , ad esempio:

public interface Constant {

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

• Qualsiasi classe che implementa l' interfaccia Constant avrà automaticamente queste costanti, ad esempio:

public class Constants implements Constant {

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

}

• È possibile combinare l'uso delle interfacce includendo costanti e intestazioni di metodo in un'unica interfaccia.
• Java non supporta l'ereditarietà multipla, quindi una classe può estendere solo una classe base. Tuttavia, utilizzando le interfacce, una classe può implementare più interfacce:

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

}

• Il motivo per cui una classe Java può estendere solo una classe base è perché se Java consente due classi base, le due classi potrebbero avere la stessa intestazione del metodo con una definizione diversa, con conseguente incoerenza.
• Due interfacce possono essere incompatibili se si definiscono due costanti con lo stesso nome e valori diversi:

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

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