我可以在另一类中使用一个类（构造函数和方法）中的代码吗？ （Java）的

Question

I'm making a game and I'm trying to ged rid of all the redundancy in my code. All my panels( PlayPanel , HighScore , Quit ,..) have a lot of properties in common so i made a class IPanel to extend in all my panels. it looks like this:

package menu;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class IPanel extends JPanel implements ActionListener{

    public Image achtergrond;
    public Tanks mainVenster;

    public String backgroundPath; 



    public IPanel(String backgroundPath, Tanks mainVenster)
    {    
        super();
        this.mainVenster = mainVenster;
        this.setLayout(null);

        this.backgroundPath = backgroundPath;
        achtergrond = new     //achtergrond is dutch for background
            ImageIcon(getClass().getResource(backgroundPath)).getImage();

    }

    public void paintComponent(Graphics g)
    {
            super.paintComponent(g);
            g.drawImage(achtergrond, 0, 0, this.getWidth(), this.getHeight(), 
                this);
    }


    public void actionPerformed(ActionEvent ae) 
    {
        mainVenster.switchPanel();
    }

    public void switchPanel(Tanks toActivate)
    {
        remove(mainVenster);
        mainVenster = toActivate;
        add(mainVenster);   //this is wrong, no idea what to do actually

        validate();
        repaint(); 
    }

    }

I'm able to use the constructor in other classes, but i don't know how to use the paintComponent and actionPerformed methods in other classes . I use these 2 methods in all of my Panels so i think it's unnecessary to write the methods all over again for all these panels.

an example of one of my panels is QuitPanel :

package menu;

 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.Image;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;

 import javax.swing.*;



@SuppressWarnings("serial")
 public class QuitPanel extends JPanel implements ActionListener 
{

     public Button yesKnop, noKnop;
     public JLabel label;
     public Tanks mainVenster;
     public QuitPanel quitPanel;

     public IPanel quit;


    public QuitPanel(Tanks mainVenster)
    {

         quit = new IPanel("/achtergronden/menu.jpg", mainVenster);

         int x = 95, width = 200, height = 50;

         label = new JLabel("ARE YOU SURE?");
         Font font = new Font("Courier", Font.BOLD, 25);
         label.setFont(font);
         label.setBounds(x+20, 400, width, height);

         yesKnop = new Button("/buttons/YES.png",x, 450, this);     
         noKnop = new Button("/buttons/NO.png",x, 525, this);

         this.add(quit);
         this.add(label);
         this.add(noKnop);
         this.add(yesKnop);

    }


     public void actionPerformed(ActionEvent ae) 
    {
        if(ae.getSource() == noKnop)
            quit.switchPanel(mainVenster); //this is wrong
        else if(ae.getSource() == yesKnop)
            System.exit(0); 

    }

}

as you can see i extended the class with JPanel because when i tried to extend IPanel i got an error at public HTPPanel(Tanks mainVenster) that said

when i open my quitPanel i get this:

so i know there must be a part of my code correct, the only problem is the fact that my background doesn't load --> ( public void paintComponent(Graphics g) method)

the question is: how do i use the method i created in class nr 1 in class nr 2?

also, the noButton isn't working (yesButton is working fine) --> ( public void actionPerformed(ActionEvent ae) method in ) --> also because of public void switchPanel(Tanks toActivate) i guess

thank you so much!

Answer 1

Yes you can, and there are two generalized approaches, composition and interhitence.

With composition, you push the code into a new class that your current solution then uses by creating and holding an instance of the code-holding class.

With inheritance, you create a class that your current solution extends, and put the code in a method in that parent class. Then you have the "other" class extend the one that contains the desired code.

Generally, composition is easier to handle over time than inheritance; but, with time, you will recognize when inheritance is the better solution due to it's ability to leverage polymorphisim.

Answer 2

The error is because when you're extending IPanel , you're expected to use at least one of the super 's constructors. In this case, there's one, so you'd have to use:

public IPanel(String backgroundPath, Tanks mainVenster)

CORRECTION

It isn't necessarily that you need to (it seems ideal to me), but in a constructor, one of the superclass's constructors need to be called with super(...) .

Meaning, if I had class A with its constructor:

public class A {
    public A(String name) {
    }
}

and class B extends A , I could do a few things:

public class B {
    // Option 1: Superclass's Constructor
    public B(String name) {
        super(name);
    }

    // Option 2: Pass static value
    public B() {
        super("something here");
    }

    // Option 3: Use null
    public B() {
        super(null);
    }
}

No matter what, in the end, if your superclass only contains constructors with parameters , every constructor of the subclass will need to call super(...) to one of the superclass's constructors .

If you put a default constructor eg: public A() {} in your superclass , you won't need to call super() on any of them.

Answer 3

you should add the default constructor without parameters to the IPanel class, eg

public IPanel() { }

then you can use your parent class IPanel for extending.

Answer 4

If you specify a constructor, the compiler is not going to create a constructor without parameters for you (you did this in your IPanel class).

public class A {
    public A(String str) { 
        //Compiler will not create a constructor without parameters.
    }
}

Reversed, if you don't specify a constructor, the compiler is going to create a constructor without parameters for you (you did this in your HTPPanel class).

public class A {
    //Compiler will create a constructor without parameters.
}

Now the thing is that in a class that extends some other class, the default constructor will call it's superclass constructor with no arguments.

public class A {
    public A(String str) {}
}

public class B extends A {}

public class C {
    public static void main(String[] args) {
        B b = new B(); //Compile error
    }
}

But also if you specify the constructor in class B, but do not add a call to it's superclass constructor, the compiler will automatically call the superclass constructor without arguments .

public class A {
    public A(String str) {}
}

public class B extends A {
    public B(int i) {}
}

public class C {
    public static void main(String[] args) {
        B b = new B(); //Compile error
    }
}

In other words, you should either add a constructor with no parameters in your IPanel class, (or add a call to the super constructor with appropriate arguments), but I believe that's not what you want to do here.

Now, as for your other questions, it can be due to multiple reasons and it will always be a guess without full code. Also consider, that when you're going to extend the IPanel class with some Panel class, that if you want to override the paintComponent method in this panel and still draw the background, you should call super.paintComponent(g); , try to figure out why .