Interface creations Problem

Question

I am new to interface design. I have a main class (class A) instantiate a new contructor from class B which extends JPanel that draw images from a newly instantiated class C. But in my class A, when load a file, I instantiates a new constructor class D. This class D perform calculation which the data collected will be passed to class C to redraw the image. I know that I need to create an interface to perform this (from class D to class C) but I don't know how. Please Help!
Example:
class A extends JFrame{
public A()
new B();
//when I load a file from JFileChooser,
new D();
public static void main(String args[])
class B extends JPanel
public B()
new C();
class C
public C()
//draw image
//draw line on image (coordinates of line from class D)
class D
public D()
//perform calculation for class C to draw.
From the above example, how do I create interface for class A so that I can perform the draw line when a file is loaded?

Answer 1

I don't quite understand what you are saying. So, you have class A, which extends JFrame. In the class A constructor, a new class B (extending JPanel) is instantiated. In the class B constructor, a new class C is instantiated, the purpose of C being to draw images. Additionally, when you choose a file, you create a new instance of D which sends calculation results to C so that C can draw the image.
Well, there are a number of ways to do stuff like this. The following code is just one particular way. I tried to keep A, B, C, and D in my example, and I tried to keep it structured just like your original code:
    public class A extends JFrame {
        protected MyB;
        public A () {
            // Create a new B instance, store it in MyB.
            MyB = new B();
        // I'm just assuming this method gets called after the
        // JFileChooser returns, and that ChosenFileInfo is any
        // information that D needs to know about the file. This
        // implementation is just for illustrative purposes.
        public void FileWasChosen (ChosenFileInfo f) {
            // Create a new D, passing file info and a C to it.
            D MyD = new D(f, MyB.getC());
    public class B extends JPanel {
        protected MyC;
        public B () {
            // Create a new C instance and keep track of it in MyC.
            MyC = new C();
        public C getC () {
            // Return the C instance created in the B constructor.
            return MyC;
    public class C {
        void draw (DrawParameters p) {
            // Draw using info in p.
    public class D {
        public D (ChosenFileInfo f, C painter) {
            // Perform calculations, pass them to the provided C.
            painter.draw(performCalculations(f)); 
        public DrawParameters performCalculations (ChosenFileInfo f) {
            // Perform calculations, return results.
    };Now, you could, say, decide to pass an instance of B to the D constructor, and let D take care of getting a C instance from B. But, regardless of the way you implement your program, the key thing to notice in my example code is the method getC() in class B.
Note that, in the above code, B stores a reference to the C instance that was created in its constructor. It stores this reference in the variable "myC". Then, the method B.getC() returns the C that was created when a new B was constructed. (As an aside, since getC() allows you to "access" the protected member MyC in B, getC() is called an "accessor" method).
Now we have a way to get the C that was created by the B and pass it along to the D. As a matter of fact, we have a way to get that C and pass it to ANY other method that needs it for something. We could, say, have a class E that also did some other calculations. We could do something like:
    MyE = new E(MyB.getC());
    ...Know what I mean?
Now, you mentioned needing to create an "interface". An interface is sort of like a contract. The terms of the contract are a set of methods that any class implementing the interface must provide. So, if you wanted to apply this to your code, you could do something like:
    public interface CProvider {
        public C getC ();
    };Now, you could rewrite the code for B like so:
    // Notice that B now "implements CProvider"
    public class B extends JPanel implements CProvider {
        protected MyC;
        public B () {
            MyC = new C();
        public C getC () {
            return MyC;
    };Since B is implementing CProvider, it is bound by the terms of the CProvider "contract" to provide a method "public C getC()". As a matter of fact, if you comment out the getC method code in B, but you still implement CProvider, you'll get a compiler error.
To take advantage of this revised B that implements CProvider, we can rewrite D like so:
    public class D {
        public D (ChosenFileInfo f, CProvider cprov) {
            // Perform calculations, and send the results to the
            // C provided by cprov (a CProvider).
            cprov.getC().draw(performCalculations(f)); 
        public DrawParameters performCalculations (ChosenFileInfo f) {
            // Perform calculations, return results.
    // A.FileWasChosen needs changed slightly, too:
        public void FileWasChosen (ChosenFileInfo f) {
            // This time, we pass a CProvider to the D constructor,
            // rather than a C itself. Although this can be done
            // other ways, I'm doing it this way to illustrate the
            // usefulness of interfaces.
            D MyD = new D(f, MyB);
        };Specifying "CProvider" as the type of the second parameter to the D constructor means that we can pass ANY class that implements CProvider to the D constructor.
We could, now, write another CProvider class that is completely unrelated to B except for the fact that it has a method getC():
public class Bonkers implements CProvider {
    protected C c;
    public Bonkers () {
        c = new C();
    public C getC () {
        return c;
};We can now pass an instance of Bonkers to the constructor of D, just like we passed an instance of B before. From D's point of view it does not matter what class you pass to it... as long as the class implements the CProvider interface, D will be happy.
On another note, you shouldn't name your classes A, B, C, and D. You should name them names that indicate what the classes actually do. That was a confusing response to type.
I hope this helps.
Jason Cipriani
[email protected]
[email protected]