Abstract class implements Cloneable... How?

I have an abstract class that is inherited by many many subclasses. I wish to make this abstract class a cloneable.
Most of the subclasses are using the protected fields inherited from the abstract one, they almost never add any extra field. So it would make a lot of sense to implement the clone() method at the abstract level. And not doing so would cost me a lot of time.
But that causes me trouble, because you can't write something like this :
public abstract class MyAbstractClass implements Cloneable {
    protected Source source; // the two fields the subclasses are satisfied with, most the time
    protected Vectro<Target> targets;
    public Effect clone() {
        return new Effect(source , targets); // when a subclass has extra fields, I plan to overwrite clone()
}Because you can't instantiate an abstract class, of course. Anyway, I'd rather instatiate a class of the appropriate concrete class.
I feel there is a way to hack this. I feel there is a way to avoid having to write the same clone() method in every subclass.
Anyone?
Thanks.

jverd wrote:
bestam wrote:
Most of the subclasses are using the protected fields inherited from the abstract one, Bad idea. Make the fields private and provide protected get/set methods.Is this a general recommendation or only in the context described by the OP?
Because API classes don't do this in many cases. Just looked at a random one: AbstractButton.

Similar Messages

Abstract class implementation Dos Prompt

Hello everyone,
Good day! Anyone knows how to implement or use abstract class to another class. Pls.... help me. I'm still a novice programmer. Program like Bank Account with a abstract class named 'Account' and an another class 'Savings' extends the abstract class and also the third class named 'TimeDeposit' something like it.

Hello everyone,
Good day! Anyone knows how to implement or
use abstract class to another class. Pls.... help
me. I'm still a novice programmer. Program like Bank
Account with a abstract class named 'Account' and an
another class 'Savings' extends the abstract class
and also the third class named 'TimeDeposit'
something like it.One thing to remember is that your class has to include code for all methods that are marked abstract in the abstract class you are extending; and if you don't want anyone else extending your class, you should make it final. You should also check the abstract class's constructors to see if you need to call a particular one when you are constructing your class. If you do, you'll need to call super(...) in your class's constructor, and it should be the first statement.

Extend abstract class & implement interface, different return type methods

abstract class X
public abstract String method();
interface Y
public void method();
class Z extends X implements Y
// Compiler error, If I don't implement both methods
// If I implement only one method, compiler error is thrown for not
// implementing another method
// If I implement both the methods,duplicate method error is thrown by
//compiler
The same problem can occur if both methods throw different checked exceptions,or if access modifiers are different..etc
I'm preparing for SCJP, So just had this weired thought. Please let me know
if there is a way to solve this.

Nothing you can do about it except for changing the design.
Kaj

Class implements Cloneable?

Is it possible for a class to implement Cloneable in JavaME - as I can't seem to get it to work.
Thanks

No, the Cloneable interface isn't part of Java ME. You could have found that out yourself by checking the Javadocs for JSR-118 and JSR-139.
db

Why use an Abstract Class ?

I am new to Java and for some reason I can't get my head around why to use an abstract class. I understand that an abstract class is something like:
public abstract class Food{ // abstract class
public void eat(){
// stub
public class Apple extends Food{
public void eat(){
// Eat an apple code
}So basically the idea above is that you can eat an "apple" but you can't eat "food" because you can't instantiate an abstract class.
I understand what an abstract class is and how to write one. What I don't understand is why you would use it? It looks to me like I could have just created a normal class called "Food" and just not instantiated it. What are the benefits of using an abstract class?

807479 wrote:
I am new to Java and for some reason I can't get my head around why to use an abstract class.One of the first books I ever read about Object-Oriented design contained the following quote from [url http://en.wikipedia.org/wiki/Lucius_Cary,_2nd_Viscount_Falkland]Lord Falkland:
"When it is not necessary to make a decision, it is necessary +not+ to make a decision."
It took me quite a while to understand, but it's all about flexibility: As soon as you cast something in stone, you lose the ability to change it later on if something better/more appropriate comes along. Interfaces and abstract classes are all about delaying that decision.
As jverd said, interfaces allow you to specify what is required without defining the how; and as ErasP said, abstract classes are usually incomplete: ie, they define some of the 'how', but not all of it.
What is most important about abstract classes though is that they cannot exist on their own: They must be extended by a concrete class that completes the 'how' before they can be instantiated and, as such, they declare the intent of the designer.
One of the most important uses of abstract classes is as "skeleton implementations" of interfaces, and there are a lot of examples of these in the Java Collections hierarchy. My favourite is probably AbstractList, which contains a skeleton implementation of a List. Because it exists, I can create a class that wraps an array as a List with very little code, viz:public final class ArrayAsList<T>()
   extends AbstractList<T>
   private final T[] values;
   public ArrayAsList(T... values) {
      this.values = values;
   @Override
   public T get(int index) {
      return values[index];
   @Override
   public T set(int index, T element) {
      T value = get(index);
      values[index] = element;
      return value;
   @Override
   public int size() {
      return values.length;
};and somewhere else, I can use it:   List<String> letters =
      new ArrayAsList<String>("a", "b", "c");or perhaps, more practically:   List<String> words = new ArrayAsList<String>(
      bigTextString.split(" +") );Now that may not seem like a big deal to you, but given all that Lists can do, it's actually a very powerful bit of code. The above example is from "Effective Java" (p.95).
HIH
Winston

Abstract class methods

I'm confused. Is this true or false.
The great thing about polymorphism is that you can call one method. If the subclass inherited that method, it will be customized and perform a different duty. That way, the action it performs will depend on 1>whether or not it's a sub or super class and also 2>if the method was overridden if it was a subclass.
Now, my confusion. If an object reference is to a Super-abstract-class... how do the method calls and properties go?? well let me let you answer for me. Thanks so much in advance for this clarification.

Yes. You are - pretty much.
The abstract class, as such, can never be instantiated. BUT a class derived from the superclass IS an instance of the superclass.
Silly example:
abstract public class Animal {
   public Animal() {
   public abstract int getNumberOfLegs();
}That's our animal class, and we know that anything that's an animal has a number of legs - but we can't just create a "generic" animal.
public class Cat extends Animal {
   public Cat() {
      super();
   public int getNumberOfLegs() {
      return legCount;
   public void maim(int legsToRemove) {
      legCount -= legsToRemove;
      if(legCount < 0 ) legCount = 0;
   private int legCount = 4;
}A Cat is a specific type of animal, so we can find out how many legs it has (usually 4). Note again that a cat IS an animal, so Cat IS an instance of Animal.
Java even provides a special operator to test this:
Cat cat = new Cat();
System.out.println("A cat is a cat: " + (cat instanceof Cat));
System.out.println("A cat is an animal: " + (cat instanceof Animal));The term used to describe the "Guarantee" that a subclass of an abstract class (or an implementation of an interface) is usually and technically a "contract", but I prefer to think of it as a "Promise" since you can break the promise by messing with the bytecode - at which point the JVM will spot the lie and complain !
D.

SerialVersionUID in abstract classes

Hi,
i have a Question about the serialVersionUID for abstract classes.
first i will describe a simple example to show my problem.
abstract class A implements Serializable {
    private int value;
    public A(int value) {
        this.value = value;
    protected abstract void doSomething();
class B extends A {
    private static final serialVersionUID = 8373629029L;
    public B(int value) {
           super(value);
    protected void doSomething() {
     //do something
} B is a ValueObjects on a Server and transmitted to a Client Application.
When i change the abstract super class A i get an exception on the client because the serialVersionUID does not mathc to the Client anymore
So i changed the " implements Serializable" Statement down to B. And tried the same. Then i get an InvalidClassException because with following hint "no valid constructor". So i also have to make A Serializable and also need a defined serialVersionUID for A.
I think there is something i don't unterstand in the serialization Mechanism in Java.
Why does it makes sense to adda serialVersionUID to an abstract class? And how do i generate the UID with the "serialver" tool deliversd with the JDK form a class which i cannot instanciate?
Edited by: kbj on Jan 23, 2009 7:14 AM

kbj wrote:
So i would like to know what is the best practise in such a case?Classes designed for inheritance should rarely implement Serializable, and interfaces should rarely extend it. If a class or interface exists primarily to participate in a framework that requires all participants to implement Serializable then it makes sense to violate this rule.
So in your case you may want to provide a protected parameterless constructor and a protected initialization method if a client provided invariant is required ("value" in your case). Then all public or protected instance methods need to call a private method that checks that the class has been initialized (i.e. the subclass has been written so that it calls the protected initialization method and passes in the "value" invariant). If not then you should throw an IllegalStateException. The field you use to flag that the object has been initialized should be of type java.util.concurrent.atomic.AtomicReference.
The above is taken pretty much verbatim from chapter 11 of effective java second edition. The book also provides an example of the above you could use as a template.

Abstract Class and Constructors

Why is it that Constructors are permitted within an abstract class?

But how is it possible to create/instantiate Abstract
classes?It's not. The only class that gets instantiated is the concrete child class.
As somebody already said, invoking a constructor does NOT create the object.
When you do new Foo(), the constructor does NOT instantiate the Foo. The new operator does. It allocates the memory, sets default values for member variables, and then it invokes the constructor. If that ctor invokes a chain of other ctors in itself and its parent, and so on up the chain, you're NOT creating more and more objects. You're just running additional constructors on the one object that has already been created.
What is the use of a constructor in an abstract class?Just like in any other class: to initialize fields.

How to implement the abstract classes MessageDigest and Signature?

Hi all,
I've recently started working on JCDK 2.2.1.
I have a problem to share and get suggestions from you!
My aim is to implement ECDSA on Java card
I have seen the Javacard API and tried to program using the classes
MessageDigest and Signature. They are abstract classes and except the
Method getInstance in them, the rest of all methods are declared abstract.
Does that mean we have to give definition for them or else can we use
them as they are?
I tried giving some definitions, but to my surprise there's no such
initiation of any variable to the algorithm we provide in the method
"getInstance"! Then, it's not possible to give defn,. for other
methods like getAlgorithm, reset, etc. How can we resolve this ?
Any ideas?
Regards,
Johnbuchk

try this...
http://developer.sonyericsson.com/site/global/techsupport/tipstrickscode/java/p_java_0501.jsp
hope it can help u

EJB question: How to use abstract class in writing a session bean?

I had written an abstract class which implements the session bean as follow:
public abstract class LoggingSessionBean implements SessionBean {
protected SessionContext ctx;
protected abstract Object editRecord(Object obj) throws Exception;
public LoggingSessionBean()
super();
private final String getBeforeUpdateImage(Object obj) throws Exception {
// implement the details of extracting the backup image ...
public void setSessionContext(SessionContext ctx)
this.ctx = ctx;
private final void writeThisImageToDatabase(String aStr) {
// connect to database to write the record ...
public final Object update(final Object obj) {
try {
final String aStr = getBeforeUpdateImage(obj);
writeThisImageToDatabase(aStr);
editRecord(obj);
} catch (Exception e) {
ctx.setRollbackOnly();
This abstract class is to write the backup image to the database so that other session beans extending it only need to implement the details in editRecord(Object Obj) and they do not need to take care of the operation of making the backup image.
However, some several questions for me are:
1. If I write a class ScheduleSessionBean extending the above abstract class and the according 2 interfaces ScheduleSession and ScheduleSessionHome for this session bean (void update(Object obj); defined in ScheduleSession), do I still need to write the interfaces for LoggingSession and LoggingSessionHome?
2. If I wrote the interface LoggingSession extending EJBObject where it defined the abstract methods "void update(Object obj);" and "void setSessionContext(SessionContext ctx);", that this meant I needed to write the ScheduleSession to implement the Logging Session?
3. I used OC4J 9.0.4. How can I define the ejb-jar.xml in this case?

Hi Maggie,
1. do I still need to write
the interfaces for LoggingSession and
LoggingSessionHome?"LoggingSessionBean" can't be a session bean, because it's an abstract class. Therefore there's no point in thinking about the 'home' and 'remote' interfaces.
2. this
meant I needed to write the ScheduleSession to
implement the Logging Session?Again, not really a question worth considering, since "LoggingSessionBean" can't be an EJB.
3. I used OC4J 9.0.4. How can I define the
ejb-jar.xml in this case?Same as you define it for any version of OC4J and for any EJB container, for that matter, since the "ejb-jar.xml" file is defined by the EJB specification.
Let me suggest that you create a "Logging" class as a regular java class, and give your "ScheduleSessionBean" a member that is an instance of the "Logging" class.
Alternatively, the "ScheduleSessionBean" can extend the "Logging" class and implement the "SessionBean" interface.
Good Luck,
Avi.

Problems implementing abstract classes

hello.
this is james mcfadden. I am developing a multiplayer BlackJack card game in Java. the game consists of three programs: BlackJack.java, BlackJackServer.java and BlackJackClient.java (three 3 programs are shown below). i don't know how to implement abstract classes. i am trying to get the BlackJack.java program working with the BlackJackServer.java program. there should be "extends BlackJackServer" somewhere in the BlackJack.java program, but i don't know where.
import javax.swing.*;
public class BlackJack extends JPanel{
   public BlackJack(){
      //FlowLayout is default layout manager for a JPanel
      add(new JButton("Hit"));
      add(new JButton("Stay"));
      add(new JButton("New Game"));
   public static void main(String[] args){
      JFrame frame=new JFrame("BlackJack");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setSize(500,500);
      frame.setLocation(200,200);
      BlackJack bj=new BlackJack();
      frame.setContentPane(bj);
      frame.setVisible(true);
import java.io.*;//Provides for system input and output through data streams, serialization and the file system
import java.net.*;//Provides the classes for implementing networking applications
import java.util.*;//Contains the collections framework, legacy collection classes, event model, date and time facilities, internationalization, and miscellaneous utility classes
import java.awt.*;//Contains all of the classes for creating user interfaces and for painting graphics and images
import javax.swing.*;//Provides a set of lightweight components that, to the maximum degree possible, work the same on all platforms
public class BlackJackServer extends JFrame{
   private JTextArea jta=new JTextArea();//a text area for displaying text
   public static void main(String[] args){
          new BlackJackServer();//invokes the constructor BlackJackServer()
   }//end main
   public BlackJackServer(){
      setLayout(new BorderLayout());//places the text area on the frame
      add(new JScrollPane(jta),BorderLayout.CENTER);//lays out a text area, arranging and resizing its components to fit in the centre region;and provides a scrollable view of a lightweight component
      setTitle("BlackJack Server");//Sets the title for this frame to the specified string
      setSize(500,300);//Resizes this component so that it has a width and a height
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//Sets the operation that will happen by default when the user closes this frame
      setVisible(true);//shows the frame
      try{
         ServerSocket serverSocket=new ServerSocket(8000);//creates a server socket
         jta.append("Server started at "+new Date()+'\n');//displays the current date in the text area
         Socket socket=serverSocket.accept();//listens for a connection request
         DataInputStream inputFromClient=new DataInputStream(socket.getInputStream());//creates a data input stream
         DataOutputStream outputToClient=new DataOutputStream(socket.getOutputStream());//creates a data output stream
         while(true){
            float bet=inputFromClient.readFloat();//receives bet from the client
            float doublebet=bet+bet;//computes double the bet
            outputToClient.writeFloat(doublebet);//sends double the bet back to the client
            jta.append("Bet received from client: "+bet+'\n');//displays the bet in the text area
            jta.append("Double the bet found: "+doublebet+'\n');//displays double the bet in the text area
         }//end while
      }//end try
      catch(IOException ex){
         System.err.println(ex);//displays an error message
      }//end catch
   }//end constructor
}//end class BlackJackServer
import java.io.*;//Provides for system input and output through data streams, serialization and the file system
import java.net.*;//Provides the classes for implementing networking applications
import java.awt.*;//Contains all of the classes for creating user interfaces and for painting graphics and images
import java.awt.event.*;//Provides interfaces and classes for dealing with different types of events fired by AWT components
import javax.swing.*;//Provides a set of lightweight components that, to the maximum degree possible, work the same on all platforms
public class BlackJackClient extends JFrame{
   private JTextField jtf=new JTextField();//a text field for receiving text
   private JTextArea jta=new JTextArea();//a text area for displaying text
   private DataOutputStream toServer;//output stream
   private DataInputStream fromServer;//input stream
   public static void main(String[] args){
      new BlackJackClient();//invokes the constructor BlackJackClient()
   public BlackJackClient(){
      JPanel p=new JPanel();//holds the label and text field
      p.setLayout(new BorderLayout());//sets the layout of the content pane of this component by default
      p.add(new JLabel("Enter bet"),BorderLayout.WEST);//displays the bet and lays out a JLabel, arranging and resizing its components to fit in the western region
      p.add(jtf,BorderLayout.CENTER);//lays out the text field, arranging and resizing its components to fit in the centre region
      jtf.setHorizontalAlignment(JTextField.RIGHT);//Sets the horizontal alignment of the text to the right
      setLayout(new BorderLayout());//places the text area on the frame
      add(p,BorderLayout.NORTH);//lays out the text field, arranging and resizing its components to fit in the northern region
      add(new JScrollPane(jta),BorderLayout.CENTER);//lays out a text area, arranging and resizing its components to fit in the centre region;and provides a scrollable view of a lightweight component
      jtf.addActionListener(new ButtonListener());//invokes the ButtonListener class
      setTitle("BlackJack Client");//Sets the title for this frame to the specified string
      setSize(500,300);//Resizes this component so that it has a width and a height
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//Sets the operation that will happen by default when the user closes this frame
      setVisible(true);//shows the frame
      try{
         Socket socket=new Socket("localhost",8000);//creates a socket to connect to the server
         fromServer=new DataInputStream(socket.getInputStream());//creates an input stream to receive data from the server
         toServer=new DataOutputStream(socket.getOutputStream());//creates an output stream to send data to the server
      }//end try
      catch(IOException ex){
         jta.append(ex.toString()+'\n');//displays an error message
      }//end catch
   private class ButtonListener implements ActionListener{
      public void actionPerformed(ActionEvent e){
         try{
            float bet=Float.parseFloat(jtf.getText().trim());//gets the bet from the text field
            toServer.writeFloat(bet);//Converts the float argument to an int using the floatToIntBits method in class Float, and then writes that int value to the underlying output stream
            toServer.flush();//Flushes this output stream and forces any buffered output bytes to be written out
            float doublebet=fromServer.readFloat();//gets double the bet from the server
            jta.append("Bet is "+bet+"\n");//displays the bet in the text area
            jta.append("Double the bet received from the server is "+doublebet+'\n');//displays double the bet in the text area
         }//end try
         catch(IOException ex){
            System.err.println(ex);//displays an error message
         }//end catch
      }//end method
   }//end class
}//end class BlackJackClient

there should be "extends BlackJackServer" somewhere in the BlackJack.java programI very much doubt that.
It's possible you might need to create a BlackJackServer object or something like that. But I don't see the point in subclassing it.

Why does this abstract class and method work without implement it?

hi,
I have seen many times that in some examples that there are objects made from abstract classes directly. However, in all books, manual and tutorials that I've read explain that we MUST implement those methods in a subclass.
An example of what I'm saying is the example code here . In a few words that example makes Channels (java.nio.channel) and does operations with them. My problem is in the class to make this channels, because they used the ServerSockeChannel class and socket() method directly despite they are abstracts.
   // Create a new channel: if port == 0, FileChannel on /dev/tty, else
   // a SocketChannel from the first accept on the given port number
private static ByteChannel newChannel (int netPort)
      throws Exception
      if (netPort == 0) {
         FileInputStream fis = new FileInputStream ("/dev/tty");
         return (fis.getChannel());
      } else {
//CONFLICT LINES
         ServerSocketChannel ssc = ServerSocketChannel.open(); //<--I have never thought do that!! Anyway, how it is static method may work.
         ssc.socket().bind (new InetSocketAddress (netPort)); //<--but here, this method (socket) is abstract. WHY RETURN A SOCKET???????? this mehod should be empty by default.
         System.out.print ("Waiting for connection on port "
            + netPort + "...");
         System.out.flush();
         ByteChannel channel = ssc.accept();
         ssc.close();
         System.out.println ("Got it");
         return (channel);
   } I test this code and works fine. So why can it be??
Also, I read that the abstract classes can't have static methods. Is it true???
Please Help!!
PS: i have seen this kind of code many times. So i feel that I don't understand how its really the abstract methods are made.
PS2: I understand that obviously you don't do something like this: *"obj = new AbstractClass(); "*. I dont understand how it could be: ServerSocketChannel ssc = ServerSocketChannel.open(); and the compiler didn't warn.

molavec wrote:
ServerSocketChannel ssc = ServerSocketChannel.open(); //<--I have never thought do that!! Anyway, how it is static method may work.
The static method creates an instance of a class which extends ServerSocketChannel, but is actually another non-abstract class.I thought that, but reading the documentation I saw that about open() method:
Opens a server-socket channel.
The new channel is created by invoking the openServerSocketChannel method of the system-wide default SelectorProvider object.
The new channel's socket is initially unbound; it must be bound to a specific address via one of its socket's bind methods before connections can be accepted.
...and the problem is the same openServerSocketChannel is abstract, so i don't understand how it could return a ServerSocketChannel.There is a concrete implementation class that has implemented that method.
I guess that really the open() method use a SelectorProvider's subclase but it doesn't appear in the doc.It doesn't need to. First, you don't care about those implementation details, and second, you know that if the class is abstract, it must use some concrete subclass.
Ok, I speak Spanish by default (<-- this sounds like "I am a machine", ^_^' ). So, I didn't know how to say that the method would be {}. Is there a way to say that?? I recommendable for me to know, for the future questions o answers.Not sure what you're saying here. But the other respondent was trying to explain to you the difference between an abstract method and an empty method.
// abstract method
public abstract void foo();
// empty method
public void bar() {
Which class does extend ServerSocketChannel? I can not see it.It may be a package-private class or a private nested class. There's no need to document that specific implementation, since you never need to use it directly.

Abstract Class that implements Comparable

I am trying to understand how a comparable interface works with an abstract class. Any help is greatly appreciated.
I have a class ClassA defined as follows:
public abstract class ClassA implements Comparable I have a method, compareTo(..), within ClassA as follows:
public int compareTo(Object o) I have a sub-class ClassB defined as follows:
public class ClassB extends ClassAI am receiving a compile error:
Class must implement the inherited abstract method packagename.ClassA.compareTo(Object)
Should or can the compareTo be abstract in ClassA and executed in ClassB? Just not sure how this works.

???? if you are inheriting from an abstract class your subclass must implement methods that were declared in the parent (abstract) class but not implemented
When in doubt, refer to the Java Language Specification..

How to reference the WindowListener in "class implements WindowListener"

i need to remove a WindowListener but i dont know how to
reference Listeners implented by classes.
Thanks for any help in advance!
public class MyClass implements WindowListener{
public MyClass(){
frame.addWindowListener(this);
public static void RemoveIt(){
frame.removeWindowListener( ??? )
JFrame frame = new JFrame();
}

Looks like im just going to have to implement this
all much differently -
and maybe in a less lazy manner, haha.Hi! Sorry for my late reply.
Let me help you a little;
===============================================================
1.) You can create a class that will be shared by each of your frame.
===============================================================
The shared class will contain the following:
1.) The number of your alive frame.
2.) The information of your alive frame. ie. name, if it is the main, etc.
Then your frame should look at that shared class so that it will know when to
invoke System.exit(int);
===============================================================
2.) You can use java.util.prefs.Preferences
===============================================================
Use preference to put and get information about your frame.
===============================================================
3.) You can extends my class below.
===============================================================
NOTE: This example may or may not help the OP. I'm sorry.
* @(#)AbstractExitableJFrame.java     05/06/25
* 2005 Tunay na pag-aari ni Ronillo Ang.
package com.yahoo.ronilloang.cswingx;
import java.awt.GraphicsConfiguration;
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import java.awt.event.WindowListener;
import java.awt.event.WindowStateListener;
import javax.swing.JFrame;
* Use this at your own risks.
* @version     1.4.2
* @author     Ronillo Ang
public abstract class AbstractExitableJFrame extends JFrame implements WindowFocusListener, WindowListener, WindowStateListener{
     private static int frameCount = 0; // how many are we?
      * @see          javax.swing.JFrame constructor.
     public AbstractExitableJFrame(){
          super();
          ++frameCount;
      * @see          javax.swing.JFrame constructor.
     public AbstractExitableJFrame(GraphicsConfiguration gc){
          super(gc);
          ++frameCount;
      * @see          javax.swing.JFrame constructor.
     public AbstractExitableJFrame(String title){
          super(title);
          ++frameCount;
      * @see          javax.swing.JFrame constructor.
     public AbstractExitableJFrame(String title, GraphicsConfiguration gc){
          super(title, gc);
          ++frameCount;
      * Called by the constructors to init the <code>AbstractExitableJFrame</code> properly.
     protected final void frameInit(){
          super.frameInit();
          addWindowFocusListener(this);
          addWindowListener(this);
          addWindowStateListener(this);
     public final void windowGainedFocus(WindowEvent we){
          exitableJFrameGainedFocus(we);
     public final void windowLostFocus(WindowEvent we){
          exitableJFrameLostFocus(we);
     public final void windowActivated(WindowEvent we){
          exitableJFrameActivated(we);
     public final void windowClosed(WindowEvent we){
          exitableJFrameClosed(we);
          --frameCount;
          if(frameCount <= 0 || isMain())
               System.exit(0);
     public final void windowClosing(WindowEvent we){
          exitableJFrameClosing(we);
     public final void windowDeactivated(WindowEvent we){
          exitableJFrameDeactivated(we);
     public final void windowDeiconified(WindowEvent we){
          exitableJFrameDeiconified(we);
     public final void windowIconified(WindowEvent we){
          exitableJFrameIconified(we);
     public final void windowOpened(WindowEvent we){
          exitableJFrameOpened(we);
     public final void windowStateChanged(WindowEvent we){
          exitableJFrameStateChanged(we);
      * Invoked when {@link #windowGainedFocus(WindowEvent)} is invoked.
     public abstract void exitableJFrameGainedFocus(WindowEvent we);
      * Invoked when {@link #windowLostFocus(WindowEvent)} is invoked.
     public abstract void exitableJFrameLostFocus(WindowEvent we);
      * Invoked when {@link #windowActivated(WindowEvent)} is invoked.
     public abstract void exitableJFrameActivated(WindowEvent we);
      * Invoked when {@link #windowClosed(WindowEvent)} is invoked.
     public abstract void exitableJFrameClosed(WindowEvent we);
      * Invoked when {@link #windowClosing(WindowEvent)} is invoked.
     public abstract void exitableJFrameClosing(WindowEvent we);
      * Invoked when {@link #windowDeactivated(WindowEvent)} is invoked.
     public abstract void exitableJFrameDeactivated(WindowEvent we);
      * Invoked when {@link #windowDeiconified(WindowEvent)} is invoked.
     public abstract void exitableJFrameDeiconified(WindowEvent we);
      * Invoked when {@link #windowIconified(WindowEvent)} is invoked.
     public abstract void exitableJFrameIconified(WindowEvent we);
      * Invoked when {@link #windowOpened(WindowEvent)} is invoked.
     public abstract void exitableJFrameOpened(WindowEvent we);
      * Invoked when {@link #windowStateChanged(WindowEvent)} is invoked.
     public abstract void exitableJFrameStateChanged(WindowEvent we);
      * Tests if this frame is the main frame.
     public abstract boolean isMain();
Take care and God bless you all. Thank you. -Ronillo

Instance of one of implementations of abstract class depending on context??

Hi all,
I just wonder if it is possible in Java to call creation of a new instance of an implementation of an abstract class depending on context.
I mean something like:
abstract class Abstract
//1st implementation of Abstract class
class Concrete1 extends Abstract
//2nd implementation of Abstract class
class Concrete2 extends Abstract
}And now, somewhere else in the code, I would really need to call something like this:
Abstract test1 = new ...(); //here I need sometimes to be created instance of Concrete1, sometimes instance of Concrete2
Is there a way how to do this??

Some more concrete code if it helps:
Abstract class:
* Individual.java
* Created on 21. leden 2007, 1:08
package genetics;
* Abstract class defining fields and methods of one individual for genetic algorithms
* This class is supposed to be implemented according to problem to be solved
* @author Richard V�tek
* @version 1.0
abstract public class Individual implements Comparable<Individual>
   * Create random chromosomes for this individual
protected abstract void createRandomChromosomes();
   * Count fitness of this individual
   * This number says how good is this individual (the higher number the better).
   * Better fitness means that this individual is closer to solution.
   * @return int   Fitness of this individual
protected abstract int getFitness();
   * Cross-breed this individual with another individual
   * This leaves untouched number of chromosomes to certain (randomly generated) position.
   * From this position on, it will swap chromosomes between this and another individual.
   * So this individual gets changed (cross-breeded) as well as the other, which is returned
   * as result of this method.
   * @param   other              The other individual to cross-breed with
   * @return Individual         Hybrid of this and another individual (in fact, the other individual
   *                             after cross-breed (this (source) individual gets changed too after cross-breed)
protected abstract Individual crossbreed(Individual other);
   * Mutate this individual
   * Mutate chromosomes of this individual; every chromosome is mutated
   * with probability set in settings of evolution.
   * This probability is supposed to be quite low number, roughly 1 %.
protected abstract void mutate();
   * Check this individual
   * Check if this individual still suits the assignment.
   * If not, repair this individual to suit it again.
protected abstract void check();
   * Implementation of Comparable: comparing of individuals by fitness
   * @param other Another individual to compare
public int compareTo(Individual other)
    return this.getFitness() - other.getFitness();
One implementation class:
* KnapsackIndividual.java
* Created on 21. leden 2007, 1:41
package genetics;
import java.util.Random;
import java.util.TreeMap;
import knapsack.KnapsackProblem;
* This is practically the same as KnapsackProblem class but designed specially
* for solving knapsack problem with genetic algorithm so all unnecessary fields
* and methods are removed.
* @author Richard V�tek
* @version 1.0
public class KnapsackIndividual extends Individual
   * Chromosomes of this individual
   * In case of knapsack problem, they are things currentl in knasack
protected boolean[] arrChromosomes;
   * Cached value of fitness of this individual
   * Used to not to count fitness of this individual everytime when needed
   * (and it is often needed); once counted, it will be read from this cached value
private int intFitnessCache = Integer.MIN_VALUE;
   * Randomizer for random-driven methods (like mutation, etc.)
private Random randomizer = new Random();
   * Reference to evolution to read mutation probability from
protected Evolution evolution;
   * Assignment of problem instance
protected KnapsackProblem assignment;
   * Create a new Individual instance
   * @param   assignment Object representing assignment of particular problem
   * @param   evolution   Reference to evolution object to be able to read evolution's settings from
public KnapsackIndividual(KnapsackProblem assignment, Evolution evolution)
    this.assignment = assignment;
    this.evolution = evolution;
    this.arrChromosomes = new boolean[assignment.getNumberOfThings()];
   * Create random chromosomes for this individual
   * @see Individual#createRandomChromosomes()
protected void createRandomChromosomes()
    int intChromosomeCount = this.arrChromosomes.length;
    for (int i = 0; i < intChromosomeCount; i++)
      this.arrChromosomes[i] = this.randomizer.nextBoolean();
   * Get fitness of this individual
   * In case of knapsack, fitness is sum of prices of all things currently in knapsack
   * @see Individual#getFitness()
protected int getFitness()
    //if cached value exist, return it
    if (this.intFitnessCache != Integer.MIN_VALUE)
      return this.intFitnessCache;
    //otherwise, count fitness of this individual
    int intChromosomeCount = this.arrChromosomes.length;
    int intSumOfValues = 0;
    //in case of knapsack, fitness is value of all things currently in knapsack
    //(sum of values of all things in knapsack)
    for (int i = 0; i < intChromosomeCount; i++)
      intSumOfValues = this.assignment.arrPrices;
//save counted fitness to cache
this.intFitnessCache = intSumOfValues;
return intSumOfValues;
* Cross-breed two individuals
* @param other The other individual for cross-breed
* @return The other individual after cross-breed (but this individual is affected too)
* @see Individual#crossbreed()
protected Individual crossbreed(Individual other)
int intChromosomeCount = this.arrChromosomes.length;
//position from which on swap chromosomes of this and the other individual
int intCrossbreedPosition = this.randomizer.nextInt(intChromosomeCount);
boolean booTemp;
//swap chromosomes from cross-breed position on
for (int i = intCrossbreedPosition; i < intChromosomeCount; i++)
booTemp = ((KnapsackIndividual) this).arrChromosomes[i];
((KnapsackIndividual) this).arrChromosomes[i] = ((KnapsackIndividual) other).arrChromosomes[i];
((KnapsackIndividual) other).arrChromosomes[i] = booTemp;
return other;
* Mutate individual chromosomes of this individual with certain probability
* In case of knapsack, particular thing is just inserted/taken out of the knapsack
* @see Individual#mutate()
protected void mutate()
//probability of mutation (in percents)
int intMutationProbability = this.evolution.getMutationProbability();
int intChromosomeCount = this.arrChromosomes.length;
//iterate through all chromosomes, mutating them with certain (set) probability
for (int i = 0; i < intChromosomeCount; i++)
//mutation probability passed => mutate this chromosome
if (this.randomizer.nextInt(100) < intMutationProbability)
this.arrChromosomes[i] = !this.arrChromosomes[i];
//when mutation finished, we must check if this individual still suits the assignment;
//if not, repait it
this.check();
* Check if this individual still suits the assignment; if not, repair it
* In case of knapsack it means that sum of weights of things currently in knapsack
* will not exceed capacity of backpack; if exceeds, take out as many things as necessary
* to not to exceed again; choose things to be taken out according to worst weight to price ratio
* @see Individual#check()
protected void check()
int intSumOfWeights = 0;
//list of things in the knapsack sorted by weight to price ratio
//key: index of thing in knapsack
//value: weight/price ratio
TreeMap<Integer, Float> things = new TreeMap<Integer, Float>();
for (int i = 0; i < this.arrChromosomes.length; i++)
//thing in the knapsack
if (this.arrChromosomes[i] == true)
//add its weight to sum of weights
intSumOfWeights += this.assignment.arrWeights[i];
//add it to the list of things sorted by weight to price ratio
things.put(i, (((float) this.assignment.arrWeights[i]) / ((float) this.assignment.arrPrices[i])));
//sum of weights exceeds knapsack capacity => take out as many things as necessary
while (intSumOfWeights > this.assignment.getKnapsackCapacity())
//take out thing with worst weight/price ratio from all things currently in knapsack
this.arrChromosomes[things.lastKey()] = false;
//update sum of weights of things currently in knapsack
intSumOfWeights -= things.get(things.lastKey());
//also remove this thing from list of things
things.remove(things.lastKey());
And another class, where i need this feature (tried to use generics for that, but they can't be used in this way):
* Evolution.java
* Created on 21. leden 2007, 2:47
package genetics;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
* Class for algorithms using simulated evolution to deal with a problem
* Tried to be designed general enough to allow to be used for every genetic algotihm.
* If true, only class Individual must be implemented according to problem to be solved,
* the rest of genetic algorithm stays the same.
* @author Richard V�tek
* @version
public class Evolution<Problem, IndividualClass extends Individual>
   * Number of generations of evolution to finish
protected int intGenerationCount;
   * Number of individuals in each generation
protected int intGenerationSize;
   * Elite individual count
   * All elite individuals are just copied from one generation to another with no change
protected int intGenerationEliteCount;
   * Number of individuals participating a tournament
   * To select an good individual for next generation, tournaments are hold.
   * This affects number of individuals which one good individual is selected
   * from in one tournament.
   * @see <a href="http://cs.felk.cvut.cz/%7Exobitko/ga/example_f.html">Genetic Algorithm Example Applet</a>
protected int intGenerationTournamentSize;
   * Probability of mutation (in percents)
protected int intMutationProbability;
   * Current generation of individuals in evolution
protected Generation<IndividualClass> thisGeneration;
   * Next generation of individuals in evolution
protected Generation<IndividualClass> nextGeneration;
   * Fitness of best individual in this generation
private int intIndividualBestFitness;
   * Sum of fitnesses of all individuals in this generation
private int intIndividualsSumFitness;
   * Fitness of worst individual in this generation
private int intIndividualWorstFitness;
   * Fitness of best elite individual in (every) generation
   * Auxilliary variable to not to count statistics for elite individuals
   * in each generation as well (not needed - elite individuals don't change themselves)
private int intIndividualEliteBestFitness;
   * Sum of fitnesses of all elite individuals in (every) generation
   * Auxilliary variable to not to count statistics for elite individuals
   * in each generation as well (not needed - elite individuals don't change themselves)
private int intIndividualElitesSumFitness;
   * Fitness of worst elite individual in (every) generation
   * Auxilliary variable to not to count statistics for elite individuals
   * in each generation as well (not needed - elite individuals don't change themselves)
private int intIndividualEliteWorstFitness;
   * Create a new instance of Evolution (settings passed through parameters)
   * @param   intGenerationCount            Number of generation of evolution to finish
   * @param   intGenerationSize             Number of individuals in each generation
   * @param   intGenerationEliteRatio       Elite individuals to generation size ratio (in percents)
   * @param   intGenerationTournamentRatio Members of tournament to generation size ratio (in percents)
   * @param   intMutationProbability        Probability of mutation of each chromosome of each individual of generation (in percents)
   * @see     #intGenerationEliteCount
   * @see     #intGenerationTournamentSize
public Evolution(
    int intGenerationCount, int intGenerationSize,
    int intGenerationEliteRatio, int intGenerationTournamentRatio,
    int intMutationProbability)
    this.intGenerationCount = intGenerationCount;
    this.intGenerationSize = intGenerationSize;
    this.intGenerationEliteCount = (int) (intGenerationSize * (intGenerationEliteRatio / 100.0));
    this.intGenerationTournamentSize = (int) (intGenerationSize * (intGenerationTournamentRatio / 100.0));
    this.intMutationProbability = intMutationProbability;
   * Create a new instance of Evolution (settings loaded from settings file)
   * @param   strSettingFile Name of file containing settings for evolution
   * @throws IOException     File does not exist, cannot be read, etc.
   * @throws Exception       Another exception occured during loading of file
public Evolution(String strSettingFile)
    BufferedReader settings;
    String settingsLine;
    int intLineCounter = 0;
    int intSetting;
    try
      settings = new BufferedReader(new FileReader(strSettingFile));
      while ((settingsLine = settings.readLine()) != null)
        intLineCounter++;
        settingsLine = settingsLine.substring(0, settingsLine.indexOf("\t"));
        intSetting = Integer.parseInt(settingsLine);
        switch (intLineCounter)
          case 1:
            this.intGenerationCount = intSetting;
            break;
          case 2:
            this.intGenerationSize = intSetting;
            break;
          case 3:
            this.intGenerationEliteCount = (int) (this.intGenerationSize * (intSetting / 100.0));
            break;
          case 4:
            this.intGenerationTournamentSize = (int) (this.intGenerationSize * (intSetting / 100.0));
            break;
          case 5:
            this.intMutationProbability = intSetting;
            break;
        } //switch
      } //while
      //after reading has been completed, let's close the stream
      settings.close();
    } //try
    //IO exception - file not found, cannot be read, etc.
    catch (IOException ioe)
      System.out.println("Vyskytl se I/O probl�m při nač�t�n� zad�n� ze souboru " + strSettingFile);
    //Exception - another problem during reading of file
    catch (Exception e)
      System.out.printf("Vyskytl se nějak� divn� probl�m při nač�t�n� zad�n� ze souboru %s. V�pis vyj�mky:\n", strSettingFile);
      e.printStackTrace();
   * Vivify first generation for evolution
   * Necessary number of individuals is created with random chromosomes.
   * Their chromosomes must then be checked if they suit the assignment
   * and if not so, repaired.
private Generation<IndividualClass> vivifyFirstGeneration()
    //create a brand-new generation
    Generation generation = new Generation<IndividualClass>(this);
    int intTemp;
    //for all individual of this generation
    for (int i = 0; i < this.intGenerationSize; i++)
//create an individual with no chromosomes
generation.arrIndividuals[i] = new IndividualClass(this, Problem);
      //create a set of random chromosomes
      neration.arrIndividuals.createRandomChromosomes();
//if these chromosomes does not suit assignment, repair them
generation.arrIndividuals[i].check();
//sort Individuals by fitness so elite individuals get to first positions of array
Arrays.sort(generation.arrIndividuals);
//now count statistics for elite individuals (it is enough to count them once,
//elite don't get changed so their statistics don't get changed either)
this.intIndividualEliteBestFitness = Integer.MIN_VALUE;
this.intIndividualElitesSumFitness = 0;
this.intIndividualEliteWorstFitness = Integer.MAX_VALUE;
//count statistics for elite individuals
for (int i = 0; i < this.intGenerationEliteCount; i++)
intTemp = generation.arrIndividuals[i].getFitness();
//better fitness than best fitness so far
if (intTemp > this.intIndividualEliteBestFitness)
this.intIndividualEliteBestFitness = intTemp;
//worse fitness than worst fitness so far
else if (intTemp < this.intIndividualEliteWorstFitness)
this.intIndividualEliteWorstFitness = intTemp;
this.intIndividualElitesSumFitness += intTemp;
//reset generation's statistics
this.intIndividualBestFitness = this.intIndividualEliteBestFitness;
this.intIndividualsSumFitness = this.intIndividualElitesSumFitness;
this.intIndividualWorstFitness = this.intIndividualEliteWorstFitness;
//count generation's statistics also from rest of individuals
for (int i = this.intGenerationEliteCount; i < this.intGenerationSize; i++)
updateGenerationStatistics(generation.arrIndividuals[i].getFitness());
return generation;
* Get next generation in evolution
* Core method for all evolution; Through this method, new generation is obtained.
* Every next generation should contain better individuals than the previous one
* (till certain point) so with growing number of iterations in evolution, we
* get better results (till certain point).
* Everytime all elite individuals are copied to next generation, then hold needed number of
* tournaments to choose a pair of good-looking individuals, cross-breed individuals in these
* pairs, mutate them (and repair if necessary) and finally add to next generation.
* @return Generation Next generation in evolution
* @see Generation#tournament()
* @see Generation#crossbreed()
* @see Generation#mutate()
private Generation getNextGeneration()
Generation nextGeneration = new Generation(this);
//number of pairs of individuals to select for next generation
int intIndividualPairsToSelect = (this.intGenerationSize - this.intGenerationEliteCount) / 2;
int intTemp;
//reset generation's statistics
this.intIndividualBestFitness = this.intIndividualEliteBestFitness;
this.intIndividualsSumFitness = this.intIndividualElitesSumFitness;
this.intIndividualWorstFitness = this.intIndividualEliteWorstFitness;
//just copy all elite individuals from this generation to another
//(they are on first positions of array of individuals)
for (int i = 0; i < this.intGenerationEliteCount; i++)
nextGeneration.arrIndividuals[i] = this.thisGeneration.arrIndividuals[i];
//hold as many tournaments as necessary to select remaining number of pairs
//of good-looking individuals for next generation (apart from the elite ones)
for (int i = 0; i < intIndividualPairsToSelect; i++)
this.thisGeneration.tournament();
this.thisGeneration.crossbreed();
this.thisGeneration.mutate();
//add this individual in next generation
nextGeneration.arrIndividuals[2 * i] = this.thisGeneration.nextGenerationIndividual01;
//update statistics of generation
updateGenerationStatistics(this.thisGeneration.nextGenerationIndividual01.getFitness());
//add this individual in next generation
nextGeneration.arrIndividuals[2 * i + 1] = this.thisGeneration.nextGenerationIndividual02;
//update statistics of generation
updateGenerationStatistics(this.thisGeneration.nextGenerationIndividual02.getFitness());
//next generation is complete => return it
return nextGeneration;
* Update statistics of current generations
* @param intFitness Fitness that may possibly update generation's statistics
* (best fitness, worst fitness, sum of fitnesses)
private void updateGenerationStatistics(int intFitness)
//better fitness than best fitness so far
if (intFitness > this.intIndividualBestFitness)
this.intIndividualBestFitness = intFitness;
//worse fitness than worst fitness so far
else if (intFitness < this.intIndividualWorstFitness)
this.intIndividualWorstFitness = intFitness;
//update sum of fitnesses as well (for average fitness)
this.intIndividualsSumFitness += intFitness;
* Execute evolution process
* Vivify first generation and then as many next generations as set in settings of evolution
public void evolution()
this.thisGeneration = vivifyFirstGeneration();
//output generation's statistics
System.out.printf("Generace 0:\t%d\t%d\t%d", this.getIndividualBestFitness(), this.getIndividualAverageFitness(), this.getIndividualWorstFitness());
for (int i = 0; i < this.intGenerationCount; i++)
this.nextGeneration = getNextGeneration();
this.thisGeneration = this.nextGeneration;
//output generation's statistics
System.out.printf("Generace %d:\t%d\t%d\t%d", i, this.getIndividualBestFitness(), this.getIndividualAverageFitness(), this.getIndividualWorstFitness());
* Get best fitness of all individuals in this generation
public int getIndividualBestFitness()
return intIndividualBestFitness;
* Get average fitness of all individuals in this generation
public float getIndividualAverageFitness()
return (this.intIndividualsSumFitness / (float) this.intGenerationSize);
* Get worst fitness of all individuals in this generation
public int getIndividualWorstFitness()
return intIndividualWorstFitness;
* Get probability of mutation
* @return Probability of mutation of each chromosome of every individual in generation (in percents)
public int getMutationProbability()
return intMutationProbability;

Abstract class implements Cloneable... How?

Similar Messages

Maybe you are looking for