Coffee break #107. Kaedah Pembina dalam Java I Overload Pembina. Kelas dan Antara Muka Java Abstrak

Kaedah Pembina dalam Java I Overload Pembina

Sumber: Objectorientedprogramming77 Apakah itu Pembina ? Ini ialah jenis kaedah khas yang namanya sama dengan nama kelas, yang menentukan cara objek dimulakan apabila ia dicipta. Seperti kaedah lain, kami juga boleh mentakrifkan kaedah Pembina dalam program Java kami, tetapi tidak seperti kaedah lain, kami tidak boleh memanggil Pembina secara langsung; Java memanggil pembina secara automatik apabila objek dicipta. Apabila kami menggunakan kata kunci baharu untuk mencipta objek kelas, Java melakukan tiga perkara:

• Memperuntukkan memori untuk objek.
• Mulakan pembolehubah contoh objek ini dengan nilai awal atau lalainya.
• Memanggil pembina Kaedah kelas.

Jika kelas tidak mentakrifkan sebarang kaedah Pembina , kami masih akan mencipta objek kelas itu, tetapi kami mesti menetapkan pembolehubah contoh atau memanggil kaedah lain, yang kemudiannya mesti memulakan objek dengan objek itu. Dengan mentakrifkan kaedah Pembina dalam kelas kita sendiri, kita boleh menetapkan nilai awal pembolehubah contoh, memanggil kaedah berdasarkan pembolehubah itu, atau memanggil kaedah pada objek lain, atau mengira sifat awal objek kita. Kita juga boleh membebankan Pembina seperti kaedah biasa untuk mencipta objek yang mempunyai sifat tertentu berdasarkan hujah yang kita hantar ke new .

Pembina Asas

Mengikut definisi, Pembina kelihatan seperti kaedah biasa dengan dua perbezaan utama.

• Nama pembina dan kelas sentiasa sama.
• Ia tidak mempunyai jenis pulangan

Sebagai contoh, jadual di bawah menunjukkan kelas Orang mudah dengan pembina yang memulakan pembolehubah contohnya berdasarkan argumen baharu . Kelas juga termasuk kaedah yang mana objek boleh memperkenalkan dirinya, dan kaedah main() untuk menguji setiap kelas ini.

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

Kami mendapat output:

Pembina yang berlebihan

Seperti kaedah lain, Pembina juga boleh menerima nombor dan jenis parameter yang berbeza, membenarkan objek dicipta dengan sifat tertentu, atau membenarkan Pembina mengira sifat berdasarkan jenis input yang berbeza. Sebagai contoh, kelas MyRectone dalam jadual tertentu mencipta pembina MyRectone dan menghantar parameter berbeza dan bukannya mencipta kaedah berbeza untuk hujah yang diberikan.

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

Kesimpulan:

Memanggil Pembina lain

Pembina boleh menjadi superset pembina lain yang ditakrifkan dalam kelas anda; iaitu, mereka boleh berkelakuan sama ditambah lebih sedikit. Daripada menduplikasi gelagat yang sama merentas berbilang kaedah pembina dalam kelas kami, adalah masuk akal untuk dapat memanggil pembina pertama itu daripada badan pembina kedua. Java menyediakan sintaks khas untuk ini. Untuk memanggil pembina yang ditakrifkan dalam kelas semasa, gunakan borang ini:

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

Hujah untuk ini , sudah tentu, hujah kepada pembina.

Kelas dan Antara Muka Java Abstrak

Sumber: Dev.to Kelas abstrak ialah kelas yang mempunyai beberapa kaedah tanpa definisi penuh dan mempunyai pengubah suai abstrak .

• Anda tidak boleh mencipta objek menggunakan pembina kelas abstrak.
• Anda boleh menggunakan kelas abstrak sebagai kelas asas untuk menentukan kelas terbitan.
• Kelas abstrak mempunyai sekurang-kurangnya satu kaedah abstrak.
• Kaedah abstrak : mempunyai pengepala seperti kaedah biasa, tetapi tanpa badan, dan memerlukan pengubah suai abstrak dan koma bertitik.
• Kaedah abstrak tidak boleh peribadi.
• Kelas abstrak boleh menjadi jenis.

Contoh:

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

public abstract double getPay();
}

Antara Muka : Mentakrifkan satu set kaedah yang mesti ada pada mana-mana kelas yang melaksanakan antara muka ini.

• Antara muka ialah sejenis.
• Ia mengandungi pengepala kaedah tanpa definisi dan tiada pembolehubah contoh:

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

Untuk melaksanakan antara muka, kelas mesti melakukan dua perkara:

• Sertakan melaksanakan InterfaceName .
• Kelas mesti melaksanakan semua pengepala kaedah yang disenaraikan dalam antara muka.

public class Implementer implements Interface1 {

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

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

}

• Pengepala kaedah diisytiharkan awam .
• Kelas abstrak juga boleh melaksanakan antara muka, kelas ini menyediakan definisi untuk beberapa pengepala kaedah dalam antara muka.
• Antara muka Java juga boleh mengandungi constant , contohnya:

public interface Constant {

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

• Mana-mana kelas yang melaksanakan antara muka Constant akan mempunyai pemalar ini secara automatik, contohnya:

public class Constants implements Constant {

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

}

• Anda boleh mencampurkan penggunaan antara muka dengan memasukkan pemalar dan pengepala kaedah ke dalam satu antara muka.
• Java tidak menyokong pelbagai warisan, jadi kelas hanya boleh melanjutkan satu kelas asas. Walau bagaimanapun, menggunakan antara muka, kelas boleh melaksanakan berbilang antara muka:

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

}

• Sebab mengapa kelas Java hanya boleh melanjutkan satu kelas asas adalah kerana jika Java membenarkan dua kelas asas, kedua-dua kelas mungkin mempunyai pengepala kaedah yang sama dengan definisi yang berbeza, mengakibatkan ketidakkonsistenan.
• Dua antara muka boleh menjadi tidak serasi jika anda menentukan dua pemalar dengan nama yang sama dan nilai yang berbeza:

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

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