โครงสร้างเหมือนวัตถุใน Java

มันผิดกับวิธีของจาวาในการสร้างโครงสร้างเหมือนวัตถุหรือไม่

class SomeData1 {
    public int x;
    public int y;
}

ฉันสามารถดูคลาสที่มี accessors และ mutators เป็น Java มากกว่า

class SomeData2 {
    int getX();
    void setX(int x);

    int getY();
    void setY(int y);

    private int x;
    private int y;
}

ชั้นเรียนจากตัวอย่างแรกนั้นใช้งานไม่สะดวก

// a function in a class
public int f(SomeData1 d) {
    return (3 * d.x) / d.y;
}

สิ่งนี้ไม่สะดวก

// a function in a class
public int f(SomeData2 d) {
    return (3 * d.getX()) / d.getY();
}

นี่เป็นหัวข้อที่พูดถึงโดยทั่วไป ข้อเสียเปรียบของการสร้างเขตข้อมูลสาธารณะในวัตถุคือคุณไม่สามารถควบคุมค่าที่ตั้งไว้ ในโครงการกลุ่มที่มีโปรแกรมเมอร์จำนวนมากใช้รหัสเดียวกันสิ่งสำคัญคือการหลีกเลี่ยงผลข้างเคียง นอกจากนี้บางครั้งมันจะดีกว่าที่จะคืนค่าสำเนาของวัตถุหรือแปลงอย่างใด ฯลฯ คุณสามารถเยาะเย้ยวิธีการดังกล่าวในการทดสอบของคุณ หากคุณสร้างคลาสใหม่คุณอาจไม่เห็นการกระทำที่เป็นไปได้ทั้งหมด มันก็เหมือนกับการเขียนโปรแกรมเชิงป้องกัน - ผู้บุกรุกและผู้ตั้งค่าสักวันหนึ่งอาจมีประโยชน์และไม่มีค่าใช้จ่ายในการสร้าง / ใช้งานมากนัก ดังนั้นบางครั้งพวกเขาก็มีประโยชน์

ในทางปฏิบัติฟิลด์ส่วนใหญ่มีตัวเชื่อมต่อและตัวตั้ง ทางออกที่เป็นไปได้จะมีลักษณะเช่นนี้:

public property String foo;   
a->Foo = b->Foo;

อัปเดต: ไม่น่าเป็นไปได้อย่างมากที่การสนับสนุนอสังหาริมทรัพย์จะถูกเพิ่มใน Java 7 หรืออาจจะเคย ภาษา JVM อื่น ๆ เช่น Groovy, Scala และอื่น ๆ รองรับคุณสมบัตินี้ทันที - อเล็กซ์มิลเลอร์

ปรากฏว่าคน Java จำนวนมากไม่คุ้นเคยกับแนวทางการเข้ารหัสของ Sun Java ซึ่งกล่าวว่าค่อนข้างเหมาะสมที่จะใช้ตัวแปรอินสแตนซ์สาธารณะเมื่อคลาสนั้นเป็น "Struct" เป็นหลักหาก Java รองรับ "struct" (เมื่อไม่มีพฤติกรรม)

คนมักจะคิดว่า getters และ setters เป็นวิธีของ Java ราวกับว่าพวกเขาเป็นหัวใจของ Java ไม่เป็นเช่นนั้น หากคุณปฏิบัติตามแนวทางการเข้ารหัสของ Sun Java โดยใช้ตัวแปรอินสแตนซ์สาธารณะในสถานการณ์ที่เหมาะสมคุณกำลังเขียนโค้ดได้ดีกว่าการถ่วงด้วยตัวรับสัญญาณที่ไม่จำเป็น

Java Code Conventions จากปี 1999และยังคงไม่เปลี่ยนแปลง

10.1 ให้การเข้าถึงอินสแตนซ์และตัวแปรของคลาส

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

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

http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-137265.html#177

http://en.wikipedia.org/wiki/Plain_old_data_structure

http://docs.oracle.com/javase/1.3/docs/guide/collections/designfaq.html#28

ใช้สามัญสำนึกจริงๆ หากคุณมีสิ่งที่ชอบ:

public class ScreenCoord2D{
    public int x;
    public int y;
}

จากนั้นก็มีจุดเล็ก ๆ ในการห่อหุ้มพวกมันด้วยตัวดูด คุณจะไม่เก็บพิกัด x และ y เป็นพิกเซลทั้งหมดด้วยวิธีอื่น Getters และ setters จะทำให้คุณช้าลงเท่านั้น

ในทางกลับกันด้วย:

public class BankAccount{
    public int balance;
}

คุณอาจต้องการเปลี่ยนวิธีการคำนวณยอดคงเหลือ ณ จุดหนึ่งในอนาคต นี่ควรใช้ getters และ setters จริงๆ

เป็นที่ทราบกันดีอยู่เสมอว่าทำไมคุณถึงใช้แนวปฏิบัติที่ดีเพื่อที่คุณจะได้รู้ว่าเมื่อใด

ในการแก้ไขปัญหาความไม่แน่นอนคุณสามารถประกาศ x และ y เป็นที่สิ้นสุด ตัวอย่างเช่น:

class Data {
  public final int x;
  public final int y;
  public Data( int x, int y){
    this.x = x;
    this.y = y;
  }
}

รหัสการโทรที่พยายามเขียนไปยังเขตข้อมูลเหล่านี้จะได้รับข้อผิดพลาดในการคอมไพล์เวลาของ "เขตข้อมูล x ถูกประกาศครั้งสุดท้ายไม่สามารถกำหนดได้"

รหัสลูกค้าสามารถมี 'ความสะดวก' ที่คุณอธิบายไว้ในโพสต์ของคุณ

public class DataTest {
    public DataTest() {
        Data data1 = new Data(1, 5);
        Data data2 = new Data(2, 4);
        System.out.println(f(data1));
        System.out.println(f(data2));
    }

    public int f(Data d) {
        return (3 * d.x) / d.y;
    }

    public static void main(String[] args) {
        DataTest dataTest = new DataTest();
    }
}

อย่าใช้publicฟิลด์

อย่าใช้publicฟิลด์เมื่อคุณต้องการห่อพฤติกรรมภายในของชั้นเรียน ใช้java.io.BufferedReaderตัวอย่างเช่น มีฟิลด์ต่อไปนี้:

private boolean skipLF = false; // If the next character is a line feed, skip it

skipLFอ่านและเขียนในวิธีการอ่านทั้งหมด จะเกิดอะไรขึ้นถ้าคลาสภายนอกที่รันในเธรดแยกต่างหากปรับเปลี่ยนสถานะของการเป็นอันตรายระหว่างskipLFการอ่าน BufferedReaderจะไปยุ่งเหยิงแน่นอน

ใช้publicฟิลด์

เวลานี้Pointระดับตัวอย่างเช่น:

class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return this.x;
    }

    public double getY() {
        return this.y;
    }

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }
}

นี่จะทำให้การคำนวณระยะทางระหว่างจุดสองจุดนั้นเจ็บปวดมากในการเขียน

Point a = new Point(5.0, 4.0);
Point b = new Point(4.0, 9.0);
double distance = Math.sqrt(Math.pow(b.getX() - a.getX(), 2) + Math.pow(b.getY() - a.getY(), 2));

ชั้นไม่มีพฤติกรรมใด ๆ นอกจาก getters และ setters ธรรมดา เป็นที่ยอมรับได้ที่จะใช้เขตข้อมูลสาธารณะเมื่อชั้นแสดงเพียงโครงสร้างข้อมูลและไม่มีและจะไม่มีลักษณะการทำงาน (thin getters และ setters ไม่ถือเป็นพฤติกรรมที่นี่) มันสามารถเขียนได้ดีกว่าด้วยวิธีนี้:

class Point {
    public double x;
    public double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

Point a = new Point(5.0, 4.0);
Point b = new Point(4.0, 9.0);
double distance = Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));

Clean!

แต่จำไว้: ไม่เพียง แต่ระดับของคุณจะต้องขาดของพฤติกรรม แต่มันก็ควรจะมีไม่มีเหตุผลที่จะมีพฤติกรรมในอนาคตได้เป็นอย่างดี

(นี่คือสิ่งที่คำตอบนี้จะอธิบายในการอ้างอิง"ข้อตกลงรหัสสำหรับภาษาการเขียนโปรแกรม Java: 10. วิธีปฏิบัติด้านการเขียนโปรแกรม" :

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

ดังนั้นเอกสารอย่างเป็นทางการก็ยอมรับการปฏิบัติเช่นนี้ด้วย)

นอกจากนี้หากคุณแน่ใจเป็นอย่างยิ่งว่าสมาชิกของPointกลุ่มที่กล่าวมาจะไม่เปลี่ยนรูปคุณสามารถเพิ่มfinalคำหลักเพื่อบังคับใช้:

public final double x;
public final double y;

โดยวิธีการที่โครงสร้างที่คุณกำลังให้เป็นตัวอย่างที่มีอยู่แล้วใน Java java.awt.Pointห้องสมุดชั้นฐานเป็น มันมี x และ y เป็นฟิลด์สาธารณะตรวจสอบได้ด้วยตัวคุณเอง

ถ้าคุณรู้ว่าคุณกำลังทำอะไรและคนอื่น ๆ ในทีมของคุณรู้เกี่ยวกับมันแล้วมันก็โอเคที่จะมีสาขาสาธารณะ แต่คุณไม่ควรเชื่อถือเพราะพวกเขาสามารถทำให้เกิดอาการปวดหัวในข้อผิดพลาดที่เกี่ยวข้องกับนักพัฒนาโดยใช้วัตถุราวกับว่าพวกเขาได้รับการจัดสรรสแต็ก structs (วัตถุจาวาจะถูกส่งไปยังวิธีการอ้างอิงและไม่ใช่สำเนา)

Re: aku, izb, John Topley ...

ระวังปัญหาความไม่แน่นอน ...

มันอาจดูสมเหตุสมผลที่จะละเว้นผู้ได้รับ / setters จริง ๆ แล้วมันอาจจะโอเคในบางกรณี ปัญหาที่แท้จริงของรูปแบบที่เสนอที่แสดงในที่นี้คือความไม่แน่นอน

ปัญหาคือเมื่อคุณส่งการอ้างอิงวัตถุที่มีเขตข้อมูลที่ไม่ใช่เขตข้อมูลสาธารณะ สิ่งอื่นใดที่มีการอ้างอิงนั้นสามารถแก้ไขฟิลด์เหล่านั้นได้ฟรี คุณไม่สามารถควบคุมสถานะของวัตถุนั้นได้อีกต่อไป (คิดว่าจะเกิดอะไรขึ้นถ้าสตริงไม่แน่นอน)

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

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

โปรดดูที่: " Java ที่มีประสิทธิภาพ " โดย Joshua Bloch - รายการ # 13: ความไม่สามารถเปลี่ยนใจได้

PS: โปรดทราบว่า JVM ทุกวันนี้จะเพิ่มประสิทธิภาพของ getMethod หากเป็นไปได้ซึ่งจะทำให้เกิดคำสั่งในการอ่านฟิลด์เพียงครั้งเดียว

ฉันได้ลองทำสิ่งนี้ในสองสามโครงการตามทฤษฎีที่ getters และ setters สร้างความสับสนให้กับโค้ดโดยใช้ cruft ที่ไม่มีความหมายและภาษาอื่น ๆ ดูเหมือนจะใช้ได้ดีกับการซ่อนข้อมูลหรือการแบ่งหน้าที่ความรับผิดชอบ (เช่น python)

ดังที่คนอื่น ๆ ได้กล่าวไว้ข้างต้นมี 2 ปัญหาที่คุณพบและพวกเขาไม่สามารถแก้ไขได้จริง:

• เครื่องมืออัตโนมัติใด ๆ ในโลก java อาศัยการประชุม getter / setter เช่นเดียวกับที่ระบุไว้โดยผู้อื่นแท็ก jsp การกำหนดค่าสปริงเครื่องมือคราส ฯลฯ ฯลฯ ... การต่อสู้กับสิ่งที่เครื่องมือของคุณคาดว่าจะเห็นเป็นสูตรสำหรับเซสชันที่ยาวนานซึ่งหมุนรอบผ่าน Google พยายามค้นหาวิธีที่ไม่เป็นมาตรฐานในการเริ่มต้น ถั่วฝักยาว ไม่คุ้มกับปัญหาเลย
• เมื่อคุณมีแอปพลิเคชั่นที่เข้ารหัสอย่างสวยงามพร้อมตัวแปรสาธารณะหลายร้อยตัวคุณจะพบสถานการณ์อย่างน้อยหนึ่งสถานการณ์ที่ไม่เพียงพอ - ซึ่งคุณต้องการความไม่เปลี่ยนแปลงอย่างแน่นอนหรือคุณต้องทริกเกอร์เหตุการณ์เมื่อตั้งค่าตัวแปรหรือคุณต้องการโยน ข้อยกเว้นเกี่ยวกับการเปลี่ยนแปลงตัวแปรเนื่องจากมันตั้งค่าสถานะวัตถุเป็นสิ่งที่ไม่พึงประสงค์ จากนั้นคุณก็ติดอยู่กับตัวเลือกที่ไม่น่าจะเป็นไปได้ระหว่างการทำให้รหัสของคุณยุ่งเหยิงด้วยวิธีพิเศษบางอย่างในทุกที่ที่มีการอ้างอิงตัวแปรโดยตรงโดยมีแบบฟอร์มการเข้าถึงพิเศษสำหรับตัวแปร 3 ใน 1,000 ตัวในใบสมัครของคุณ

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

Java นั้นละเอียดมากและนี่เป็นสิ่งที่น่าดึงดูด อย่าทำมัน

หากวิธี Java เป็นวิธี OO แล้วใช่การสร้างคลาสที่มีเขตข้อมูลสาธารณะจะทำลายหลักการเกี่ยวกับการซ่อนข้อมูลซึ่งบอกว่าวัตถุควรจัดการสถานะภายในของตัวเอง (ดังนั้นเมื่อฉันไม่เพียงแค่พูดศัพท์แสงใส่มือคุณประโยชน์ของการซ่อนข้อมูลคือการทำงานภายในของคลาสนั้นถูกซ่อนอยู่หลังอินเตอร์เฟซ - กล่าวว่าคุณต้องการเปลี่ยนกลไกที่คลาส struct ของคุณบันทึกไว้ในฟิลด์ใดฟิลด์หนึ่ง คุณอาจต้องย้อนกลับไปและเปลี่ยนคลาสที่ใช้คลาส ... )

คุณไม่สามารถใช้ประโยชน์จากการสนับสนุนคลาส JavaBean ที่ตั้งชื่อได้ซึ่งจะเกิดความเสียหายหากคุณตัดสินใจพูดใช้คลาสใน JavaServer Page ซึ่งเขียนโดยใช้ Expression Language

บทความ JavaWorld เหตุใดเมธอด Getter และ Setter เป็นบทความที่ไม่ดีอาจเป็นที่สนใจของคุณในการพิจารณาว่าเมื่อใดที่จะไม่ใช้เมธอด accessor และ mutator

หากคุณกำลังเขียนโซลูชันขนาดเล็กและต้องการลดจำนวนรหัสที่เกี่ยวข้องวิธี Java อาจไม่ใช่วิธีที่ถูกต้อง - ฉันคิดว่ามันขึ้นอยู่กับคุณเสมอและปัญหาที่คุณพยายามแก้ไข

ไม่มีอะไรผิดปกติกับรหัสประเภทนั้นโดยที่ผู้เขียนรู้ว่าพวกเขาเป็น structs (หรือกระสวยข้อมูล) แทนวัตถุ นักพัฒนา Java จำนวนมากไม่สามารถบอกความแตกต่างระหว่างวัตถุที่มีรูปแบบที่ดี (ไม่ใช่แค่คลาสย่อยของ java.lang.Object แต่เป็นวัตถุจริงในโดเมนที่ระบุ) และสับปะรด ถึงแม้ว่าพวกเขาจะจบลงด้วยการเขียน structs เมื่อพวกเขาต้องการวัตถุและผู้แทน

ปัญหาเกี่ยวกับการใช้การเข้าถึงข้อมูลสาธารณะเป็นปัญหาเดียวกับการใช้ใหม่แทนที่จะเป็นวิธีการจากโรงงาน - หากคุณเปลี่ยนใจในภายหลังผู้โทรที่มีอยู่ทั้งหมดจะใช้งานไม่ได้ ดังนั้นจากมุมมองวิวัฒนาการของ API มันเป็นความคิดที่ดีที่จะกัดกระสุนและใช้ตัวต่อ / ตัวตั้ง

ที่เดียวที่ฉันไปอีกทางคือเมื่อคุณควบคุมการเข้าถึงคลาสอย่างรุนแรงตัวอย่างเช่นในคลาสสแตติกภายในที่ใช้เป็นโครงสร้างข้อมูลภายใน ในกรณีนี้อาจมีความชัดเจนมากในการใช้การเข้าถึงฟิลด์

อย่างไรก็ตามในการยืนยันของ e-bartek นั้นเป็นไปได้ยากมากที่ IMO จะให้การสนับสนุนด้านคุณสมบัติใน Java 7

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

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

เป็นคำถามที่เก่ามาก แต่ให้ฉันทำอีกสั้น Java 8 แนะนำแลมบ์ดานิพจน์และการอ้างอิงเมธอด นิพจน์แลมบ์ดาอาจเป็นวิธีการอ้างอิงแบบง่าย ๆ และไม่ประกาศเนื้อความ "จริง" แต่คุณไม่สามารถ "แปลง" ฟิลด์เป็นข้อมูลอ้างอิงวิธีการ ดังนั้น

stream.mapToInt(SomeData1::x)

ไม่ถูกกฎหมาย แต่

stream.mapToInt(SomeData2::getX)

คือ.

ฉันไม่เห็นอันตรายถ้าคุณรู้ว่ามันจะเป็นโครงสร้างที่เรียบง่ายและคุณจะไม่ต้องการที่จะแนบพฤติกรรมกับมัน

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

ที่นี่ฉันสร้างโปรแกรมเพื่อป้อนชื่อและอายุของ 5 คนที่แตกต่างกันและดำเนินการเรียงลำดับการเลือก (อายุฉลาด) ฉันใช้คลาสที่ทำหน้าที่เป็นโครงสร้าง (เช่นภาษาการเขียนโปรแกรม C) และคลาสหลักเพื่อดำเนินการให้เสร็จสมบูรณ์ ที่นี่ฉันทำรหัส ...

import java.io.*;

class NameList {
    String name;
    int age;
}

class StructNameAge {
    public static void main(String [] args) throws IOException {

        NameList nl[]=new NameList[5]; // Create new radix of the structure NameList into 'nl' object
        NameList temp=new NameList(); // Create a temporary object of the structure

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        /* Enter data into each radix of 'nl' object */

        for(int i=0; i<5; i++) {
            nl[i]=new NameList(); // Assign the structure into each radix

            System.out.print("Name: ");
            nl[i].name=br.readLine();

            System.out.print("Age: ");
            nl[i].age=Integer.parseInt(br.readLine());

            System.out.println();
        }

        /* Perform the sort (Selection Sort Method) */

        for(int i=0; i<4; i++) {
            for(int j=i+1; j<5; j++) {
                if(nl[i].age>nl[j].age) {
                    temp=nl[i];
                    nl[i]=nl[j];
                    nl[j]=temp;
                }
            }
        }

        /* Print each radix stored in 'nl' object */

        for(int i=0; i<5; i++)
            System.out.println(nl[i].name+" ("+nl[i].age+")");
    }
}

รหัสข้างต้นคือข้อผิดพลาดฟรีและทดสอบ ... เพียงคัดลอกและวางลงใน IDE ของคุณและ ... คุณรู้และอะไร ??? :)

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

บางครั้งฉันใช้คลาสนั้นเมื่อฉันต้องการคืนค่าหลายค่าจากวิธีการ แน่นอนว่าวัตถุดังกล่าวมีอายุสั้นและมีทัศนวิสัยที่ จำกัด ดังนั้นจึงควรตกลง

เช่นเดียวกับสิ่งส่วนใหญ่มีกฎทั่วไปแล้วมีสถานการณ์เฉพาะ หากคุณกำลังปิดแอปพลิเคชั่นที่ถูกดักจับเพื่อให้คุณทราบว่าจะใช้วัตถุใดได้บ้างคุณสามารถออกกำลังกายได้อย่างอิสระมากขึ้นเพื่อสนับสนุนทัศนวิสัยและ / หรือประสิทธิภาพ หากคุณกำลังพัฒนาชั้นเรียนซึ่งผู้อื่นจะใช้งานแบบสาธารณะโดยไม่ได้อยู่ในการควบคุมของคุณให้ลองไปยังโมเดล getter / setter เช่นเดียวกับทุกสิ่งเพียงใช้สามัญสำนึก มันก็โอเคที่จะทำรอบแรกกับสาธารณชนแล้วเปลี่ยนเป็น getter / setters ในภายหลัง

การเขียนโปรแกรมเชิงมุมมองช่วยให้คุณดักจับการมอบหมายหรือดึงข้อมูลและแนบตรรกะการดักจับซึ่งพวกเขาเสนอเป็นวิธีที่เหมาะสมในการแก้ปัญหา (ปัญหาว่าพวกเขาควรจะเป็นสาธารณะหรือได้รับการคุ้มครองหรือป้องกันแพคเกจเป็นมุมฉาก)

ดังนั้นคุณจึงเริ่มต้นด้วยฟิลด์ที่ไม่ถูก จำกัด ด้วยตัวระบุการเข้าถึงที่เหมาะสม เมื่อความต้องการของโปรแกรมของคุณเติบโตขึ้นคุณจะต้องแนบตรรกะเพื่อตรวจสอบทำสำเนาของวัตถุที่ส่งคืนเป็นต้น

ปรัชญา getter / setter กำหนดค่าใช้จ่ายในกรณีง่าย ๆ จำนวนมากซึ่งไม่จำเป็น

ไม่ว่าลักษณะด้านจะสะอาดขึ้นหรือไม่นั้นค่อนข้างมีคุณภาพ ฉันพบว่ามันง่ายที่จะเห็นตัวแปรในชั้นเรียนและดูตรรกะแยกจากกัน ในความเป็นจริง raison d'etre สำหรับการเขียนโปรแกรม Apect-oriented คือความกังวลจำนวนมากถูกตัดขวางและการจัดแบ่งพวกมันในร่างกายคลาสนั้นไม่เหมาะ (การบันทึกเป็นตัวอย่าง - ถ้าคุณต้องการบันทึกทั้งหมดทำให้ Java ต้องการให้คุณ เขียนกลุ่มผู้ได้รับทั้งหมดและทำให้ข้อมูลตรงกัน แต่ AspectJ อนุญาตให้คุณใช้งานแบบหนึ่งครั้ง)

ปัญหาของ IDE คือแฮร์ริ่งแดง มันไม่ได้เป็นเรื่องของการพิมพ์เพราะมันเป็นมลพิษจากการอ่านและการมองเห็นที่เกิดขึ้นจากการรับ / เซต

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

ฉันหวังว่าการรับรู้ของ AspectJ จะป้องกันผู้คนจากการตั้งค่าภาษาแบบไดนามิกก่อนกำหนด