Polymorphism and abstract classes

DYNAMIC BINDING
I am writing a JAVA(SWING/GUI) program that recognises certain commands.Users will enter command and the program executes the command.I want to be able to add commands in future.I have been able to do it with IF/ELSE statements and would like to do it using polymorhism so as to allow dynamic binding.Part of the code is shown below
I am open to any suggestions
private class commandhandler implements ActionListener
{ public void actionPerformed(ActionEvent event)
for(int start=0;start<end;start++)
{ String read=label2.getText();
COMMAND (OpCode,Operand);
public void COMMAND(String COM1,String COM2)
{ if(COM1.equals("01"))
{ String copy1=label.getText();
else if(opcode.equals("02"))

Here's one idea, that could do what you want an outlines some points
1. Build a class with the following methods:
String[] getFunctions ();
Object[] getFunctionParams (String function);
boolean accept(String functioncall,String[] args);
boolean execute (String funcall, String[] args);
2. You could then just recompile your class with updates that would be recognizable to your console under this framework, or you could do something like this.
public static void main (String[] args) {
MyProjectOperations = class.forName(args[0]).instanceOf();
}

Similar Messages

Mixing polymorphism with abstract classes???

Hi,
Can you have polymorhism with abstract superclasses in Java?
For example, say I have a superclass called Pet:
abstract class Pet {
     private String name;
     public String getName() {
          return name;
    public void setName(String petName) {
         name = petName;
    public String speak() {
         return "I am a Pet";
}Now I have a Cat subclass:
public class Cat extends Pet{
    public String speak {
         return "i am a cat";
public class Dog extends Pet {
public String fetch() {
     return "fetching a stick";
}In my test method I have:
public class TestPet {
     public static void main(String[] args) {
          Pet p = new Pet();
          System.out.println(p.speak());
          Pet p = new Dog();
          System.out.println(((Dog)p).fetch());
          Pet p = new Cat();
          System.out.println(p.speak() +" is now a cat");
}So it appears to me that you cannot have polymorphic methods with an abstract superclass - is this right?
Cheers.

cotton.m wrote:
List<Pet> pets = new ArrayList<Pet>();
I was working (more or less) along the same lines...
package forums;
import java.util.List;
import java.util.ArrayList;
abstract class Pet
private String name;
public String getName() { return this.name; }
public void setName(String name) { this.name = name; }
public String speak() {
    return "I am a Pet";
public abstract String fetch(); // <<<<< the new bit.
public String getClassName() {
    final String name = this.getClass().getName();
    return name.substring(name.lastIndexOf('.')+1).toLowerCase();
class Cat extends Pet
public Cat(String name) {
    setName(name);
public String speak() {
    return "I am a cat";
public String fetch() {
    return "No. I am a cat!";
public String rollOver() {
    return "No. I am a cat!";
class Dog extends Pet
public Dog(String name) {
    setName(name);
public String fetch() {
    return "Look boss, I'm fetching the stick.";
public String sit() {
    return "Look boss, I'm sitting!";
public class PetTest
public static void main(String[] args) {
    List<Pet> pets = new ArrayList<Pet>();
    pets.add(new Cat("Fungus"));
    pets.add(new Dog("Spike"));
    for ( Pet pet : pets ) {
      System.out.println("\""+pet.speak()+"\" said "+pet.getName()+" the "+pet.getClassName()+".");
      System.out.println("\"Go fetch\" said the master.");
      System.out.println("\""+pet.fetch()+"\" said "+pet.getName()+".");
      System.out.println();
    System.out.println("Therefore we conclude that dogs are much better pets.");
}Both these examples demonstrate that polymorphism is very useful when we have a list of different-type-if-things which have a common interface... i.e. different classes which have (a) a common ancestor; or (b) a common interface... allowing us to treat those different types-of-things as if they where one-type-of-thing, except the-different-types actually do different stuff internally, which is appropriate-to-there-specific-type.
That's the essence of polymorphism... and, of course, this seperation of "type" and "implementation" isn't limited to lists-of-stuff... it can be very useful all over the show.
Cheers. Keith.
Edited by: corlettk on 10/05/2009 11:01 ~~ That's a bit clearer.

Interface and Abstract class difference

An interface can be used in such a way that we don't know the class of object assigned to a reference of that interface type until runtime. Can we use the abstract class in a similar way too?
The difference between an abstract class and interface can be listed as
1. Interface can not have implementation of any method
2. The usage of interface and class is one other difference
3. What other differences we have?

Yes an abstract class can be used in a similar way. The main issue with an abstract class is that you extend it and you can only extend one class so that can be a huge limitation that an interface does not give you.
Here's another one that is often overlooked: use both.
public abstract class SomeBaseClass implements Runnable {
public abstract void someAbstractMethod();
public void someMethodWithADefaultImplementation(){
System.out.println("Hello!");
}Any class that extends SomeBaseClass (and is not abstract) will need to implement the run() method of the Runnable interface.

Inter face and abstract class

hi
can u please tell me the difference between interface and an abstract class? In which situations they will be usefull.
thank u
shyam

http://java.sun.com/developer/JDCTechTips/2001/tt1106.html#tip2

Interfaces and abstract classes

can anyone pls tell me where exactly an abstract class is used and where exactly an interface is to be used.
i think the main difference between an abstract class and an interface is that an interface will have all the abstract methods whereas an abstract class can have one or more abstract methods--- if i am not wrong.
anything to add? -- pls let me know on this....
and also how they might be useful for us....

Inheritance is the most popular feature of the OOP. By organising classes into class hierachy it gives an extra dimension to the encapsulation of abstract data types becauase it enables classes to inherit attributes/methods from other classes.
There are two complementary roles of inheritance in OOP application.
1. Specialisation: Extending the functionality of an existing class.
2. Generalisation: Sharing commonality between two or more classes.
So adding functionality by extending what exists at each level to create more specialized classes. This would create a hierarchy and would be helpful even later on in maintenance.
Now when to have an abstarct class and when an interface. An interface just defines the basic functionality to be implemented by all the subclasses, though the way they are implemented may be different. e.g an interfaca animal can have all those functionalities common to all animals in basics but different in implementation. e.g all animals walk however some walk on two legs and some on four. All animals can see but they might have a different colour spectrum visible. So all such methods general but common can be in an interface.
Abstract classes come into play at a more defined level e.g in an abstract class human though walk would be the same so implemented there and then but talking can be left abstract since there may be different languages involved.
For more details refer to a good OOP book.

Interface and abstract class

why we have constructor for abstract class and not for interface,

When you call a constructor of a class which is extended by abstract class. It runs first the abstract class constructor and then child class constructor and initialize the member variables.
while interface has no variable all final data so interface is no need to implement a constructor.
Regards,

Difference between inheritance and abstract class

difference between inheritance and abstract class

See this thread:
http://forum.java.sun.com/thread.jspa?forumID=24&threadID=663657
And before Post New Topic, just search in this forums. All most will get answers.

How to use interface and abstract class in the real time sennario ?

how to validate password and reenter password fields in the struts through the xml files?

Here is a modified dealForm.jsp that merges the 2 steps - both symbol submission and Yahoo convert is done by it. Play with it and add your DB code to it:
<html>
<head><title>IPIB Database Selection</title></head>
<body bgcolor="#DFDFFF">
<H1><CENTER>IPIB Database Selection</CENTER></H1>
<font size=4>
<%@ page language="java" %>
<%@ page import="java.net.*,java.io.*,java.util.*" %>
<%
String symbol = request.getParameter("symbol");
if (symbol != null) {
String urlString = "http://finance.yahoo.com/download/javasoft.beans?SYMBOLS=" + symbol + "&format=ab";
try {
URL url = new URL(urlString);
URLConnection con = url.openConnection();
InputStream is = con.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line = br.readLine();
StringTokenizer tokenizer = new StringTokenizer(line,",");
String name = tokenizer.nextToken();
name = name.substring(1, name.length()-2);
String price = tokenizer.nextToken();
price = price.substring(1, price.length()-2);
%>
<p>
Original line from yahoo <%= line %>
</p> <p>
Name: <%= name %>
</p> <p>
Price: <%= price %>
</p> <p>
Pub DB processing code from dealLoad.jsp here
</p>
<%
} catch (IOException exception) {
System.err.println("IOException: " + exception);
} else { %>
<form action="dealForm.jsp"method="GET">
<p>Enter Symbol: <input size="20" name="symbol">
<inputtype="submit" value="Submit">
</p></form>
<% } %>
</font>
</body>
</html>

Interfaces, Abstract Classes & Polymorphism

I have a friend taking a Java course as part of a larger degree program, and she's asked for some help with an assignment. The assignment is as follows:
This assignment is to write a simple encryption/decryption application. There will be a single application
that the user can use to encrypt or decrypt a phrase passed in on the command line, with the user deciding
which encryption/decryption scheme to use.
The first scheme is to add 1 to each character that is in the phrase, the other is to subtract 1 from each
character that is in the phrase.
To encrypt, you must be able to use the follwing syntax:
java Crypto encrypt Additive "hello"
Output:
"hello" encrypts to: "ifmmmp"
To decrypt:
java ca.bcit.cst.comp2256.a###### decrypt Additive "ifmmp"
Output:
"ifmmp" decrypts to: "hello"
Use Additive or Subtractive as the arguments to choose which encryption/decryption to
use. The problem is, I'm not entirely sure how to use abstract classes and interfaces to do what is being asked. I'm pretty sure I could do the whole program in a single for-loop, but apparently her teacher doesn't want people coming up with their own solutions for the problem. I don't need any code for how to do it, per se, I'm just wondering how one would structure a program like that to include interfaces, polymorphism and abstract classes.
Anyone have any ideas?

with the user deciding which encryption/decryption scheme to use.This is the key sentence. encryption/decryption can be done using multiple schemes. The contract for any given scheme can be defined using
public String encrypt(String input);
public String decrypt(String input);There can be multiple implementations for these methods, one set for each scheme.
The contract therefore becomes the interface and each implementation is a concrete implementation of this interface.
The problem doesn't delve deep into the kind of schemes available. If it does and there is a significant overlap between 2 schemes, an abstract class that takes care of the shared logic among 2 schemes comes into picture.
Hope this helps!

Difference between abstract class and the normal class

Hi...........
can anyone tell me use of abstract class instead of normal class
The main doubt for me is...
1.why we are defining the abstract method in a abstract class and then implementing that in to the normal class.instead of that we can straight way create and implement the method in normal class right...../

Class vs. interface
Some say you should define all classes in terms of interfaces, but I think recommendation seems a bit extreme. I use interfaces when I see that something in my design will change frequently.
For example, the Strategy pattern lets you swap new algorithms and processes into your program without altering the objects that use them. A media player might know how to play CDs, MP3s, and wav files. Of course, you don't want to hardcode those playback algorithms into the player; that will make it difficult to add a new format like AVI. Furthermore, your code will be littered with useless case statements. And to add insult to injury, you will need to update those case statements each time you add a new algorithm. All in all, this is not a very object-oriented way to program.
With the Strategy pattern, you can simply encapsulate the algorithm behind an object. If you do that, you can provide new media plug-ins at any time. Let's call the plug-in class MediaStrategy. That object would have one method: playStream(Stream s). So to add a new algorithm, we simply extend our algorithm class. Now, when the program encounters the new media type, it simply delegates the playing of the stream to our media strategy. Of course, you'll need some plumbing to properly instantiate the algorithm strategies you will need.
This is an excellent place to use an interface. We've used the Strategy pattern, which clearly indicates a place in the design that will change. Thus, you should define the strategy as an interface. You should generally favor interfaces over inheritance when you want an object to have a certain type; in this case, MediaStrategy. Relying on inheritance for type identity is dangerous; it locks you into a particular inheritance hierarchy. Java doesn't allow multiple inheritance, so you can't extend something that gives you a useful implementation or more type identity.
Interface vs. abstract class
Choosing interfaces and abstract classes is not an either/or proposition. If you need to change your design, make it an interface. However, you may have abstract classes that provide some default behavior. Abstract classes are excellent candidates inside of application frameworks.
Abstract classes let you define some behaviors; they force your subclasses to provide others. For example, if you have an application framework, an abstract class may provide default services such as event and message handling. Those services allow your application to plug in to your application framework. However, there is some application-specific functionality that only your application can perform. Such functionality might include startup and shutdown tasks, which are often application-dependent. So instead of trying to define that behavior itself, the abstract base class can declare abstract shutdown and startup methods. The base class knows that it needs those methods, but an abstract class lets your class admit that it doesn't know how to perform those actions; it only knows that it must initiate the actions. When it is time to start up, the abstract class can call the startup method. When the base class calls this method, Java calls the method defined by the child class.

Non-abstract methods in a Abstract class

Abstract Class can contain Non-abstract methods.
and Abstract Classes are not instantiable as well
So,
What is the purpose of Non-abstract methods in a Abstract class.
since we can't create objects and use it
so these non-abstract methods are only available to subclasses.
(if the subclass is not marked as abstract)
is that the advantage that has.(availability in subclass)
??

For example, the AbstractCollection class (in
java.util) provides an implementation for many of the
methods defined in the Collection interface.
Subclasses only have to implement a few more methods
to fulfill the Collection contract. Subclasses may
also choose to override the AbstractCollection
functionality if - for example - they know how to
provide an optimized implementation based on
characteristics of the actual subclass.Another example is the abstract class MouseAdapter that implements MouseListener, MouseWheelListener, MouseMotionListener, and that you can use instead of these interfaces when you want to react to one or two types of events only.
Quoting the javadocs: "If you implement the MouseListener, MouseMotionListener interface, you have to define all of the methods in it. This abstract class defines null methods for them all, so you can only have to define methods for events you care about."

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

A question about Abstract Classes

Hello
Can someone please help me with the following question.
Going through Brian's tutorials he defines in one of his exercises an 'abstract' class as follows
<ClassType ID="MyMP.MyComputerRoleBase" Base="Windows!Microsoft.Windows.ComputerRole" Accessibility="Internal" Abstract="true" Hosted="true" Singleton="false">
Now I am new to authoring but get the general concepts, and on the surface of it, it appears odd to have an 'abstract' class that is also 'hosted' I understand and abstract class to be a template with one or more properties defined which is then used
as the base class for one or more concrete classes. Therefore you do not have to keep defining the properties on these concrete classes over and over as they inherit the properties from their parent abstract class, is this correct so far?
if the above is correct then it seems odd that the abstract class would be hosted, unless (and this is the only way it makes sense to me) that ultimately (apart from singleton classes) any class that is going to end up being discovered and
thereby an instance of said class instigated in the database must ultimately be hosted somewhere, is that correct?
in other words if you has an abstract class, which acts as the base class for one or more concrete classes (by which I mean ones for which you are going to create lets say WMI discoveries ), if this parent abstract class is not ultimately
hosted to a concrete class of its own then these child concrete classes (once discovered) will never actually create instances in the database.
Is that how it is?
Any advise most welcome, thanks
AAnotherUser__
AAnotherUser__

Hi,
Hosting is the only relationship type that doesn't require you to discover it with a discovery rule. OpsMgr will create a relationship instance automatically for you using a 'hosted' properties 'chain' in a class\model definition. In an abstract class definition
you need to have this property set to 'true' or you will 'brake' a hosting 'chain'.
http://OpsMgr.ru/

Abstract Classes versus Interfaces

Somebody at work has just made an interesting observation and its bugging me, comments please.
When I started Java I just used classes (and abstract classes), and didnt bother with Interfaces I understood them to be a way of getting round the lack of MultipleInheritance and it wasnt a problem that concerned me.
But as time went on I found that sometimes I did want classes that had little in common to provide some additional feature (such as logging), and interfaces were great for this.
..so I was happy ..
During all this time if I want a HashSet I would write code like this
HashSet dataSet = new HashSet();but then I read that HashSet was an implementation detail and we should be using Interfaces as follows:
Set dataSet = new HashSet();So whereas before I might have had a class hierachy with an Abstract class at the top , I started slotting in Interfaces above that and viewing the Abstract class as just a convenience to implementing the Interface.
So which is the right method , originally I saw subclassing object as an 'is a ' relationship and implementing an interface as a 'implements' relationship. But more recently it seems to be turned on its head and implementing an interface is an 'is a' relationship (but supports multiple inheritance)
Also it seems to be the trouble with this second approach is that anyone can implement an interface, for example I could implement Set,Map and List with one class, the class hierachy is not so helpful .

Thanks, but the question was alot wider than that,
the HashSet example was just one part of it.I think it is representative of all the situations that you talk about, which are whether an instantiator should handle the instantiated object by its interface or by its implementation.
I suppose the question is
"How do you code model "is a " relationship in java
through extending a class or creating an interface
and implementing it"
MySubClass extends MySuperClass implements MyInterface {}MySubClass is a MySuperClass and a MyInterface. The way that I view it, the "is a" relationship applies to all type inheritance, even for the multiple type inheritance that you can have with interfaces. The "is a" relationship doesn't doesn't have to be a 1:1 mapping. There's no point in thinking about it differently since that's how the language behaves.
an alternative question is
"is it correct to mix/match both methods I described
above"I thought I gave an answer. You said that my answer is not "broad enough." How so? My answer was that handling an object that you instantiate by its interface can reduce the amount of changes you have to make if you change the implementation. You will have to make one change (the line of code that instantiates the object) instead of many. Also, handling it by its interface makes it easier to switch from object A instantiating object B to object A being passed a reference to B and to object A getting its dependencies injected by XML configuration.
It seems weird to handle an object by its interface if you already know it's implementation, but it's commonly seen and this is why I think it must be used. As I said, it's a small benefit of abstraction.
The times when you may not want to do this is when the instantiator has to call methods from different interfaces of the object. You can handle it by its interface by casting between the different interfaces you have to work with, or you can just handle it by its implementation, gaining access to all of the object's interfaces.
Note that everything I explained concerns the type by which the instantiator handles an instantiated object. If a class does not instantiate a certain object, then it almost always should receive it by its interface, unless it's some really common implementation that's never going to change.
I use interface, abstract class, and base class interchangeably. It's up to you to decide which to use for type inheritance. It's good practice to favor interfaces.

Static vs abstract classes

Just wondering if anyone knows the difference between static classes and abstract classes.
How do static methods, static variables work?
Is there such a thing as an abstract method?
Thanks

Ok i think its easier to understand if u see some examples:
abstract class X{
protected int value;
public abstract void setValue(int pValue);
class Y extends X{
public void setValue(int pValue) {
this.value=pValue;
}//each class, which extends x has to implement this method, or the class has to be //declared abstract too
class Z extends X{
public void setValue(int pValue) {
this.value=2*pValue;
You can use this inheritance-tree as follows:
public class try {
public static void main(String[] args) {
X try=new X() //NOT possible!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
X try=new Y();
try.setValue(10); //the value-field of try has the value 10
try=new Z();
try.setValue(10); //the value-field of try has the value 20
The techinque i used above is called "dynamical linking" and is one of the advantages of an objectoriented language.
The main difference of abstract and static is, that you can't instantiate an abstract class direct.
A static class or a static method and variables has just one (and only one!!) represantation during runtime. And if you want to change the value of a static variable within a method this method has to be static too.
Example:
public class StaticTest {
static int counter;
public StaticTest() {
counter++;
public static void print() {
System.out.println(this.counter);
public class TestClass {
public static void main(String[] args) {
StaticTest test;
for (int i=0;i<10;i++) {
test=new StaticTest();
StaticTest.print(); //the output would be 10!!!!!!!!!!!!!!
I hope this helps

Polymorphism and abstract classes

Similar Messages

Maybe you are looking for