Thread: abstract class:

After all this time OOP just clicked, I am laughing at myself like a mad scientist. I just needed a project to really required it I suppose. Reading about design patterns was a really cool moment for me. However I have questions:

I have a abstract class like this below:

public abstract class Weapon {
 
	protected String name;
	protected int zeroRoundCount;
	protected int qualRoundCount;
	protected int practiceRoundCount;
 
 
	 	JFrame frame;
		JButton enterBtn;
		JButton closeBtn;
 
		JLabel zeroLbl;
		JLabel practiceLbl;
		JLabel qualLbl;
		JLabel calulateLbl;
 
		JTextField zeroTextBox; 
		JTextField practiceTextBox;
		JTextField qualTextBox;
		JTextField calculateTxtBox;
 
	 Weapon(String name)
	 {
		 zeroRoundCount=18;
		 qualRoundCount=40;
		 practiceRoundCount=60; 
		 String weaponName = null;
 
		 	frame = new JFrame(weaponName);
			frame.getContentPane().setLayout(new GridLayout(0,1));
			frame.setSize(240,220);
			frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
			//button will calculate total rounds needed
			enterBtn =  new JButton("Enter");
			closeBtn = new JButton("Close");
 
 
			//text box's will be default values from abstract Weapon
			zeroTextBox= new JTextField(5); 
			practiceTextBox= new JTextField(5);
			qualTextBox= new JTextField(5);
			calculateTxtBox= new JTextField(10);
 
			//creating labels
			zeroLbl= new JLabel("Zero");
			practiceLbl= new JLabel("Practice");;
			qualLbl= new JLabel("Qual");
			calulateLbl = new JLabel("Total Ammo Needed");
 
			frame.add(zeroLbl);
			frame.add(zeroTextBox);
 
			frame.add(qualLbl);
			frame.add(qualTextBox);
 
			frame.add(practiceLbl);
			frame.add(practiceTextBox);
 
			frame.add(calulateLbl);
			frame.add(calculateTxtBox);
 
			frame.add(enterBtn);
			frame.add(closeBtn);
			frame.setVisible(true);
	 }
 
 
}

I make another class:

package army.strac;
 
public class M4 extends Weapon{
 
	M4() 
	{
		super("M4");
 
	}
 
}

Then a main class and it runs. Now how can I put the actionListners methods:

//example
zeroTextBox.addActionListener(new ActionListener)
	 {
		 public void actionPerformed(ActionEvent ae)
		 {
			 zeroTextBox.setText(zeroRoundCount);
		 }
	 }

I want to put them in the abstract class set them all up and simply change the field numbers values in the subclass. Therefore for every weapon type I just change the number required by accesses the field numbers in the constructor and BAM I am done.

If you want to use different values for every subclass of a class you can simply define an abstract method in the super class and have it implemented in each subclass.
For example:

public abstract class Person {
 
	public abstract int getIncome();
 
}

public class Professor extends Person {
 
	public int getIncome() {
		return 2500;
	}
 
}

public class Student extends Person {
 
	public int getIncome() {
		return 0;
	}
 
}

As you can see, every class (Student / Professor) that subclasses Person can define its own implementation for the getIncome() method.
A professor has an income of 2500 while a student has an income of 0.

You never create nor add any listeners in the code you have posted so its hard to really tell what you are trying to do.
Since your variables are package-private you should have access to them as long as you declare your subclass in the same package, so I dont see a problem with that. Other then bad design of course.

The preferred solution would be to create and add the listeners in your super class but have them call abstract methods which would need to be implemented by the subclasses.

For example:

public abstract class AbstractWindow extends JFrame {
	private static final long	serialVersionUID	= 1L;
 
	public AbstractWindow() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setBounds(100, 100, 450, 300);
 
		JPanel contentPane = new JPanel();
		setContentPane(contentPane);
 
		JButton btn = new JButton("Some Button");
		contentPane.add(btn);
 
		btn.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				btnAction();
			}
		});
	}
 
	protected abstract void btnAction();
 
}

public class ActualWindow extends AbstractWindow {
	private static final long	serialVersionUID	= 1L;
 
	protected void btnAction() {
		System.out.println("Button had been pressed!");
	}
 
}

YES!!! That is what I was trying to do.

Bad design? Is it a good design to put each class into their own package? This is for modularity reasons correct?

No, its not a good design to put each class into a separate package, that would be rather pointless.
But its a bad design to have so many package-private variables, especially if they are not really needed. Furthermore, having a class that creates GUI elements in its constructor, especially a JFrame, is just calling for bad things to happen later down the road.
But you have to make those experiences yourself.

would you care to enlighten me? I only mentioned the classes being in every class because of this framework I was learning "OSGI", it requires it for modularity purposes.

Where would you suggest I create my GUI. This is not the real program, this is me testing out a model after reading about design patterns.

I am trying to make a program that calculates how many rounds a certain weapon needs per training event. There will be about 50 different weapons and but what they must accomplish is pretty much the same.

My plan right now is to make a JFrame of JCheckBoxes with labels picking the weapons systems need to calculations for. After that those select weapons appear, enter the number of people, hit enter and it is all transferred to a beautiful excel sheet that is able to be e-mailed.

This is my first real tackle at something real. I am very excited and will love any advice. I am still in the planning and designing process.

Right now you would create a new JFrame for each of them, if you have 50 you would have 50 windows popping up.

Usually people use the MVC design for applications with a GUI. You could read up on that, perhaps on wikipedia.
The basic idea is that you split your program up into 3 parts. The model part where data is stored and altered, the view part that is the GUI and everything that is specific to the application itself, and the control part which manages interaction between the model and the view.

It goes well with the observer pattern to have the view update when the model changes.