Coffee break #107. Paraan ng Constructor sa Java I Constructor Overload. Mga Abstract na Klase at Interface ng Java

Paraan ng Constructor sa Java I Constructor Overload

Source: Objectorientedprogramming77 Ano ang Constructor ? Ito ay isang espesyal na uri ng pamamaraan na ang pangalan ay kapareho ng pangalan ng klase, na tumutukoy kung paano sinisimulan ang bagay kapag ito ay nilikha. Tulad ng iba pang mga pamamaraan, maaari din nating tukuyin ang isang paraan ng Constructor sa aming Java program, ngunit hindi tulad ng ibang mga pamamaraan, hindi namin maaaring direktang tawagan ang Constructor ; Awtomatikong tinatawag ng Java ang constructor kapag nilikha ang isang bagay. Kapag ginamit namin ang bagong keyword upang lumikha ng isang bagay ng isang klase, ang Java ay gumagawa ng tatlong bagay:

• Naglalaan ng memorya para sa isang bagay.
• Simulan ang variable na instance ng object na ito gamit ang kanilang inisyal o default na halaga.
• Tinatawag ang Method constructor ng klase.

Kung hindi tukuyin ng isang klase ang anumang paraan ng Constructor , gagawa pa rin kami ng object ng klase na iyon, ngunit dapat kaming magtakda ng variable ng instance o tumawag ng iba pang mga pamamaraan, na pagkatapos ay dapat na simulan ang object sa object na iyon. Sa pamamagitan ng pagtukoy ng paraan ng Constructor sa sarili nating mga klase, maaari nating itakda ang mga paunang halaga ng isang variable ng instance, tumawag ng isang pamamaraan batay sa variable na iyon, o tumawag ng mga pamamaraan sa iba pang mga bagay, o kalkulahin ang mga paunang katangian ng ating object. Maaari din nating i-overload ang Constructor tulad ng mga normal na pamamaraan upang lumikha ng isang bagay na may ilang partikular na katangian batay sa argumentong ipinapasa natin sa new .

Pangunahing Konstruktor

Sa pamamagitan ng kahulugan, ang Constructor ay mukhang isang regular na pamamaraan na may dalawang pangunahing pagkakaiba.

• Ang constructor at pangalan ng klase ay palaging pareho.
• Wala itong uri ng pagbabalik

Halimbawa, ang talahanayan sa ibaba ay nagpapakita ng isang simpleng klase ng Tao na may constructor na nagpapasimula sa instance variable nito batay sa bagong argument . Kasama rin sa klase ang isang paraan kung saan maaaring ipakilala ng isang bagay ang sarili nito, at isang pangunahing() na pamamaraan para sa pagsubok sa bawat isa sa mga klase na ito.

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

Nakukuha namin ang output:

Overload ng constructor

Tulad ng iba pang mga pamamaraan, ang Constructor ay maaari ding tumanggap ng iba't ibang numero at uri ng mga parameter, na nagpapahintulot sa mga bagay na malikha gamit ang mga tinukoy na katangian, o nagpapahintulot sa Constructor na kalkulahin ang mga katangian batay sa iba't ibang uri ng input. Halimbawa, ang MyRectone class sa isang ibinigay na talahanayan ay lumilikha ng isang MyRectone constructor at nagpapasa ng ibang parameter sa halip na lumikha ng iba't ibang pamamaraan para sa mga ibinigay na argumento.

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

Konklusyon:

Tumatawag sa isa pang Constructor

Ang isang constructor ay maaaring isang superset ng isa pang constructor na tinukoy sa iyong klase; iyon ay, maaari silang kumilos ng pareho at kaunti pa. Sa halip na i-duplicate ang magkatulad na pag-uugali sa maraming paraan ng constructor sa aming klase, makatuwirang tawagan lang ang unang constructor na iyon mula sa katawan ng pangalawang constructor. Nagbibigay ang Java ng isang espesyal na syntax para dito. Upang tumawag sa isang constructor na tinukoy sa kasalukuyang klase, gamitin ang form na ito:

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

Ang mga argumento dito ay, siyempre, ang mga argumento sa constructor.

Mga Abstract na Klase at Interface ng Java

Pinagmulan: Dev.to Ang abstract na klase ay isang klase na may ilang pamamaraan na walang buong kahulugan at mayroong abstract modifier .

• Hindi ka makakagawa ng object gamit ang constructor ng abstract class.
• Maaari kang gumamit ng abstract class bilang base class para tukuyin ang isang derived class.
• Ang isang abstract na klase ay may hindi bababa sa isang abstract na pamamaraan.
• Abstract na paraan : may header tulad ng isang regular na pamamaraan, ngunit walang katawan, at nangangailangan ng abstract modifier at semicolon.
• Ang abstract na paraan ay hindi maaaring pribado.
• Ang abstract na klase ay maaaring isang uri.

Halimbawa:

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

public abstract double getPay();
}

Interface : Tinutukoy ang isang hanay ng mga pamamaraan na dapat mayroon ang anumang klase na nagpapatupad ng interface na ito.

• Ang isang interface ay isang uri.
• Naglalaman ito ng mga header ng pamamaraan na walang kahulugan at walang mga variable ng instance:

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

Upang ipatupad ang isang interface, ang isang klase ay dapat gumawa ng dalawang bagay:

• Isama ang mga nagpapatupad ng InterfaceName .
• Dapat ipatupad ng klase ang lahat ng mga header ng pamamaraan na nakalista sa interface.

public class Implementer implements Interface1 {

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

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

}

• Ang mga header ng pamamaraan ay ipinahayag na pampubliko .
• Ang isang abstract na klase ay maaari ding magpatupad ng isang interface, ang klase na ito ay nagbibigay ng mga kahulugan para sa ilan sa mga header ng pamamaraan sa interface.
• Ang mga interface ng Java ay maaari ding maglaman ng constant , halimbawa:

public interface Constant {

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

• Anumang klase na nagpapatupad ng Constant interface ay awtomatikong magkakaroon ng mga constant na ito, halimbawa:

public class Constants implements Constant {

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

}

• Maaari mong paghaluin ang paggamit ng mga interface sa pamamagitan ng pagsasama ng mga constant at method header sa isang interface.
• Hindi sinusuportahan ng Java ang maramihang inheritance, kaya ang isang klase ay maaari lamang mag-extend ng isang base class. Gayunpaman, gamit ang mga interface, ang isang klase ay maaaring magpatupad ng maramihang mga interface:

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

}

• Ang dahilan kung bakit ang isang Java class ay maaari lamang mag-extend ng isang base class ay dahil kung ang Java ay nagpapahintulot ng dalawang base class, ang dalawang klase ay maaaring magkaroon ng parehong method na header na may ibang kahulugan, na nagreresulta sa hindi pagkakapare-pareho.
• Maaaring hindi magkatugma ang dalawang interface kung tutukuyin mo ang dalawang constant na may parehong pangalan at magkaibang mga halaga:

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

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