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.
Similar Messages
-
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 -
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. -
Implementing Comparable in an abstract class
Hi all,
I am making my first sortie with abstract classes. I have had a good look around, but would still appreciate some advice with the following problem.
In my application I have several classes that have many things in common. I have concluded therefore, that if I create and then inherit from an abstract super class, I can reduce and improve my code. I created this abstract class:
public abstract class YAbstractObject implements Comparable {
public YAbstractObject(int projectId, YObject object, String objectName) {
this.projectId = projectId; // Always the same parameters
this.object = object;
this.objectName = objectName;
// This is abstract as it must always be present for sub classes but differant processing will take place
public abstract void resolveObject();
// These three methods will always be the same for all sub classes
public String getName() {
return objectName;
public YObject getObject() {
return object;
public boolean isValid() {
return isValid;
// Overridden and always the same for all sub classes
public String toString() {
return objectName;
// implemented abstract method
public int compareTo(Object thatObject) {
// Issue here! I would like something as follows:
// return this.getName().compareToIgnoreCase(thatObject.getName());
// Variable decleration
private int projectId;
private YObject object;
private String objectName;
private boolean isValid;As I have commented in the compareTo() method, I would like it to be able to use the getName() method for comparison objects and compare them. But it does not like this, as it does not know that "thatObject" is of the same class as this object - I hope that made sense.
in essence, I want to inherit this method for different classes and have it work with each.
Is there a way to do this? Generics?
Any observations, greatly appreciated,
SteveYou can use also generics (if applicable: java -version >= 1.5).
public abstract class Test implements Comparable<Test> {
String name;
public Test(String name) {
this.name = name;
public String getName() {
return name;
public int compareTo(Test obj) {
return this.getName().compareTo(obj.getName());
public class Other extends Test {
public Other(String name) {
super(name);
public class Tester extends Test {
public Tester(String name) {
super(name);
public static void main(String[] args) {
Test t = new Tester("t");
Test a = new Tester("a");
Test o = new Other("t");
System.out.println(t.compareTo(a));
System.out.println(t.compareTo(new Object())); //compile error
System.out.println(t.compareTo(o));
}Without the compile error line it will give the following result:
19
0 -
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 BlackJackClientthere 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.. -
Concrete classes implement abstract class and implements the interface
I have one query..
In java collection framework, concrete classes extend the abstract classes and implement the interface. What is the reason behind extending the class and implementing the interface when the abstract class actually claims to implement that interface?
For example :
Class Vector extends AbstractList and implements List ,....
But the abstract class AbstractList implements List.. So the class Vector need not explicitly implement interface List.
So, what is the reason behind this explicit definition...?
If anybody knows please let me know..
Thanx
Rajendra.Why do you post this question again? You already asked this once in another thread and it has been extensively debated in that thread: http://forum.java.sun.com/thread.jsp?forum=31&thread=347682
-
Internal class implementing interface extending abstract interface :P
Confused ha? Yeah me too. RIght here it goes.
Theres an abstract interface (abstractIFace) that has for example method1() method2() and method3(). There are two other interfaces iFace1 and iFace2 that extend abstractIFace. Still with me? :P iFace1 only uses method2() whereas iFace2 uses method1(), method2() and method3(). Internal classes implementing these are then used. The reason is so that when returning an object one method can be used that will return different types of objects. But this doesnt work. It says that all the classes in the abstractIFace must be used/implemented but I only want method2() in iFace1 and all in iFace2.
Just say what the f*ck if this is too confusing cos i think it is and i did a crap job explaining!! :Ppublic interface IFace {
void method1();
void method2();
void method3();
public class Test {
private static class Class1 implements IFace {
public void method1() {
System.out.println("method1");
public void method2() {
System.out.println("method2");
public void method3() {
System.out.println("method3");
private static class Class2 implements IFace {
public void method1() {
throw new UnsupportedOperationException();
public void method2() {
System.out.println("method2");
public void method3() {
throw new UnsupportedOperationException();
public static IFace createObject(boolean flag) {
return flag ? (IFace) new Class1() : new Class2();
} -
Implement method inside abstract class?
hello everyone:
I have a question regarding implementation of method inside a abstract class. The abstract class has a static method to swamp two numbers.
The problem ask if there is any output from the program; if no output explain why?
This is a quiz question I took from a java class. I tried the best to recollect the code sample from my memory.
if the code segment doesn't make sense, could you list several cases that meet the purpose of the question. I appreciate your help!
code sample
public abstract class SwampNumber
int a = 4;
int b = 2;
System.out.println(a);
System.out.println(b);
swamp(a, b);
public static void swamp(int a, int b)
int temp = a;
a = b;
b = a;
System.out.println(a);
System.out.println(b);It won't compile.
You can't instantiate an abstract class before you know anything.
//somewhere in main
SwampNumber myNum = new SwampNumber();
//Syntax ErrorQuote DrClap
This error commonly occurs when you have code that >>is not inside a method.
The only statements that can appear outside methods >>in a Java class are >>declarations.Message was edited by:
lethalwire -
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; -
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,
Johnbuchktry this...
http://developer.sonyericsson.com/site/global/techsupport/tipstrickscode/java/p_java_0501.jsp
hope it can help u -
How to Compile this prog. i DOS prompt.
Hey Friends,
I don't know how to compile this prog. on DOS prompt, kindly tell.
// My Java Prog.
package package1;
import java.awt.Graphics;
import java.lang.Number;
import java.io.*;
import java.net.*;
import java.util.*;
import java.awt.Color;
import java.awt.event.*;
import java.applet.Applet;
import java.io.*;
import java.util.*;
import java.Applet.*;
/* <applet code="abc" width=600 height=1000 > </applet> */
public class abc extends Applet implements Runnable {
Hashtable dataFile = new Hashtable();
StringBuffer sb;
String Date,Time,Freq;
double KarDmd,KarDwl,KarShr,KarGen;
boolean flag = true ;
Thread myThread = null;
* init
public void init(){
setBackground(Color.gray);
* start
public void start() {
System.out.println("Start called"+this.getDocumentBase());
System.out.println("Start called"+this.getCodeBase());
myThread = new Thread(this );
myThread.start();
}//close thread
public void run(){
while (flag){
try {
URL url = new URL(this.getCodeBase(),"servlet/FileReadingServlet");
HttpMessage message = new HttpMessage(url);
InputStream in = message.sendGetMesage(null);
ObjectInputStream ois = new ObjectInputStream(in);
//String readStream = (String)ois.readObject();
dataFile = (Hashtable)ois.readObject();
//sb = new StringBuffer(readStream);
System.out.println("Applet Read :"+dataFile);
this.repaint();
try {
Thread.sleep(10000);
}catch (InterruptedException io){}
}catch (Exception e){
e.printStackTrace();
flag = false;
}//while
}//close run
public void paint (Graphics g){
g.clearRect(0,0,700,450);
g.drawString("Date :", 500,16);
g.drawString((String)dataFile.get("DATE"), 550,16);
g.drawString("TIME:",500,32);
g.drawString((String)dataFile.get("TIME"), 550,32);
g.drawString("FREQ :",500,48);
g.drawString((String)dataFile.get("FREQ"), 550,48);
// "KARNATAKA"
g.setColor(Color.cyan);
g.drawRect(10,50,150,100);
g.fillRect(10,50,150,100);
g.setColor(Color.black);
g.drawString("KARNATAKA",25,65);
g.drawLine(160,100,250,100);
g.drawString("GENERATION ",12,87);
String KAR_GEN = this.getGeneration((String)dataFile.get("KAR_DMD"),
(String)dataFile.get("KAR_DRL"));
g.drawString(KAR_GEN ,120,87);
g.drawString("SCHEDULE",12,107);
g.drawString((String)dataFile.get("KAR_SHD"),120,107);
g.drawString("DRAWL ",12,127);
g.drawString((String)dataFile.get("KAR_DRL"),120,127);
g.drawString("DEMAND ",12,147);
g.drawString((String)dataFile.get("KAR_DMD"),120,147);
g.drawLine(92,70,92,150);
//"KAPS"
g.setColor(Color.green);
g.drawRect(12,5,85,30);
g.fillRect(12,5,85,30);
g.setColor(Color.black);
g.drawString("KAPS",14,20);
g.drawString("DEMAND:",14,35);
g.drawString((String)dataFile.get("KAPS_DMD"),70,35);
//"GOA"
g.setColor(Color.magenta);
g.drawRect(100,5,85,30);
g.fillRect(100,5,85,30);
g.setColor(Color.black);
g.drawString("GOA",104,20);
g.drawString("DEMAND:", 104,35);
g.drawString((String)dataFile.get("GOA_DMD"),160,35);
// "ANDHRA PRADESH"
g.setColor(Color.orange);
g.drawRect(250,50,150,100);
g.fillRect(250,50,150,100);
g.setColor(Color.black);
g.drawLine(32,37,32,50);
g.drawLine(110,35,110,50);
g.drawString("ANDHRA PRADESH",268,65);
g.drawString("GENERATION ",252,87);
String AP_GEN = this.getGeneration((String)dataFile.get("AP_DMD"),
(String)dataFile.get("AP_DRL"));
g.drawString(AP_GEN,350,87);
g.drawString("SCHEDULE",252,107);
g.drawString((String)dataFile.get("AP_SHD"),350,107);
g.drawString("DRAWL",252,127);
g.drawString((String)dataFile.get("AP_DRL"),350,127);
g.drawString("DEMAND",252,147);
g.drawString((String)dataFile.get("AP_DMD"),350,147);
g.drawLine(332,70,332,150);
// "NTPC"
g.setColor(Color.pink);
g.drawRect(250,3,85,30);
g.fillRect(250,3,85,30);
g.setColor(Color.black);
g.drawString("NTPC",252,14);
g.drawString("DEMAND:",252,30);
g.drawString((String)dataFile.get("NTPC_DMD"),305,30);
//"HVDC"
g.setColor(Color.green);
g.drawRect(350,3,85,30);
g.fillRect(350,3,85,30);
g.setColor(Color.black);
g.drawString("HVDC",352,14);
g.drawString("DEMAND:",352,30);
g.drawString((String)dataFile.get("HVDC_DMD"),405,30);
//"GAUZACK"
g.setColor(Color.magenta);
g.drawRect(450,80,90,30);
g.fillRect(450,80,90,30);
g.setColor(Color.black);
g.drawString("GAZ",452,90);
g.drawString("DEMAND:",452,105);
g.drawString((String)dataFile.get("GAZ_DMD"),510,105);
g.drawLine(160,250,250,250);
g.drawLine(85,150,85,200);
g.drawLine(160,125,250,225);
g.drawLine(270,300,270,330);
g.drawLine(370,300,370,330);
g.drawLine(400,230,450,230);
g.drawLine(400,100,450,100);
g.drawLine(270,33,270,50);
g.drawLine(370,33,370,50);
//"KERALA"
g.setColor(Color.green);
g.drawRect(10,200,150,100);
g.fillRect(10,200,150,100);
g.setColor(Color.black);
g.drawString("KERALA",62,215);
g.drawString("GENERATION ",12,237);
String KER_GEN = this.getGeneration((String)dataFile.get("KER_DMD"),
(String)dataFile.get("KER_DRL"));
g.drawString((String)dataFile.get("KER_GEN"),120,237);
g.drawString("SCHEDULE ",12,257);
g.drawString((String)dataFile.get("KER_SHD"),120,257);
g.drawString("DRAWL",12,277);
g.drawString((String)dataFile.get("KER_DRL"),120,277);
g.drawString("DEMAND",12,297);
g.drawString((String)dataFile.get("KER_DMD"),120,297);
//"TAMIL NADU"
g.drawLine(92,220,92,300);
g.drawLine(325,150,325,200);
g.setColor(Color.yellow);
g.drawRect(250,200,150,100);
g.fillRect(250,200,150,100);
g.setColor(Color.black);
g.drawString("TAMIL NADU",272,215);
g.drawString("GENERATION ",252,237);
String TN_GEN = this.getGeneration((String)dataFile.get("TN_DMD"),
(String)dataFile.get("TN_DRL"));
g.drawString((String)dataFile.get("TN_GEN"),350,237);
g.drawString("SCHEDULE ",252,257);
g.drawString((String)dataFile.get("TN_SHD"),350,257);
g.drawString("DRAWL ",252,277);
g.drawString((String)dataFile.get("TN_DRL"),350,277);
g.drawString("DEMAND:",252,297);
g.drawString((String)dataFile.get("TN_DMD"),350,297);
g.drawLine(332,220,332,300);
// "PONDYCHERRY"
g.setColor(Color.magenta);
g.drawRect(450,220,90,30);
g.fillRect(450,220,90,30);
g.setColor(Color.black);
g.drawString("PDY",452,230);
g.drawString("DEMAND:",452,245);
g.drawString((String)dataFile.get("PDY_DMD"),510,245);
//"NLY"
g.setColor(Color.green);
g.drawRect(250,330,90,30);
g.fillRect(250,330,90,30);
g.setColor(Color.black);
g.drawString("NLY",252,340);
g.drawString("DEMAND:",252,355);
g.drawString((String)dataFile.get("NLY_DMD"),310,355);
//"MAPS"
g.setColor(Color.pink);
g.drawRect(350,330,90,30);
g.fillRect(350,330,90,30);
g.setColor(Color.black);
g.drawString("MAPS",352,340);
g.drawString("DEMAND:",352,355);
g.drawString((String)dataFile.get("MAPS_DMD"),410,355);
g.setColor(Color.black);
//g.drawLine(440,306,620,306);
//g.drawLine(440,332,620,332);
//g.drawLine(440,358,620,358);
//g.drawLine(530,280,530,388);
for(int i=70;i<150;i=i+20) g.drawLine(10,i,160,i);
for(int i=70;i<150;i=i+20) g.drawLine(250,i,400,i);
for(int i=220;i<300;i=i+20) g.drawLine(10,i,160,i);
for(int i=220;i<300;i=i+20) g.drawLine(250,i,400,i); }//close paint
* stop
public void stop() {
myThread.destroy();
* destroy
public void destroy() {
* getAppletInfo
* @return java.lang.String
public String getAppletInfo() {
return "Applet Information";
private String getGeneration(String DMD,String DRL){
double _gen = 0;
if ( ( DMD != null) && ( DRL != null)){
Double DMDOB = new Double(DMD);
Double DRLOB = new Double(DRL);
gen = DMDOB.doubleValue() - _DRLOB.doubleValue();
return new Double (_gen).toString();
} //close classChange your directory to the directory above package1.
Assuming that you've got d:/projects/src/package1/abc.java you'd want to be in d:/projects/src.
Run javac referencing the abc class relatively:
d:\projects\src> javac package1/abc.javaThis should get you abc.class in the package1 directory.
Hope this helps. -
Hi ,
I have a fundamental doubt regarding Abstract Class & Interface!!!
What is their real benefit...whether we implement an interface or extend an Abstract class we have to write the code for the abstract method in the concrete class.Then where the benefit remained....
And it is said that Abstract class provide default behaviour...what is the actual meaning of that?
Thanks & Regards
SantoshIn this section we will redesign our OneRowNim game to fit within a hierarchy of classes of two-player games. There are many games that characteristically involve two players: checkers, chess, tic-tac-toe, guessing games, and so forth. However, there are also many games that involve just one player: blackjack, solitaire, and others. There are also games that involve two or more players, such as many card games. Thus, our redesign of OneRowNim as part of a two-player game hierarchy will not be our last effort to design a hierarchy of game-playing classes. We will certainly redesign things as we learn new Java language constructs and as we try to extend our game library to other kinds of games.
This case study will illustrate how we can apply inheritance and polymorphism, as well as other object-oriented design principles. The justification for revising OneRowNim at this point is to make it easier to design and develop other two-player games. As we have seen, one characteristic of class hierarchies is that more general attributes and methods are defined in top-level classes. As one proceeds down the hierarchy, the methods and attributes become more specialized. Creating a subclass is a matter of specializing a given class.
8.6.1. Design Goals
One of our design goals is to revise the OneRowNim game so that it fits into a hierarchy of two-player games. One way to do this is to generalize the OneRowNim game by creating a superclass that contains those attributes and methods that are common to all two-player games. The superclass will define the most general and generic elements of two-player games. All two-player games, including OneRowNim, will be defined as subclasses of this top-level superclass and will inherit and possibly override its public and protected variables and methods. Also, our top-level class will contain certain abstract methods, whose implementations will be given in OneRowNim and other subclasses.
Generic superclass
A second goal is to design a class hierarchy that makes it possible for computers to play the game, as well as human users. Thus, for a given two-player game, it should be possible for two humans to play each other, or for two computers to play each other, or for a human to play against a computer. This design goal will require that our design exhibit a certain amount of flexibility. As we shall see, this is a situation in which Java interfaces will come in handy.
[Page 376]
Another important goal is to design a two-player game hierarchy that can easily be used with a variety of different user interfaces, including command-line interfaces and GUIs. To handle this feature, we will develop Java interfaces to serve as interfaces between our two-player games and various user interfaces.
8.6.2. Designing the TwoPlayerGame Class
To begin revising the design of the OneRowNim game, we first need to design a top-level class, which we will call the TwoPlayerGame class. What variables and methods belong in this class? One way to answer this question is to generalize our current version of OneRowNim by moving any variables and methods that apply to all two-player games up to the TwoPlayerGame class. All subclasses of TwoPlayerGamewhich includes the OneRowNim classwould inherit these elements. Figure 8.18 shows the current design of OneRowNim.
Figure 8.18. The current OneRowNim class.
What variables and methods should we move up to the TwoPlayerGame class? Clearly, the class constants, PLAYER_ONE and PLAYER_TWO, apply to all two-player games. These should be moved up. On the other hand, the MAX_PICKUP and MAX_STICKS constants apply just to the OneRowNim game. They should remain in the OneRowNim class.
The nSticks instance variable is a variable that only applies to the OneRowNim game but not to other two-player games. It should stay in the OneRowNim class. On the other hand, the onePlaysNext variable applies to all two-player games, so we will move it up to the TwoPlayerGame class.
Because constructors are not inherited, all of the constructor methods will remain in the OneRowNim class. The instance methods, takeSticks() and getSticks(), are specific to OneRowNim, so they should remain there. However, the other methods, getPlayer(), gameOver(), getWinner(), and reportGameState(), are methods that would be useful to all two-player games. Therefore these methods should be moved up to the superclass. Of course, while these methods can be defined in the superclass, some of them can only be implemented in subclasses. For example, the reportGameState() method reports the current state of the game, so it has to be implemented in OneRowNim. Similarly, the getWinner() method defines how the winner of the game is determined, a definition that can only occur in the subclass. Every two-player game needs methods such as these. Therefore, we will define these methods as abstract methods in the superclass. The intention is that TwoPlayerGame subclasses will provide game-specific implementations for these methods.
[Page 377]
Constructors are not inherited
Given these considerations, we come up with the design shown in Figure 8.19. The design shown in this figure is much more complex than the designs used in earlier chapters. However, the complexity comes from combining ideas already discussed in previous sections of this chapter, so don't be put off by it.
Figure 8.19. TwoPlayerGame is the superclass for OneRowNim and other two-player games.
To begin with, note that we have introduced two Java interfaces into our design in addition to the TwoPlayerGame superclass. As we will show, these interfaces lead to a more flexible design and one that can easily be extended to incorporate new two-player games. Let's take each element of this design separately.
[Page 378]
8.6.3. The TwoPlayerGame Superclass
As we have stated, the purpose of the TwoPlayerGame class is to serve as the superclass for all two-player games. Therefore, it should define the variables and methods shared by two-player games.
The PLAYER_ONE, PLAYER_TWO, and onePlaysNext variables and the getPlayer(), setPlayer(), and changePlayer() methods have been moved up from the OneRowNim class. Clearly, these variables and methods apply to all two-player games. Note that we have also added three new variables, nComputers, computer1, computer2, and their corresponding methods, getNComputers() and addComputerPlayer(). We will use these elements to give our games the capability to be played by computer programs. Because we want all of our two-player games to have this capability, we define these variables and methods in the superclass rather than in OneRowNim and subclasses of TwoPlayerGame.
Note that the computer1 and computer2 variables are declared to be of type IPlayer. IPlayer is an interface containing a single method declaration, the makeAMove() method:
public interface IPlayer {
public String makeAMove(String prompt);
Why do we use an interface here rather than some type of game-playing object? This is a good design question. Using an interface here makes our design more flexible and extensible because it frees us from having to know the names of the classes that implement the makeAMove() method. The variables computer1 and computer2 will be assigned objects that implement IPlayer via the addComputerPlayer() method.
Game-dependent algorithms
The algorithms used in the various implementations of makeAMove() are game-dependentthey depend on the particular game being played. It would be impossible to define a game playing object that would suffice for all two-player games. Instead, if we want an object that plays OneRowNim, we would define a OneRowNimPlayer and have it implement the IPlayer interface. Similarly, if we want an object that plays checkers, we would define a CheckersPlayer and have it implement the IPlayer interface. By using an interface here, our TwoPlayerGame hierarchy can deal with a wide range of differently named objects that play games, as long as they implement the IPlayer interface. Using the IPlayer interface adds flexibility to our game hierarchy and makes it easier to extend it to new, yet undefined, classes. We will discuss the details of how to design a game player in Section 8.6.7.
The IPlayer interface
Turning now to the methods defined in TwoPlayerGame, we have already seen implementations of getPlayer(), setPlayer(), and changePlayer() in the OneRowNim class. We will just move those implementations up to the superclass. The getNComputers() method is the assessor method for the nComputers variable, and its implementation is routine. The addComputerPlayer() method adds a computer player to the game. Its implementation is as follows:
[Page 379]
public void addComputerPlayer(IPlayer player) {
if (nComputers == 0)
computer2 = player;
else if (nComputers == 1)
computer1 = player;
else
return; // No more than 2 players
++nComputers;
As we noted earlier, the classes that play the various TwoPlayerGames must implement the IPlayer interface. The parameter for this method is of type IPlayer. The algorithm we use checks the current value of nComputers. If it is 0, which means that this is the first IPlayer added to the game, the player is assigned to computer2. This allows the human user to be associated with PLAYERONE if this is a game between a computer and a human user.
If nComputers equals 1, which means that we are adding a second IPlayer to the game, we assign that player to computer1. In either of these cases, we increment nComputers. Note what happens if nComputers is neither 1 nor 2. In that case, we simply return without adding the IPlayer to the game and without incrementing nComputers. This, in effect, limits the number of IPlayers to two. (A more sophisticated design would throw an exception to report an error. but we will leave that for a subsequent chapter.)
The addComputerPlayer() method is used to initialize a game after it is first created. If this method is not called, the default assumption is that nComputers equals zero and that computer1 and computer2 are both null. Here's an example of how it could be used:
OneRowNim nim = new OneRowNim(11); // 11 sticks
nim.add(new NimPlayer(nim)); // 2 computer players
nim.add(new NimPlayerBad(nim));
Note that the NimPlayer() constructor takes a reference to the game as its argument. Clearly, our design should not assume that the names of the IPlayer objects would be known to the TwoPlayerGame superclass. This method allows the objects to be passed in at runtime. We will discuss the details of NimPlayerBad in Section 8.6.7.
The getrules() method is a new method whose purpose is to return a string that describes the rules of the particular game. This method is implemented in the TwoPlayerGame class with the intention that it will be overridden in the various subclasses. For example, its implementation in TwoPlayerGame is:
public String getRules() {
return "The rules of this game are: ";
Overriding a method
[Page 380]
and its redefinition in OneRowNim is:
public String getRules() {
return "\n*** The Rules of One Row Nim ***\n" +
"(1) A number of sticks between 7 and " + MAX_STICKS +
" is chosen.\n" +
"(2) Two players alternate making moves.\n" +
"(3) A move consists of subtracting between 1 and\n\t" +
MAX_PICKUP +
" sticks from the current number of sticks.\n" +
"(4) A player who cannot leave a positive\n\t" +
" number of sticks for the other player loses.\n";
The idea is that each TwoPlayerGame subclass will take responsibility for specifying its own set of rules in a form that can be displayed to the user.
You might recognize that defining geTRules() in the superclass and allowing it to be overridden in the subclasses is a form of polymorphism. It follows the design of the toString() method, which we discussed earlier. This design will allow us to use code that takes the following form:
TwoPlayerGame game = new OneRowNim();
System.out.println(game.getRules());
Polymorphism
In this example the call to getrules() is polymorphic. The dynamic-binding mechanism is used to invoke the getrules() method defined in the OneRowNim class.
The remaining methods in TwoPlayerGame are defined abstractly. The gameOver() and getWinner() methods are both game-dependent methods. That is, the details of their implementations depend on the particular TwoPlayerGame subclass in which they are implemented.
This is good example of how abstract methods should be used in designing a class hierarchy. We give abstract definitions in the superclass and leave the detailed implementations up to the individual subclasses. This allows the different subclasses to tailor the implementations to their particular needs, while allowing all subclasses to share a common signature for these tasks. This enables us to use polymorphism to create flexible, extensible class hierarchies.
Figure 8.20 shows the complete implementation of the abstract TwoPlayerGame class. We have already discussed the most important details of its implementation.
Figure 8.20. The TwoPlayerGame class
(This item is displayed on page 381 in the print version)
public abstract class TwoPlayerGame {
public static final int PLAYER_ONE = 1;
public static final int PLAYER_TWO = 2;
protected boolean onePlaysNext = true;
protected int nComputers = 0; // How many computers
// Computers are IPlayers
protected IPlayer computer1, computer2;
public void setPlayer(int starter) {
if (starter == PLAYER_TWO)
onePlaysNext = false;
else onePlaysNext = true;
} // setPlayer()
public int getPlayer() {
if (onePlaysNext)
return PLAYER_ONE;
else return PLAYER_TWO;
} // getPlayer()
public void changePlayer() {
onePlaysNext = !onePlaysNext;
} // changePlayer()
public int getNComputers() {
return nComputers;
} // getNComputers()
public String getRules() {
return "The rules of this game are: ";
} // getRules()
public void addComputerPlayer(IPlayer player) {
if (nComputers == 0)
computer2 = player;
else if (nComputers == 1)
computer1 = player;
else
return; // No more than 2 players
++nComputers;
} // addComputerPlayer()
public abstract boolean gameOver(); // Abstract Methods
public abstract String getWinner();
} // TwoPlayerGame class
Effective Design: Abstract Methods
Abstract methods allow you to give general definitions in the superclass and leave the implementation details to the different subclasses.
[Page 381]
8.6.4. The CLUIPlayableGame Interface
We turn now to the two interfaces shown in Figure 8.19. Taken together, the purpose of these interfaces is to create a connection between any two-player game and a command-line user interface (CLUI). The interfaces provide method signatures for the methods that will implement the details of the interaction between a TwoPlayerGame and a UserInterface. Because the details of this interaction vary from game to game, it is best to leave the implementation of these methods to the games themselves.
Note that CLUIPlayableGame extends the IGame interface. The IGame interface contains two methods that are used to define a standard form of communication between the CLUI and the game. The getGamePrompt() method defines the prompt used to signal the user for a move of some kindfor example, "How many sticks do you take (1, 2, or 3)?" And the reportGameState() method defines how the game will report its current statefor example, "There are 11 sticks remaining." CLUIPlayableGame adds the play() method to these two methods. As we will see shortly, the play() method contains the code that will control the playing of the game.
[Page 382]
Extending an interface
The source code for these interfaces is very simple:
public interface CLUIPlayableGame extends IGame {
public abstract void play(UserInterface ui);
public interface IGame {
public String getGamePrompt();
public String reportGameState();
} // IGame
Note that the CLUIPlayableGame interface extends the IGame interface. A CLUIPlayableGame is a game that can be played through a CLUI. The purpose of its play() method is to contain the game-dependent control loop that determines how the game is played via a user interface (UI). In pseudocode, a typical control loop for a game would look something like the following:
Initialize the game.
While the game is not over
Report the current state of the game via the UI.
Prompt the user (or the computer) to make a move via the UI.
Get the user's move via the UI.
Make the move.
Change to the other player.
The play loop sets up an interaction between the game and the UI. The UserInterface parameter allows the game to connect directly to a particular UI. To allow us to play our games through a variety of UIs, we define UserInterface as the following Java interface:
public interface UserInterface {
public String getUserInput();
public void report(String s);
public void prompt(String s);
Any object that implements these three methods can serve as a UI for one of our TwoPlayerGames. This is another example of the flexibility of using interfaces in object-oriented design.
To illustrate how we use UserInterface, let's attach it to our KeyboardReader class, thereby letting a KeyboardReader serve as a CLUI for TwoPlayerGames. We do this simply by implementing this interface in the KeyboardReader class, as follows:
public class KeyboardReader implements UserInterface
[Page 383]
As it turns out, the three methods listed in UserInterface match three of the methods in the current version of KeyboardReader. This is no accident. The design of UserInterface was arrived at by identifying the minimal number of methods in KeyboardReader that were needed to interact with a TwoPlayerGame.
Effective Design: Flexibility of Java Interfaces
A Java interface provides a means of associating useful methods with a variety of different types of objects, leading to a more flexible object-oriented design.
The benefit of defining the parameter more generally as a UserInterface instead of as a KeyboardReader is that we will eventually want to allow our games to be played via other kinds of command-line interfaces. For example, we might later define an Internet-based CLUI that could be used to play OneRowNim among users on the Internet. This kind of extensibilitythe ability to create new kinds of UIs and use them with TwoPlayerGamesis another important design feature of Java interfaces.
Generality principle
Effective Design: Extensibility and Java Interfaces
Using interfaces to define useful method signatures increases the extensibility of a class hierarchy.
As Figure 8.19 shows, OneRowNim implements the CLUIPlayableGame interface, which means it must supply implementations of all three abstract methods: play(), getGamePrompt(), and reportGameState().
8.6.5. Object-Oriented Design: Interfaces or Abstract Classes?
Why are these methods defined in interfaces? Couldn't we just as easily define them in the TwoPlayerGame class and use inheritance to extend them to the various game subclasses? After all, isn't the net result the same, namely, that OneRowNim must implement all three methods.
These are very good design questions, exactly the kinds of questions one should ask when designing a class hierarchy of any sort. As we pointed out in the Animal example earlier in the chapter, you can get the same functionality from an abstract interface and an abstract superclass method. When should we put the abstract method in the superclass, and when does it belong in an interface? A very good discussion of these and related object-oriented design issues is available in Java Design, 2nd Edition, by Peter Coad and Mark Mayfield (Yourdan Press, 1999). Our discussion of these issues follows many of the guidelines suggested by Coad and Mayfield.
Interfaces vs. abstract methods
We have already seen that using Java interfaces increases the flexibility and extensibility of a design. Methods defined in an interface exist independently of a particular class hierarchy. By their very nature, interfaces can be attached to any class, and this makes them very flexible to use.
Flexibility of interfaces
Another useful guideline for answering this question is that the superclass should contain the basic common attributes and methods that define a certain type of object. It should not necessarily contain methods that define certain roles that the object plays. For example, the gameOver() and getWinner() methods are fundamental parts of the definition of a TwoPlayerGame. One cannot define a game without defining these methods. By contrast, methods such as play(), getGamePrompt(), and reportGameState() are important for playing the game but they do not contribute in the same way to the game's definition. Thus these methods are best put into an interface. Therefore, one important design guideline is:
[Page 384]
Effective Design: Abstract Methods
Methods defined abstractly in a superclass should contribute in a fundamental way to the basic definition of that type of object, not merely to one of its roles or its functionality.
8.6.6. The Revised OneRowNim Class
Figure 8.21 provides a listing of the revised OneRowNim class, one that fits into the TwoPlayerGame class hierarchy. Our discussion in this section will focus on the features of the game that are new or revised.
Figure 8.21. The revised OneRowNim class, Part I.
(This item is displayed on page 385 in the print version)
public class OneRowNim extends TwoPlayerGame implements CLUIPlayableGame {
public static final int MAX_PICKUP = 3;
public static final int MAX_STICKS = 11;
private int nSticks = MAX_STICKS;
public OneRowNim() { } // Constructors
public OneRowNim(int sticks) {
nSticks = sticks;
} // OneRowNim()
public OneRowNim(int sticks, int starter) {
nSticks = sticks;
setPlayer(starter);
} // OneRowNim()
public boolean takeSticks(int num) {
if (num < 1 || num > MAX_PICKUP || num > nSticks)
return false; // Error
else // Valid move
{ nSticks = nSticks - num;
return true;
} // else
} // takeSticks()
public int getSticks() {
return nSticks;
} // getSticks()
public String getRules() {
return "\n*** The Rules of One Row Nim ***\n" +
"(1) A number of sticks between 7 and " + MAX_STICKS +
" is chosen.\n" +
"(2) Two players alternate making moves.\n" +
"(3) A move consists of subtracting between 1 and\n\t" +
MAX_PICKUP + " sticks from the current number of sticks.\n" +
"(4) A player who cannot leave a positive\n\t" +
" number of sticks for the other player loses.\n";
} // getRules()
public boolean gameOver() { /*** From TwoPlayerGame */
return (nSticks <= 0);
} // gameOver()
public String getWinner() { /*** From TwoPlayerGame */
if (gameOver()) //{
return "" + getPlayer() + " Nice game.";
return "The game is not over yet."; // Game is not over
} // getWinner()
The gameOver() and getWinner() methods, which are nowinherited from the TwoPlayerGame superclass, are virtually the same as in the previous version. One small change is that getWinner() now returns a String instead of an int. This makes the method more generally useful as a way of identifying the winner for all TwoPlayerGames.
Similarly, the getGamePrompt() and reportGameState() methods merely encapsulate functionality that was present in the earlier version of the game. In our earlier version the prompts to the user were generated directly by the main program. By encapsulating this information in an inherited method, we make it more generally useful to all TwoPlayerGames.
Inheritance and generality
The major change to OneRowNim comes in the play() method, which controls the playing of OneRowNim (Fig. 8.22). Because this version of the game incorporates computer players, the play loop is a bit more complex than in earlier versions of the game. The basic idea is still the same: The method loops until the game is over. On each iteration of the loop, one or the other of the two players, PLAYER_ONE or PLAYER_TWO, takes a turn making a movethat is, deciding how many sticks to pick up. If the move is a legal move, then it becomes the other player's turn.
Figure 8.22. The revised OneRowNim class, Part II.
(This item is displayed on page 386 in the print version)
/** From CLUIPlayableGame */
public String getGamePrompt() {
return "\nYou can pick up between 1 and " +
Math.min(MAX_PICKUP,nSticks) + " : ";
} // getGamePrompt()
public String reportGameState() {
if (!gameOver())
return ("\nSticks left: " + getSticks() +
" Who's turn: Player " + getPlayer());
else
return ("\nSticks left: " + getSticks() +
" Game over! Winner is Player " + getWinner() +"\n");
} // reportGameState()
public void play(UserInterface ui) { // From CLUIPlayableGame interface
int sticks = 0;
ui.report(getRules());
if (computer1 != null)
ui.report("\nPlayer 1 is a " + computer1.toString());
if (computer2 != null)
ui.report("\nPlayer 2 is a " + computer2.toString());
while(!gameOver()) {
IPlayer computer = null; // Assume no computers
ui.report(reportGameState());
switch(getPlayer()) {
case PLAYER_ONE: // Player 1's turn
computer = computer1;
break;
case PLAYER_TWO: // Player 2's turn
computer = computer2;
break;
} // cases
if (computer != null) { // If computer's turn
sticks = Integer.parseInt(computer.makeAMove(""));
ui.report(computer.toString() + " takes " + sticks + " sticks.\n");
} else { // otherwise, user's turn
ui.prompt(getGamePrompt());
sticks =
Integer.parseInt(ui.getUserInput()); // Get user's move
if (takeSticks(sticks)) // If a legal move
changePlayer();
} // while
ui.report(reportGameState()); // The game is now over
} // play()
} // OneRowNim class
Let's look now at how the code decides whether it is a computer's turn to move or a human player's turn. Note that at the beginning of the while loop, it sets the computer variable to null. It then assigns computer a value of either computer1 or computer2, depending on whose turn it is. But recall that one or both of these variables may be null, depending on how many computers are playing the game. If there are no computers playing the game, then both variables will be null. If only one computer is playing, then computer1 will be null. This is determined during initialization of the game, when the addComputerPlayer() is called. (See above.)
In the code following the switch statement, if computer is not null, then we call computer.makeAMove(). As we know, the makeAMove() method is part of the IPlayer interface. The makeAMove() method takes a String parameter that is meant to serve as a prompt, and returns a String that is meant to represent the IPlayer's move:
public interface IPlayer {
public String makeAMove(String prompt);
[Page 385]
In OneRowNim the "move" is an integer, representing the number of sticks the player picks. Therefore, in play() OneRowNim has to convert the String into an int, which represents the number of sticks the IPlayer picks up.
On the other hand, if computer is null, this means that it is a human user's turn to play. In this case, play() calls ui.getUserInput(), employing the user interface to input a value from the keyboard. The user's input must also be converted from String to int. Once the value of sticks is set, either from the user or from the IPlayer, the play() method calls takeSticks(). If the move is legal, then it changes whose turn it is, and the loop repeats.
[Page 386]
There are a couple of important points about the design of the play() method. First, the play() method has to know what to do with the input it receives from the user or the IPlayer. This is game-dependent knowledge. The user is inputting the number of sticks to take in OneRowNim. For a tic-tac-toe game, the "move" might represent a square on the tic-tac-toe board. This suggests that play() is a method that should be implemented in OneRowNim, as it is here, because OneRowNim encapsulates the knowledge of how to play the One-Row Nim game.
Encapsulation of game-dependent knowledge
[Page -
What is the diff b/w Abstract class and an interface ?
Hey
I am always confused as with this issue : diff b/w Abstract class and an interface ?
Which is more powerful in what situation.
Regards
VinayHi, Don't worry I am teach you
Abstract class and Interface
An abstract class can have instance methods that implement a default behavior. An Interface can only declare constants and instance methods, but cannot implement default behavior and all methods are implicitly abstract. An interface has all public members and no implementation. An abstract class is a class which may have the usual flavors of class members (private, protected, etc.), but has some abstract methods.
Edited by SASIKUMARA
SIT INNOVATIONS- Chennai
Message was edited by:
sasikumara
Message was edited by:
sasikumara
Maybe you are looking for
-
How can I fix a nav bar that wraps to a second line?
I have a single line of text on the navigation bar while I'm working in iweb but when published it wraps to a second line. I tried extending the page width which seemed to help on my home page but the other pages still have 2 lines.
-
Change of Material Valuation Class - What Approach to Consider?
Dear SAP Expert ... In OSS notes # 160970, it mentions that starting from release 4.6B we can use Customizing Transaction OMT4 (Change System Message) to change corresponding check from error to warning. With this function, the system won't check if
-
How to change white background with text to transparent background
Good afternoon, I have a jpg file (part of our logo) white background with black text and I would like to change it to transparent background and keep the black text (to be able to insert it on a cup image). I tried to change it in photoshop, however
-
User Exit in Contract -Very Urgent
Dear Experts, We are using User Exit "M06E0005 - Role determination for release of purchasing documents" for some enhancement of release strategy for purchasing docs. It is working fine for PO but in case of contract the exit is not firing. We wrote
-
How can i get apple mail to recognize gmail and pac bell mail servers?
how can i get apple mail to get gmail and pacbell mail? it says it doesn't recognixe the certificate, so i restarted which usally works but not always please help thank you garrett