จะส่งพารามิเตอร์ไปยังคลาสที่ไม่ระบุชื่อได้อย่างไร

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

int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // How would one access myVariable here?
    }
});

มีวิธีใดบ้างสำหรับผู้ฟังที่เข้าถึง myVariable หรือผ่าน myVariable โดยไม่ต้องสร้าง listener เป็นคลาสที่มีชื่อจริง?

ในทางเทคนิคไม่เพราะคลาสนิรนามไม่สามารถมีคอนสตรัคเตอร์ได้

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

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

ใช่โดยเพิ่มเมธอด initializer ที่ส่งคืน 'this' และเรียกเมธอดนั้นทันที:

int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    private int anonVar;
    public void actionPerformed(ActionEvent e) {
        // How would one access myVariable here?
        // It's now here:
        System.out.println("Initialized with value: " + anonVar);
    }
    private ActionListener init(int var){
        anonVar = var;
        return this;
    }
}.init(myVariable)  );

ไม่มีการประกาศ 'ขั้นสุดท้าย' ที่จำเป็น

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

แบบนี้:

final int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // Now you can access it alright.
    }
});

สิ่งนี้จะทำเวทย์มนตร์

int myVariable = 1;

myButton.addActionListener(new ActionListener() {

    int myVariable;

    public void actionPerformed(ActionEvent e) {
        // myVariable ...
    }

    public ActionListener setParams(int myVariable) {

        this.myVariable = myVariable;

        return this;
    }
}.setParams(myVariable));

ดังที่แสดงไว้ที่http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-classคุณสามารถเพิ่ม initializer อินสแตนซ์ได้ มันเป็นบล็อกที่ไม่มีชื่อและถูกเรียกใช้ก่อน (เหมือนตัวสร้าง)

ดูเหมือนว่าพวกเขากำลังพูดถึงที่ทำไม initializer java Instance? และinitializer อินสแตนซ์ต่างจากตัวสร้างได้อย่างไร? กล่าวถึงความแตกต่างจากตัวสร้าง

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

ตัวอย่างเช่น: (จากรหัส GWT บางอย่างเพื่อจัดการการเปลี่ยนแปลงกล่องข้อความ):

/* Regular method. Returns the required interface/abstract/class
   Arguments are defined as final */
private ChangeHandler newNameChangeHandler(final String axisId, final Logger logger) {

    // Return a new anonymous class
    return new ChangeHandler() {
        public void onChange(ChangeEvent event) {
            // Access method scope variables           
            logger.fine(axisId)
        }
     };
}

สำหรับตัวอย่างนี้เมธอด class anonymous ใหม่จะถูกอ้างอิงด้วย:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

หรือใช้ข้อกำหนดของ OP:

private ActionListener newActionListener(final int aVariable) {
    return new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            System.out.println("Your variable is: " + aVariable);
        }
    };
}
...
int myVariable = 1;
newActionListener(myVariable);

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

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

int myVariable = 1;

{
    final int anonVar = myVariable;

    myButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            // How would one access myVariable here?
            // Use anonVar instead of myVariable
        }
    });
}

Adam Mlodzinski ไม่ได้ทำอะไรอย่างอื่นในคำตอบของเขา แต่มีรหัสมากขึ้น

คุณสามารถใช้lambdas ธรรมดา ("แลมบ์ดานิพจน์สามารถจับภาพตัวแปร")

int myVariable = 1;
ActionListener al = ae->System.out.println(myVariable);
myButton.addActionListener( al );

หรือแม้แต่ฟังก์ชั่น

Function<Integer,ActionListener> printInt = 
    intvar -> ae -> System.out.println(intvar);

int myVariable = 1;
myButton.addActionListener( printInt.apply(myVariable) );

การใช้ฟังก์ชั่นเป็นวิธีที่ดีในการปรับโครงสร้างมัณฑนากรและอะแดปเตอร์ดูที่นี่

ฉันเพิ่งเริ่มเรียนรู้เกี่ยวกับลูกแกะดังนั้นหากคุณพบข้อผิดพลาดคุณสามารถเขียนความคิดเห็นได้

วิธีง่ายๆในการใส่ค่าลงในตัวแปรภายนอก (ไม่ได้อยู่ในคลาสที่ไม่ระบุชื่อ) เป็นวิธีการที่ folow!

ในทำนองเดียวกันถ้าคุณต้องการรับค่าของตัวแปรภายนอกคุณสามารถสร้างวิธีที่คืนสิ่งที่คุณต้องการ!

public class Example{

    private TypeParameter parameter;

    private void setMethod(TypeParameter parameter){

        this.parameter = parameter;

    }

    //...
    //into the anonymus class
    new AnonymusClass(){

        final TypeParameter parameterFinal = something;
        //you can call setMethod(TypeParameter parameter) here and pass the
        //parameterFinal
        setMethod(parameterFinal); 

        //now the variable out the class anonymus has the value of
        //of parameterFinal

    });

 }

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

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

เช่น

อินเตอร์เฟซ:

public interface TextProcessor
{
    public String Process(String text);
}

ระดับ:

private String _key;

public String toJson()
{
    TextProcessor textProcessor = new TextProcessor() {
        @Override
        public String Process(String text)
        {
            return _key + ":" + text;
        }
    };

    JSONTypeProcessor typeProcessor = new JSONTypeProcessor(textProcessor);

    foreach(String key : keys)
    {
        _key = key;

        typeProcessor.doStuffThatUsesLambda();
    }

ฉันไม่รู้ว่าพวกเขาได้แยกออกมาใน java 8 (ฉันติดอยู่ในโลก EE และยังไม่ถึง 8) แต่ใน C # มันจะมีลักษณะเช่นนี้:

    public string ToJson()
    {
        string key = null;
        var typeProcessor = new JSONTypeProcessor(text => key + ":" + text);

        foreach (var theKey in keys)
        {
            key = theKey;

            typeProcessor.doStuffThatUsesLambda();
        }
    }

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