Code tells me I need to implement ActionListener when I already have?

Question

So I am making this code to write to a file based on user clicks. The only problem I have, is that I get an error on "public class prog". The prog name is where I get the error: It says: The type prog must implement the inherited abstract method ActionListener.actionPerformed(ActionEvent). When I do the quickfix of adding the uninherited methods, it adds the action listener method to the end of my code but with nothing in it. If I already have action listeners in the program, why does it tell me I need to implement them? And why when I add it at the end, does it work fine even though nothing is in it?

import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.swing.*;

public class prog extends JFrame implements ActionListener {

//create newLine
final String newLine = System.getProperty("line.separator");

//create buttons
JPanel row1 = new JPanel();
JButton oneLeft = new JButton("oneLeft");
JButton oneRight = new JButton("oneRight");

JPanel row2 = new JPanel();
JButton twoLeft = new JButton("twoLeft");
JButton twoRight = new JButton("twoRight");

JPanel row3 = new JPanel();
JButton threeLeft = new JButton("threeLeft");
JButton threeRight = new JButton("threeRight");


public prog() {
    super("Prog");
    setLookAndFeel();
    setSize(400, 800);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    GridLayout layout = new GridLayout(3, 2);
    setLayout(layout);

    //create outStream for writing to file
    try {
        final File numClicks = new File("numClicks.properties");
        final FileOutputStream outStream = new FileOutputStream(numClicks);
        //add Listeners
        oneLeft.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "oneLeft has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        oneRight.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "oneRight has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        twoLeft.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "twoLeft has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        twoRight.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "twoRight has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        threeLeft.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "threeLeft has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });

        threeRight.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                try {
                    write(outStream, "threeRight has been clicked.");
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        });
    } catch (IOException ioe) {
        System.out.println("The file could not be written.");
    }




    row1.add(oneLeft);
    row1.add(oneRight);
    row2.add(twoLeft);
    row2.add(twoRight);
    row3.add(threeLeft);
    row3.add(threeRight);
    add(row1);
    add(row2);
    add(row3);



    setVisible(true);
}

private void setLookAndFeel() {
    try {
        UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
    } catch (Exception e) {
        //ignore error
    }
}

void write(FileOutputStream stream, String output) throws IOException {
    output = output + newLine;
    byte[] data = output.getBytes();
    stream.write(data, 0, data.length);
}

public static void main(String[] args) {
    prog progApp = new prog();
}
}

So I have to have the empty method even though it won't do anything? — David, Aug 14 '13 at 22:14
If your class implements the interface. Better remove the implementation declaration — Reimeus, Aug 14 '13 at 22:15
If that's the case then your class doesn't need to `implements ActionListener`. — Boris the Spider, Aug 14 '13 at 22:15
So why exactly don't I need to implement it? I just removed the implements statement and it worked, but why? If I use action listener don't I need to implement it? — David, Aug 14 '13 at 22:18

score 3 · Answer 1 · answered Aug 14 '13 at 22:18

3

Your class shouldn't implement ActionListener. Instead of writing a top-level class that implements the interface, you're writing a bunch of little inline classes (called anonymous inner classes) that do this work for you when you say new ActionListener().

answered Aug 14 '13 at 22:18

chrylis -cautiouslyoptimistic-

75,269
21
115
152

asteri · Answer 2 · 2013-08-14T22:21:15.227

You implement ActionListener it, but you don't actually implement the required methods (i.e., actionPerformed()). Therefore your class is invalid to the compiler.

You need a method like:

@Override
public void actionPerformed(ActionEvent e) {
    // ...
}

The way an interface works is that it defines what the classes that implements it have to... well... implement. That way any other process can treat it as an ActionListener and know that certain methods have been defined.

Just another way Java tries to make polymorphism your friend.

To address something from the comment below, it's actually not that uncommon to see a class implement an interface (like KeyListener) and define the method without even using it.

For example, KeyListener requires you to implement three different methods:

public void keyPressed(KeyEvent e);
public void keyReleased(KeyEvent e);
public void keyTyped(KeyEvent e);

Let's say I only really care about keyPressed. Then my class might look something like this:

public class MyKeyListener implements KeyListener {

    @Override
    public void keyPressed(KeyEvent e) {
        // do stuff
    }

    @Override
    public void keyReleased(KeyEvent e){}

    @Override
    public void keyTyped(KeyEvent e){}

}

So I have to implement the actionPerformed method without even using it? — David, Aug 14 '13 at 22:15
@David If you `implement ActionListener`, then yes. But it looks like you don't even need it in your main class. You do all your processing in anonymous subclasses that you define internally. — asteri, Aug 14 '13 at 22:16
@David There is an excellent explanation of how this works on this question: http://stackoverflow.com/questions/355167/how-are-anonymous-inner-classes-used-in-java — asteri, Aug 14 '13 at 22:17
ah thanks! That explained it to me. I didn't know I didn't even need to implement it if it's an anonymous class. I'm still learning so this stuff helps. Thanks!! — David, Aug 14 '13 at 22:21

Code tells me I need to implement ActionListener when I already have?

2 Answers2