ลักษณะใดที่ดีกว่า (ตัวแปรอินสแตนซ์กับค่าตอบแทน) ใน Java

ฉันมักจะพบว่าตัวเองกำลังดิ้นรนเพื่อตัดสินใจว่าจะใช้วิธีใดในสองวิธีนี้เมื่อฉันต้องการใช้ข้อมูลทั่วไปในบางวิธีในชั้นเรียนของฉัน อะไรจะเป็นทางเลือกที่ดีกว่า

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

public class MyClass {
    private int var1;

    MyClass(){
        doSomething();
        doSomethingElse();
        doMoreStuff();
    }

    private void doSomething(){
        var1 = 2;
    }

    private void doSomethingElse(){
        int var2 = var1 + 1;
    }

    private void doMoreStuff(){
        int var3 = var1 - 1;
    }
}

หรือเพียงแค่สร้างตัวแปรท้องถิ่นและส่งให้พวกเขาเป็นอาร์กิวเมนต์?

public class MyClass {  
    MyClass(){
        int var1 = doSomething();
        doSomethingElse(var1);
        doMoreStuff(var1);
    }

    private int doSomething(){
        int var = 2;
        return var;
    }

    private void doSomethingElse(int var){
        int var2 = var + 1;
    }

    private void doMoreStuff(int var){
        int var3 = var - 1;
    }
}

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

ฉันประหลาดใจที่ยังไม่ได้พูดถึง ...

ขึ้นอยู่กับว่าvar1เป็นส่วนหนึ่งของสถานะวัตถุของคุณหรือไม่

คุณคิดว่าทั้งสองวิธีนี้ถูกต้องและเป็นเพียงเรื่องของสไตล์ คุณผิด.

นี่คือทั้งหมดเกี่ยวกับวิธีการสร้างแบบจำลองอย่างถูกต้อง

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

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

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

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

ลักษณะใดที่ดีกว่า (ตัวแปรอินสแตนซ์กับค่าตอบแทน) ใน Java

มีสไตล์อื่น - ใช้บริบท / รัฐ

public static class MyClass {
    // Hold my state from one call to the next.
    public static final class State {
        int var1;
    }

    MyClass() {
        State state = new State();
        doSomething(state);
        doSomethingElse(state);
        doMoreStuff(state);
    }

    private void doSomething(State state) {
        state.var1 = 2;
    }

    private void doSomethingElse(State state) {
        int var2 = state.var1 + 1;
    }

    private void doMoreStuff(State state) {
        int var3 = state.var1 - 1;
    }
}

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

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

มันเกี่ยวกับผลข้างเคียง

การถามว่าvar1รัฐเป็นส่วนหนึ่งของประเด็นนี้หรือไม่ แน่นอนว่าถ้าvar1ต้องคงอยู่มันจะต้องเป็นตัวอย่าง วิธีใดวิธีหนึ่งสามารถทำงานได้ไม่ว่าจะต้องมีการคงอยู่หรือไม่ก็ตาม

วิธีผลข้างเคียง

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

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

วิธีการใช้งาน

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

เป็นส่วนหนึ่งของรัฐหรือไม่คุณยังสามารถใช้วิธีใดวิธีหนึ่ง

ในตัวอย่างเหล่านี้ 'var1' ไม่มีการห่อหุ้มอะไรนอกจาก debugger ของคุณจึงรู้ว่ามันมีอยู่ ฉันเดาว่าคุณทำอย่างนั้นเพราะคุณไม่ต้องการอคติกับเรา โชคดีที่ฉันไม่สนใจสิ่งที่

ความเสี่ยงของผลข้างเคียง

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

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

ผลข้างเคียงที่กลับหัวกลับหาง

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

ข้อเสียของวิธีการทำงานส่วนตัว

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

โพสต์ conditionals

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

ข้อสรุป

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

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

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

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

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

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

ลองตัวอย่างที่ทำอะไรบางอย่าง ยกโทษให้ฉันตั้งแต่นี้ไม่ใช่ javascript จาวา จุดควรเหมือนกัน

ไปที่https://blockly-games.appspot.com/pond-duck?lang=thคลิกแท็บ javascript แล้ววางสิ่งนี้:

hunt = lock(-90,1), 
heading = -135;

while(true) {
  hunt()  
  heading += 2
  swim(heading,30)
}

function lock(direction, width) {
  var dir = direction
  var wid = width
  var dis = 10000

  //hunt
  return function() {
    //randomize() //Calling this here makes the state of dir meaningless
    scanLock()
    adjustWid()
    if (isSpotted()) {
      if (inRange()) {
        if (wid <= 4) {
          cannon(dir, dis)
        }
      }
    } else {
      if (!left()) {
        right()
      }
    }
  }

  function scanLock() {
    dis = scan(dir, wid);
  }

  function adjustWid() {
    if (inRange()) {
      if (wid > 1)
        wid /= 2;
    } else {
      if (wid < 16) {
        wid *= 2; 
      }
    }
  }

  function isSpotted() {
    return dis < 1000;
  }

  function left() {
    dir += wid;
    scanLock();
    return isSpotted();
  }

  function right() {
    dir -= wid*2;
    scanLock();
    return isSpotted()
  }

  function inRange() {
    return dis < 70;
  }

  function randomize() {
    dir = Math.random() * 360
  }
}

คุณควรจะแจ้งให้ทราบว่าdir, widและdisจะไม่ได้รับการผ่านรอบมาก คุณควรสังเกตว่ารหัสในฟังก์ชั่นที่lock()ส่งคืนดูเหมือนรหัสหลอก มันเป็นรหัสจริง แต่มันอ่านง่ายมาก เราสามารถเพิ่มการส่งผ่านและการมอบหมาย แต่นั่นจะเพิ่มความยุ่งเหยิงที่คุณไม่เคยเห็นในรหัสหลอก

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

แน่นอนว่าตอนนี้เราสามารถเลื่อนdirลงไปในขอบเขตได้แล้ว แต่ไม่ใช่โดยไม่ถูกบังคับให้ทำเรื่องหลอก ๆ ของเราอย่างรหัสผ่านและตั้งค่า

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

ไม่ได้หมายความว่าพวกเขาจะกลายเป็นปาเก็ตตี้อย่างฝันร้ายไม่ได้ แต่แล้วจะทำอะไรไม่ได้

การล่าเป็ดอย่างมีความสุข