คอฟฟี่เบรค #107. วิธีการสร้างใน Java I Constructor Overload คลาส Java และอินเทอร์เฟซเชิงนามธรรม

วิธีการสร้างใน Java I Constructor Overload

ที่มา: Objectliedprogramming77 Constructor คืออะไร นี่เป็นวิธีพิเศษที่มีชื่อเหมือนกับชื่อของคลาส ซึ่งกำหนดวิธีการเตรียมใช้งานออบเจ็กต์เมื่อถูกสร้างขึ้น เช่นเดียวกับวิธีอื่นๆ เรายังสามารถกำหนด วิธี Constructorในโปรแกรม Java ของเราได้ แต่ไม่เหมือนกับวิธีอื่นๆ เราไม่สามารถเรียกConstructorได้โดยตรง Java เรียก Constructor โดยอัตโนมัติเมื่อวัตถุถูกสร้างขึ้น เมื่อเราใช้ คีย์เวิร์ดใหม่เพื่อสร้างอ็อบเจ็กต์ของคลาส Java จะทำสามสิ่ง:

• จัดสรรหน่วยความจำให้กับวัตถุ
• เริ่มต้นตัวแปรอินสแตนซ์ของออบเจ็กต์นี้ด้วยค่าเริ่มต้นหรือค่าเริ่มต้น
• เรียกตัวสร้างวิธีการของชั้นเรียน

หากคลาสไม่ได้กำหนด เมธอด Constructorใดๆ เราจะยังคงสร้างอ็อบเจ็กต์ของคลาสนั้น แต่เราต้องตั้งค่าตัวแปรอินสแตนซ์หรือเรียกใช้เมธอดอื่น ซึ่งจะต้องเริ่มต้นอ็อบเจ็กต์ด้วยอ็อบเจ็กต์นั้นในภายหลัง ด้วยการกำหนด วิธีConstructorในคลาสของเราเอง เราสามารถตั้งค่าเริ่มต้นของตัวแปรอินสแตนซ์ เรียกวิธีการตามตัวแปรนั้น หรือเรียกวิธีการบนวัตถุอื่น ๆ หรือคำนวณคุณสมบัติเริ่มต้นของวัตถุของเรา นอกจากนี้เรายังสามารถโอเวอร์โหลดConstructorเช่นเดียวกับวิธีการปกติเพื่อสร้างอ็อบเจ็กต์ที่มีคุณสมบัติบางอย่างตามอาร์กิวเมนต์ที่เราส่งไปยัง new

ตัวสร้างพื้นฐาน

ตามคำจำกัดความConstructorดูเหมือนเป็นวิธีการปกติโดยมีข้อแตกต่างหลักสองประการ

• ชื่อ Constructorและคลาสจะเหมือนกันเสมอ
• มันไม่มีประเภทส่งคืน

ตัวอย่างเช่น ตารางด้านล่างแสดงคลาสPerson แบบธรรมดาพร้อมตัวสร้างที่เริ่ม ต้นตัวแปรอินสแตนซ์ตาม อาร์กิวเมนต์ ใหม่ คลาสนี้ยังรวมถึงวิธีการที่อ็อบเจ็กต์สามารถแนะนำตัวเองได้ และ วิธีการ main()สำหรับการทดสอบแต่ละคลาสเหล่านี้

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

เราได้รับผลลัพธ์:

ตัวสร้างโอเวอร์โหลด

เช่นเดียวกับวิธีอื่นๆConstructorยังสามารถยอมรับจำนวนและประเภทของพารามิเตอร์ที่แตกต่างกัน ช่วยให้สามารถสร้างออบเจ็กต์ด้วยคุณสมบัติที่ระบุ หรืออนุญาตให้Constructorคำนวณคุณสมบัติตามอินพุตประเภทต่างๆ ตัวอย่างเช่น คลาสMyRectoneในตารางที่กำหนดจะสร้าง ตัวสร้าง MyRectoneและส่งพารามิเตอร์อื่นแทนการสร้างวิธีการที่แตกต่างกันสำหรับอาร์กิวเมนต์ที่กำหนด

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

บทสรุป:

เรียกตัวสร้างอื่น

Constructor สามารถเป็น superset ของ Constructor อื่นที่กำหนดไว้ในคลาสของคุณ นั่นคือพวกเขาสามารถประพฤติเหมือนเดิมและเพิ่มอีกนิดหน่อย แทนที่จะทำซ้ำพฤติกรรมที่เหมือนกันในเมธอด Constructor หลายๆ วิธีในคลาสของเรา มันสมเหตุสมผลแล้วที่จะเรียก Constructor ตัวแรกจากเนื้อความของ Constructor ตัวที่สองได้ Java มีไวยากรณ์พิเศษสำหรับสิ่งนี้ หากต้องการเรียก Constructor ที่กำหนดไว้ในคลาสปัจจุบัน ให้ใช้แบบฟอร์มนี้:

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

แน่นอนว่า ข้อโต้แย้งของเรื่องนี้ คือข้อโต้แย้งของตัวสร้าง

คลาส Java และอินเทอร์เฟซเชิงนามธรรม

ที่มา: Dev.to คลาสนามธรรมคือคลาสที่มีวิธีการบางอย่างโดยไม่มีคำจำกัดความแบบเต็มและมีตัว แก้ไข นามธรรม

• คุณไม่สามารถสร้างวัตถุโดยใช้ตัวสร้างคลาสนามธรรมได้
• คุณสามารถใช้คลาสนามธรรมเป็นคลาสพื้นฐานเพื่อกำหนดคลาสที่ได้รับ
• คลาสนามธรรมมีวิธีนามธรรมอย่างน้อยหนึ่งวิธี
• วิธีบทคัดย่อ : มีส่วนหัวเหมือนวิธีปกติ แต่ไม่มีเนื้อหา และต้องมี ตัวแก้ไข นามธรรมและอัฒภาค
• วิธีนามธรรมไม่สามารถเป็นแบบส่วนตัวได้
• คลาสนามธรรมสามารถเป็นประเภทได้

ตัวอย่าง:

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

public abstract double getPay();
}

อินเทอร์เฟซ : กำหนดชุดของวิธีการที่คลาสใด ๆ ที่ใช้อินเทอร์เฟซนี้ต้องมี

• อินเทอร์เฟซเป็นประเภท
• มันมีส่วนหัวของวิธีการที่ไม่มีคำจำกัดความและไม่มีตัวแปรอินสแตนซ์:

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

หากต้องการใช้อินเทอร์เฟซ คลาสต้องทำสองสิ่ง:

• รวมการใช้ งานInterfaceName
• คลาสจะต้องใช้ส่วนหัวของวิธีการทั้งหมดที่ระบุไว้ในอินเทอร์เฟซ

public class Implementer implements Interface1 {

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

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

}

• ส่วน หัวของวิธีการประกาศต่อสาธารณะ
• คลาสนามธรรมยังสามารถใช้อินเทอร์เฟซได้ คลาสนี้ให้คำจำกัดความสำหรับ ส่วนหัวของเมธอด บางส่วนในอินเทอร์เฟซ
• อินเทอร์เฟซ Java ยังสามารถมีค่าคงที่ได้ เช่น:

public interface Constant {

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

• คลาสใดๆ ที่ใช้ อินเทอร์เฟซ Constantจะมีค่าคงที่เหล่านี้โดยอัตโนมัติ ตัวอย่างเช่น:

public class Constants implements Constant {

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

}

• คุณสามารถผสมผสานการใช้อินเทอร์เฟซโดยรวมค่าคงที่และส่วนหัวของวิธีการไว้ในอินเทอร์เฟซเดียว
• Java ไม่รองรับการสืบทอดหลายรายการ ดังนั้นคลาสจึงสามารถขยายคลาสพื้นฐานได้เพียงคลาสเดียวเท่านั้น อย่างไรก็ตาม การใช้อินเทอร์เฟซ คลาสสามารถใช้หลายอินเทอร์เฟซได้:

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

}

• สาเหตุที่คลาส Java สามารถขยายได้เพียงคลาสพื้นฐานเดียวเท่านั้น เพราะหาก Java อนุญาตให้มีคลาสพื้นฐานสองคลาส ทั้งสองคลาสอาจมีส่วนหัวของเมธอดเดียวกันแต่มีคำจำกัดความที่แตกต่างกัน ส่งผลให้เกิดความไม่สอดคล้องกัน
• อินเทอร์เฟซสองตัวอาจเข้ากันไม่ได้หากคุณกำหนดค่าคงที่สองตัวด้วยชื่อเดียวกันและค่าต่างกัน:

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

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