Method inheritence from abstract classes, and arguments

I'm trying to do something a little weird. I'm writing a pretty complicated wrapper/adapter for two platforms, and I'd like to have an abstract method passed on to child classes, but with the type of the single argument specified by the child class. Is this possible?
Example
public abstract class AbstractParent {
public abstract void foo([ambiguousType] arg);
public class ChildOne extends AbstractParent {
public void foo(TypeA arg) {
//body
public class ChildTwo extends AbstractParent {
public void foo(TypeB arg) {
//body
}TypeA and TypeB have no common supertype beyond Object, and I'd rather not just do instanceof checks and throw errors. Does anyone know of a solution? Can I elaborate any better?

Perhaps you could use generics?
    public abstract class AbstractParent<E> {
        public abstract void foo(E arg);
    public abstract class ChildOne extends AbstractParent<String> {
        public void foo(String arg) {
    public abstract class ChildTwo extends AbstractParent<Integer> {
        public void foo(Integer arg) {
    }

Similar Messages

Method signature (Chapter : Abstract class and Polymorphism)

Hi all,
I found some quaint thing about signature method. It's said: "A child class may define additional methods with signatures different from the parent's method." but
"It is an error if a child defines a method with the same signature as a parent method, but with a different return type."
The thing is: return type is not belong to method's signature !!!
Can someone explain this point?
Thanks and have a nice day ( 11:00 am in Germany)
H.A

"It is an error if a child defines a method with the
same signature as a parent method, but with a
different return type."
The thing is: return type is not belong to method's
signature !!!
Can someone explain this point?Yes.
Even though return type isn't part of the "signature" (as the JLS defines "signature"), the JLS requires that child methods with the same signature as parent classes have the same return type.
Think about it for a minute: Return type isn't part of the signature, but it is part of the contract. If Parent has public Whatsit foo() then it's promising that every instance of Parent, AND every instance of any Child that is a subclass of Parent (since a Child also IS A Parent), will have that method, and callers of that method will receive a Whatsit as a return value.
If I try to override it in Child with public Doobley foo() then a call might try to do this: Parent parent = factory.createParent(); // happens to return a Child, which is allowed, because a Child is a Parent
Whatsit w = parent.foo(); // OH NO! We got bad a Doobley instead of a Watsit! See the problem?
Now, it turns out that 1.5 adds covariant return types, which allows a child method to return a subtype of what the parent returns. So the above would work IFF Doobley is a subclass or subinterface of Whatsis, or is a class that implements Whatsis. This works because the child is still keeping the parent's contract. He's just actually promising a bit more than what the parent promises.

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.

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 and method

Dear all Abaper experts,
I am doubt on a abap object program shown as below. It is a ABSTRACT class and method. However, during compiling, an error message is displayed "The abstract method 'WRITE_STATUS' may not be implemented". What does it mean?
REPORT ZOOP_ABSTRACT.
* Class Declaration
CLASS vehicle DEFINITION ABSTRACT.
PUBLIC SECTION.
    METHODS: accelerate,
             write_status ABSTRACT.
PROTECTED SECTION.
    DATA speed TYPE i.
ENDCLASS.
CLASS plane DEFINITION INHERITING FROM vehicle.
PUBLIC SECTION.
    METHODS: rise.
PROTECTED SECTION.
    DATA altitude TYPE i.
ENDCLASS.
CLASS ship DEFINITION INHERITING FROM vehicle.
ENDCLASS.
* Class Implementation
CLASS vehicle IMPLEMENTATION.
METHOD accelerate.
    speed = speed + 1.
ENDMETHOD.
ENDCLASS.
CLASS plane IMPLEMENTATION.
METHOD rise.
    altitude = altitude + 1.
ENDMETHOD.
METHOD write_status.
    WRITE: / 'Plane speed:', speed.
    WRITE: / 'Altitude:', altitude.
ENDMETHOD.
ENDCLASS.
CLASS ship IMPLEMENTATION.
ENDCLASS.
* Global Data
DATA: plane_ref TYPE REF TO plane,
      ship_ref TYPE REF TO ship.
* Classical Processing Blocks
START-OF-SELECTION.
CREATE OBJECT: plane_ref,
                 ship_ref.
CALL METHOD: plane_ref->accelerate,
               plane_ref->rise,
               plane_ref->write_status,
               plane_ref->accelerate,
               plane_ref->write_status.
All answers are welcome and appreciate for the help.

Hi,
try this code I've rearranged your Class Implementation and just added the foll code;
write_status REDEFINITION in the Definition part of the Subclass.
* Class Declaration
CLASS vehicle DEFINITION ABSTRACT.
PUBLIC SECTION.
    METHODS: accelerate,
             write_status ABSTRACT.
PROTECTED SECTION.
    DATA speed TYPE i.
ENDCLASS.
* Class Implementation
CLASS vehicle IMPLEMENTATION.
METHOD accelerate.
    speed = speed + 1.
ENDMETHOD.
ENDCLASS.
CLASS plane DEFINITION INHERITING FROM vehicle.
PUBLIC SECTION.
    METHODS: rise,
             write_status redefinition.
PROTECTED SECTION.
    DATA altitude TYPE i.
ENDCLASS.
CLASS plane IMPLEMENTATION.
METHOD rise.
    altitude = altitude + 1.
ENDMETHOD.
METHOD write_status.
    WRITE: / 'Plane speed:', speed.
    WRITE: / 'Altitude:', altitude.
ENDMETHOD.
ENDCLASS.
CLASS ship DEFINITION INHERITING FROM vehicle.
PUBLIC SECTION.
    METHODS: write_status redefinition.
ENDCLASS.
CLASS ship IMPLEMENTATION.
METHOD write_status.
    WRITE: / 'In Ship Class.'.
ENDMETHOD.
ENDCLASS.
* Global Data
DATA: plane_ref TYPE REF TO plane,
      ship_ref TYPE REF TO ship.
* Classical Processing Blocks
START-OF-SELECTION.
CREATE OBJECT: plane_ref,
                 ship_ref.
CALL METHOD: plane_ref->accelerate,
               plane_ref->rise,
               plane_ref->write_status,
               plane_ref->accelerate,
               plane_ref->write_status,
               ship_ref->write_status.
Best Regards,
Sunil.

Abstract Classes and Method

Hi all,
I want to appear for SCJP exam and studying for the same ,
Can anyone tell whether concrete methods in an abstract class can be overridden by its subclass or not ... ???
Thanks in advance ,
Suvo

Hai
Actually the overridden concept is supported when the methods are default, protected, public with some constraints, not only when they are protected and public.
The access specifier in the overriding method (in the derived class) should not be more limiting than that of the overriden method (in the base class). This means that if the access specifier for base class method is protected then the access specifier for the derived class method should not be default or private but can be protected, public. The order of increasing visibility of various specifiers is:
default
protected
public
Thanks,
Hari
Edited by: Hari on Jun 3, 2011 8:45 PM

Java abstract classes and methods

Can anyone please tell me any real time example of abstract classes and methods.
I want to know its real use. If anyone have ever used it for some purpose while programming please do tell me.

Ashu_Web wrote:
No please.. I just want to know if you have used it while programming. Like "an abstract class can be used to put all the common method names in it without having to write actual implementation code."That would describe an Interface better than an abstract class. Abstract classes usually have at least some implementation.
I want to know its usage in programming, not just a definition. I guess you understand what I am looking for.Yes, and I gave you one: java.util.AbstractList. It can be found inside the src.zip in your JDK directory and it is a pretty good example for an abstract class that provides some implementation and defines exactly what is necessary to make a full List implementation.

Abstract class and a static method

Can i call a static method within an abstract class ?

public class AbstractDemo {
public static void main(String[] args) {
    BiPlane biPlane = new BiPlane();
    System.out.println("biplane propulsion = " + biPlane.getPropulsionType());
    JumboJet jumboJet = new JumboJet();
    System.out.println("jet load = " + jumboJet.confirmMaxLoad());
    System.out.println("jet speed = " + jumboJet.getTopSpeed());
    System.out.println(Airplane.confirmMaxLoad());
abstract class Airplane {
static String confirmMaxLoad() {
    return "go_get_um, yeehaa!";
public abstract String getPropulsionType();
abstract String getTopSpeed();
class BiPlane extends Airplane {
public BiPlane() {
    System.out.println("BiPlane constructor");
static String confirmMaxLoad() {
    return "400 lbs";
public String getPropulsionType() {
    return "propeller";
final String getTopSpeed() {
    return "130 knots";
class JumboJet extends Airplane {
public JumboJet() {
    System.out.println("JumboJet constructor");
public String getPropulsionType() {
    return "jet";
public String getTopSpeed() {
    return "mach .87";
}

Abstract Class and polymorphism - class diagram

Hi,
]Im trying to draw a class diagram for my overall system but im not too sure how to deal with classes derived from abstract classes. I'll explain my problem using the classic shape inheritance senario...
myClass has a member of type Shape, but when the program is running shape gets instantiated to a circle, square or triangle for example -
Shape s = new circle();
since they are shapes. But at no stage is the class Shape instantiated.
I then call things like s.Area();
On my class diagram should there be any lines going from myClass directly to circle or triangle, or should a line just be joining myClass to Shape class?
BTW - is s.Area() polymorphism?
Thanks,
Conor.

Sorry, my drawing did not display very well.
If you have MyClass, and it has a class variable of type Shape, and the class is responsible for creating MyClass, use Composition on your UML diagram to link Shape and MyClass.
If you have MyClass, and it has a class variable of type Shape, and the class is created elsewhere, use Aggregation on your UML diagram to link Shape and MyClass.
If you have MyClass, and it is used in method signatures, but it is not a class variable, use Depedency on your UML diagram to link Shape and MyClass. The arrow will point to Shape.
Shape and instances of Circle, Triangle, Square, etc. will be linked using a Generalization on your UML diagram. The arrow will always point to Shape.
Anything that is abstract (class, method, variable, etc.) should be italicized. Concrete items (same list) should be formatted normally.
BTW, the distinction between Composition, Aggregation and Dependency will vary from project to project or class to class. It's a gray area. Just be consistent or follow whatever guidelines have been established.
- Saish

From abstract class to public class

I am developing a editor base application...wondering that how to cancel the abstract class and put all the abstract class methods into the public class..?? thanks

Is this a C++ question? If so, you should post it in the C++ forum. If it is a Java question, post in the Java forum.
In either case, please make your question more specific. It sounds like all you have to do is copy the functions from the abstract class to the derived class, remove the dependency on the abstract class, and delete the abstract class from the source code. Presumably that is not what you are asking.

Abstract classes and OO theory...

I have an OO theory question related to abstract classes and their member variables. I realize opinions will vary from person to person but I'll ask anyway...
If I'm creating an abstract class, should member variables that will be used by subclasses be private or protected? Why? Either way, they will have accessor methods for classes that instantiate them (where appropriate) but I'm debating whether or not to give subclasses direct access to these variables or not.
To me, it seems odd to make variables in the abstract class private but I'm curious what your opinions are.
Thanks...

I knew you'd say that. I'd like to play along with a for-instance, if you will allow ... here's an example parent class:
public abstract class ProvideMenu   extends JFrame {
protected              JMenuBar       jmbar;
protected              JMenu          jmfile,
                                        jmedit,
                                        jmhelp;
protected              JMenuItem      jmfnew,
                                        jmfopen,
                                        jmfsave,
                                        jmfsaveas,
                                        jmfprint,
                                        jmfexit,
                                        jmecopy,
                                        jmepaste,
                                        jmhabout,
                                        jmhcontents;
public ProvideMenu() {
    jmbar       = new JMenuBar();
    jmfile      = new JMenu( FILE_MENU );
    jmedit      = new JMenu( EDIT_MENU );
public abstract void aMeth();
}Now the subclass does not need to provide setProvideMenuFont( new Font( ... ) ) and Font getProvideMenuFont() methods, setProvideMenuEnabled(), etc. but can use the standard methods setFont, getFont setBackground(), setEnabled, etc, etc.
Mind you I'm not advocating this ... what I am doing is trying to open the discussion up a bit - I hope no one minds ... what better design - just a for-instance - would you advocate?
~Bill

Abstract class and class

What is the difference between abstract class and class in java?

arcadesstuff wrote:
Abstract class: a class that contains at least one abstract method. As has already been mentioned, abstract classes need not contain any methods at all. Have a look at the abstract class you posted; it's still abstract, though it contains no abstract methods. Note that if one declares any method of a class abstract, the class itself must be declared abstract as well.
When you implement the abstract class Animal, you will have to write the code of those two abstract methods from above.Your example contains no abstract methods. Abstract methods must be marked with the keyword "abstract".
~

Question about Classes, Abstract Classes and Interfaces.

I have been experimenting with Classes, Abstract Classes and Interfaces and wonder if anyone can explain this to me.
I was looking for a way to assign a value to a variable and then keep it fixed for the session and have devised this.
First I create an abstract class like this:
public abstract class DatabaseConnection {
private static String ServerName = null;
public static void setServerName(String serverName) {
          ServerName = serverName;
     public static String getServerName() {
          return ServerName;
}and then I created an interface
public interface DatabaseAccess {
     String servername = DatabaseConnection.getServerName();
}And finally the class itself with some test lines in it so I could see what was going on:
public class CreateDatabase extends DatabaseConnection implements DatabaseAccess {
     public static void main (String args[]){
          new CreateDatabase();
     public CreateDatabase(){
          setServerName("Server Name 1");
          System.out.println ("Before update ");
          System.out.println ("ServerName from Interface           = " + servername);
          System.out.println ("ServerName from Abstract Class = " + getServerName());
          System.out.println ("After update ");
          setServerName("Server Name 2");
          System.out.println ("ServerName from Interface           = " + servername);
          System.out.println ("ServerName from Abstract Class = " + getServerName());
          System.out.println ("==========================");
}The output I get from the above is:
Before update
ServerName from Interface           = Server Name 1
ServerName from Abstract Class = Server Name 1
After update
ServerName from Interface           = Server Name 1
ServerName from Abstract Class = Server Name 2
==========================I also tried this in another class which calls the above class to see if I get the same effect
public class CheckDatabaseAccess {
     public static void main (String args[]){
          new CreateDatabase();
          CreateDatabase.setServerName("Server 3");
          System.out.println("CreateDatabase "+CreateDatabase.servername);
          CreateDatabase.setServerName("Server 4");
          System.out.println("CreateDatabase "+CreateDatabase.servername);
          CreateDatabase.setServerName("Server 5");
          System.out.println("CreateDatabase "+CreateDatabase.servername);
}The output of which is this:
Before update
ServerName from Interface           = Server Name 1
ServerName from Abstract Class = Server Name 1
After update
ServerName from Interface           = Server Name 1
ServerName from Abstract Class = Server Name 2
==========================
CreateDatabase Server Name 1
CreateDatabase Server Name 1
CreateDatabase Server Name 1Can anyone explain why I appear to only be able to change or set the ServerName only the once?
Is this the correct way to do it? If it is it's exactly what I am looking for, a way to set the value of variable once in a session and then prevent it being changed.
Or is there a better way of doing this.
What I want to use this for is for example, storing the accesses to a database on a server. I won't know what server the database will be stored on nor what the database is called so I create an INI file which stores this information in encrypted format, which is set by the database administrator. It occurs to me I can use this method to then retrieve that data once and once only from the INI file and use that throughout the life of the session to access the database.
Any help appreciated
Regards
John

Not gonna read all of it, but this jumps out:
public abstract class DatabaseConnection {
private static String ServerName = null;
public interface DatabaseAccess {
     String servername = DatabaseConnection.getServerName();
}You have two completely separate variables (with two different names, for that matter, since you were inconsistent in your capitalization, but it wouldn't make a difference if they did have the same name with the same case). And the one in the interface is implicitly public, static, and final.
Anytime you refer to "servername" through a reference of type DatabaseAccess, it refers to the one declared in the interface.
Anytime you refer to "ServerName" inside the DatabaseConnection class, it refers to the one declared in that class.

What is the difference between Abstract class and Interface ?

Hi,
Could u plz tell me the difference between Abstract class and Interface?
Thanks in advance.
Gopi

Lots.
An abstract class can contain some method implementations, or indeed all the method implementations. It may contain methods with all the various access modifiers. It cannot be instantiated. A class may inherit from only a single abstract class.
An interface contains only public method stubs and constants. A class may implement multiple interfaces. An interface cannot (obviously) be instantiated.
Abstract classes are particularly useful when you need to provide a semi-complete implementation for reuse. Interfaces are used more like types.
Look at java.util.* for some good examples of the use of both.

Difference between abstract classes and interfaces

I actually wonder about what are the differences between abstract classes and interfaces may somebody give an example code about it?
and i have one more question how can i use interfaces like multiple inheritance ? i mean when i implement an interface like
class a extends b implements c,di have to use all c and d methods but what that methods means?
I mean as i know we cannot make implementations of methods in interfaces
but for example in runnable interface there is a method like run() and it has been defined somewhere because it knows what to do(i mean when it will run), i just write my code into that method .

Once you get past the starting point (I am referring to the OP here), there are a few salient differences:
You can only extend (or generalize) a single superclass; however, you can implement (or realize) multiple interfaces. As such, all things being equal, using an interface in lieu of an abstract class 'frees' your design. Later, if you want the implementor of an interface to inherit from another class, there is not issue.
Any abstract method specifies a contract. However, abstract classes allow you to also add common behavior to subclasses. This is an overused justification for abstract classes, IMO. You can achieve the same effect using delegation and still having interfaces.
Always program to interfaces wherever possible. This means that you define an interface and have an implementing class (usually at a minimum). Do not do this for all your classes, but rather the ones that make your system unique (the domain model or M in MVC architecture). This allows you to later change implementation with a minimal amount of refactoring. This is a core precept from the Group of Four and any number of decent programming books.Best of luck.
- Saish

Method inheritence from abstract classes, and arguments

Similar Messages

Maybe you are looking for