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."

Similar Messages

Can i call non -abstract method in abstract class into a derived class?

Hi all,
Is it possible in java to call a non-abstract method in a abstact class from a class derived from it or this is not possible in java.
The following example will explain this Ques. in detail.
abstract class A
void amethod()
System.out.println(" I am in Base Class");
public class B extends A
void amethod()
System.out.println(" I am in Derived Class");
public static void main (String args[])
// How i code this part to call a method amathod() which will print "I am in Base Class
}

Ok, if you want to call a non-static method from a
static method, then you have to provide an object. In
this case it does not matter whether the method is in
an abstract base class or whatever. You simply cannot
(in any object oriented language, including C++ and
JAVA) call a nonstatic method without providing an
object, on which you will call the method.
To my solution with reflection: It also only works,
if you have an object. And: if you use
getDeclaredMethod, then invoke should not call B's
method, but A's. if you would use getMethod, then the
Method object returned would reflect to B's method.
The process of resolving overloaded methods is
performed during the getMethod call, not during the
invoke (at least AFAIK, please tell me, if I'm wrong).You are wrong....
class A {
    public void dummy() {
         System.out.println("Dymmy in A");
class B extends A {
     public void dummy() {
          System.out.println("Dymmy in B");
     public static void main(String[] args) throws Exception {
          A tmp = new B();
          Class clazz = A.class;
          Method method = clazz.getDeclaredMethod("dummy", null);
          method.invoke(tmp, null);
}Prints:
Dymmy in B
/Kaj

Abstract method and class

I'm a beginner in Java and just learn about abstract method and class.
However, i am wondering what is the point of using abstract method/class?
Because when I delete the abstract method and change the class name to public class XXXX( changed from "abstract class XXXX), my program still runs well, nothing goes different.
Is it because I haven't encountered any situation that abstract method is necessary or ?
Thanks!

Yes - you probably haven't encountered a situation where you need an abstract.
Abstract classes are not designed to do anything on their own. They are designed to provide a template for other classes to extend by inheritance. What you have build sounds like a concrete class - one which you are creating instances of. Abstract classes are not designed to be ever instantiated in their pure form - they act like a partial building block, which you will complete in a class which extends the abstract.
An example might be a button class, which provides some core functionality (like rollover, rollout etc) but has an empty action method which has to be overwritten by a relevant subclass like 'StartButton'. In general, abstract classes may not be the right answer, and many people would argue that it is better to use an interface, which can be implemented instead of extended, meaning that you can ADD instead of REPLACING.
Not sure if that helps.. there are whole chapters in books on this kind of thing, so it's hard to explain in a couple of paragraphs. Do some google searches to find out more about how they work.

Overiding super class method to an abstract method

public class Super
public void doSomethingUseful()
public abstract class Sub extends Super
public abstract void doSomethingUseful();
What is the OO principle behind this?
When do we need to override a super class method in subclass as an abstract?

Lets first look at a simple design pattern called "Template Method".
public abstract class Library
private void collectBooks()
// collect books here
private void putBookInShelf()
// put books in shelf here
// abstract method sortBooks()
public abstract void sortBooks();
public void processBooks()
collectBooks();
sortBooks();
putBooksInShelf();
this class is an abstract class giving an abstract method called "sortBooks()", what is it useful for? We can make a subclass and implement sortBooks() to sort the books as we want (title wise, author wise, date wise, publisher wise) and then simply call processBooks() to process them.
One Sub class may look like:
public class MyLibrary extends Library
public void sortBooks()
// sort books by title b/c I like them sorted out by title
Another sub-class may look like
public class HisLibrary extends Library
public void sortBooks()
// sort books by Author, b/c he likes his books sorted out by author
Now client will say:
public static void main(String str[])
MyLibrary mylib=new MyLibrary();
mylib.processBooks(); // books will be processed by sorting them title wise
HisLibrary hislib=new HisLibrary();
hislib.processBooks(); // books will be processed by sorting them author wise
So in Library class, method "sortBooks()" was a template method allowing subclasses to sort the books as they want while all other functionality was implemented by Library class itself.
Now if we go back to your example, a method which is concrete in super class that you converted into an abstract method in sub class ( doSomethingUseful() ) is now a template method, which alows the sub classes of this subclass to do something useful what they think is useful or in other words you are allowing subclasses of this subclass to implement this template method as they want by using their own algorithm.
Now why whould you do that? answer is that you don't have access to the code of super class, otherwise you must have made this method abstract in super class in the first place.
Note that the code may not compile, I tried to come up with an exmple and did not pay attention to compiler demands.
I think I cleared my point, It was tough to explain though.
Good Luck.
Khawar.

Advantage of abstract methods

hi, i am a bit confuse abt the abstract methods in an abstract class. what are the advantages of declaring them as abstract? all the classes that extend it need to implement the methods although the classes do not require implementation of that method which resulted in an empty method body. If i juz comment the abstract methods in the abstract class, my whole program still can compile and run to my expectation. So, why we need to do extra work by writing the abstract methods in the abstract class?
i'm sorry that i'm a bit stupid to understand this although i have been looking for answer from books and online resources. Would appreciate if anyone of u can help explaining to me. thx.
Regards,
cy

Ooops.
Didn't read your whole reply.
But I'm not sure what you mean by "Often when it is,
the default implementation given is a no-op."Instead of public abstract void walk(); you do public void walk {} This is not necssarily a good idea though. By declaring it abstract, you force subclasses to impelement it. With the no-op (the empty, non-abstract method), subclasses don't have to do anything, and they just have a useless, meaningless, probably incorrect walk method.
However, there are cases when it's useful. I forget the details of exactly which classes and methods, but for some of the Swing (or maybe AWT) stuff, the various listeners have to respond to a bunch of events. WindowListener might have 5 or 10 or 15 different events it listens to. The interface or abstract base class leaves them all abstract. It might be that your WindowListener implementation really only reacts to two of them. So you have to provide empty methods for all the rest. To make this more convenient, the API provides XxxAdapter classes. These implement all the event handling methods with no-ops, and you can extend that class and just override the ones your Listener needs.

...is not abstract and does not override abstract method compare

Why am I getting the above compile error when I am very clearly overriding abstract method compare (ditto abstract method compareTo)? Here is my code -- which was presented 1.5 code and I'm trying to retrofit to 1.4 -- followed by the complete compile time error. Thanks in advance for your help (even though I'm sure this is an easy question for you experts):
import java.util.*;
   This program sorts a set of item by comparing
   their descriptions.
public class TreeSetTest
   public static void main(String[] args)
      SortedSet parts = new TreeSet();
      parts.add(new Item("Toaster", 1234));
      parts.add(new Item("Widget", 4562));
      parts.add(new Item("Modem", 9912));
      System.out.println(parts);
      SortedSet sortByDescription = new TreeSet(new
         Comparator()
            public int compare(Item a, Item b)   // LINE CAUSING THE ERROR
               String descrA = a.getDescription();
               String descrB = b.getDescription();
               return descrA.compareTo(descrB);
      sortByDescription.addAll(parts);
      System.out.println(sortByDescription);
   An item with a description and a part number.
class Item implements Comparable
      Constructs an item.
      @param aDescription the item's description
      @param aPartNumber the item's part number
   public Item(String aDescription, int aPartNumber)
      description = aDescription;
      partNumber = aPartNumber;
      Gets the description of this item.
      @return the description
   public String getDescription()
      return description;
   public String toString()
      return "[descripion=" + description
         + ", partNumber=" + partNumber + "]";
   public boolean equals(Object otherObject)
      if (this == otherObject) return true;
      if (otherObject == null) return false;
      if (getClass() != otherObject.getClass()) return false;
      Item other = (Item) otherObject;
      return description.equals(other.description)
         && partNumber == other.partNumber;
   public int hashCode()
      return 13 * description.hashCode() + 17 * partNumber;
   public int compareTo(Item other)   // OTHER LINE CAUSING THE ERROR
      return partNumber - other.partNumber;
   private String description;
   private int partNumber;
}Compiler error:
TreeSetTest.java:25: <anonymous TreeSetTest$1> is not abstract and does not over
ride abstract method compare(java.lang.Object,java.lang.Object) in java.util.Com
parator
            public int compare(Item a, Item b)
                       ^
TreeSetTest.java:41: Item is not abstract and does not override abstract method
compareTo(java.lang.Object) in java.lang.Comparable
class Item implements Comparable
^
2 errors

According to the book I'm reading, if you merely take
out the generic from the code, it should compile and
run in v1.4 (assuming, of course, that the class
exists in 1.4). I don't know what book you are reading but that's certainly incorrect or incomplete at least. I've manually retrofitted code to 1.4, and you'll be inserting casts as well as replacing type references with Object (or the erased type, to be more precise).
These interfaces do exist in 1.4, and
without the generics.Exactly. Which means compareTo takes an Object, and you should change your overriding method accordingly.
But this raises a new question: how does my 1.4
compiler know anything about generics? It doesn't and it can't. As the compiler is telling you, those interfaces expect Object. Think about it, you want to implement one interface which declares a method argument type of Object, in several classes, each with a different type. Obviously all of those are not valid overrides.

Abstract method which when implemented will have different parameters

Hello to all,
I have an assignment but not looking for someone to do it for me. I am only searching for a suggestion on how to do the following.
Imagine having an application that needs to provide an estimate of the rent for different buildings.
Basically I start with by having a class name Building. This class has an abstract method called estimateRent.
I then create two classes that extend the class Building which are named Apartment and House. Both need to have the method estimateRent.
However the problem is that the rent for the Apartment is calculated on the nights passed in the flat and the people in it, while the rent for the House is just calculated on a month bases.
This means the estimateRent method requires to have different parameters depending if it is implemented inside the Apartment class or the House class.
Now I only know of two options.
The first option is to not declare the estimateRent method as an abstract method inside the Building class and just implemented inside the Apartment and House with different parameters. I do not like this option since in the future if a new Building comes in then I would like to impose the fact that that object needs to have a calculate method.
The second option is to make the estimateRent method as abstract inside the Building class however takes a parameter of either a String array or else a Map. Then the estimateRent within the Apartment class would search for the elements tagged as nights and people, and the House class would only search for the elements tagged as months!
However do not know if there are any other, better ways on how to do this. I am using Java 1.4 however if you only have answers for Java 5.0 then please post them again since I always like to learn something new :)
Thank You for any comments.
tx

The implementation changes, yes.Yes that I could understand in the Strategy Pattern (in the document I read it was being compared with the Template Pattern).
Then you need to refactor your design.I tought about that, however if you read my first post you will notice that I have different criteria on which the costs need to be estimated. While the costs for a flat are estimated on the people staying in and nights slept there, the costs for the house are based only on the months stayed there regardless of the people living in. Now for me I feel that it is bad programming practice to create one method that can have all the parameters required for any scenario. I mean the following is NOT something I am going to do:
estimateCosts(int nights, int people, int months ... etc);
That's not a very elegant way of going about it.
What is the "Context" going to have?Yep I agree, but so far my limited brain has only come up with that! I am open to any other sugestion! always if i understand it first!
Basically the Context would better be named as Criteria and it would be an interface as follows:
interface Criteria{}
Then I would create two classes that implement the Criteria object as follows:
class AppartmentCriteria implements Criteria{
public Result estimateCosts(int nights, int people);
class HouseCriteria implements Criteria{
public Result estimateCosts(int months);
Now when I recieve the inputs, depending on the scenario the Criteria is typecasted and the correct parameters passed and we recieve the Result.
I feel the above sucks since I am not seeing it as an object oriented way of doing this out! Is there any other sugestions! The refactoring thing I am intrested in! however really I can not see how such a call to that method could be refectored!
Thank You,
tx.
PS: Sun has blocked my other account as well, and this time they did not even send me an email to confirm that I was registered successfuully :( Is there someone I can contact on this? I guess next time I will reply with tx53m :)

Parent constructor calls abstract method

Hi everybody!
I'm wondering if there is something wrong with java or if the idea is just too ill?
Anyway, I think it would be great if this hierachy would work...
Two classes A and B.
Class A defines an astract method.
In A's constructor this abstract method is called.
Class B extends A and provides an implementation for the abstract method in A.
Class B also defines a member variable that is set in B's implementation of the abstract method.
In class' B constructor the parent constructor A() is called.
example:
public abstract class A {
public A() {
    createComponents();
public abstract void createComponents();
public class B extends A {
private String string = null;
public B() {
    super();
    System.out.println("B::B() " + string);
public void createComponents() {
    System.out.println("B::createComponents() begin");
    string = new String("test");
    System.out.println("B::createComponents() " + string);
public void describe() {
    System.out.println("B::describe() " + string);
public static void main(String[] args) {
    B b = new B();
    b.describe();
}running the code above produces the following output:
B::createComponents() begin
B::createComponents() test
B::B() null
B::describe() null
why is the string member variable null in B's constructor??
thanks in advance
Peter Bachl
Polytechnic University of Upper Austria, Hagenberg
[email protected]

The answer is that the call of the super-constructor
is allways done before the initialization
of the member variable. That's all and that's the
normal behavior.
order :
- initialization of static variables
- call to the super-constructor
- initialization of the instance variables
- execution of the constructor
Since this is the advanced forum it is relevant to point out that that is not exactly true.
There is a step in java that 'initializes' member variables before any constructors are called, super or other wise.
From the JLS 12.5...
Otherwise, all the instance variables in the new object, including those declared in superclasses, are initialized to their default values (4.5.5)
Using the following code as an example
class MyClass
     int i1;
     int i2 = 1;
.When creating an instance of the above there will be three 'initializations'
// Part of object creation...
i1 = 0; // The default value
i2 = 0; // The default value
// Part of construction...after super ctors called.
i2 = 1; // The variable initializer (see step 4 of JLS 12.5)
Unfortunately the descriptions are rather similar and so confusion can result as to when the assignment actually occurs.

Why am i able to use abstract methods id they aren't yet implemented?

For example, why i can use this [http://docs.oracle.com/javase/7/docs/api/java/nio/CharBuffer.html#slice] if this is abstract?
Edited by: 947971 on 13-set-2012 10.38

947971 wrote:
Yes, but if CharBuffer has a method declared:
public abstract CharBuffer slice()So i can't use the method slice() because it's not implemented.
And why , indeed, i'm able to use it?Because it is implemented by the actual class being used. You can't instantiate abstract classes, so there is a subclass of CharBuffer which does implement the method.
If you take the interface Comparable, you see that it has an (implicitly)abstract method compareTo. A class that implements Comparable is Integer, so you can easily write:
Comparable<Integer> i = new Integer(100);
i.compareTo(new Integer(55));

About abstract method

Hi, there are many abstract methods In the abstract java.awt.Graphics class. when I write a class extends Component(for example JPanel), override the paint(Graphics g) method, then I can invoke the abstract methods in the Graphics class to draw in my Component.
So I think there is a class extends the Grahpics class, but is secret to us. and the JDK designer how to design these class structor?
Thanks a lot,
Regards.

The reason that why most of the methods of the Graphics class are abstract is because to have an implementation for them, the underlying platform must be used, for example: g.drawLine(0,0,100,100) would on Linux end up on the native side making the call:
XDrawLine(display,drawable,gc,0,0,100,100);whereas on Windows it would be something else. There is not platform independent way to draw on the screen.
Tuomas Rinta

Can abstract method be overridden

"An abstract method can be overridden by an abstract method"
If an abstract method does not have any implementation, then what does one mean by overriding an abstract class in the subclass. Any code to show this will be of better understanding.
Thanks..

As yawmark demonstrated it can be use to to increase visibilty but it can also be used to reduce exception declarations.
Example:
abstract class A
abstract void f() throws java.io.IOException, java.sql.SQLException;
abstract class B extends A
abstract void f() throws java.net.SocketException;
}

Abstract methods probe!!!!!!

HI,
Please help me,
I would like to make changeSize abstract
Problem is subclass Circle AND Triangle
where Circle requiers only one parameter (radius)
and Triangle (two height & width)
abstract public void changeSize(int newSize);
Thanks //jF

I suspect something's severly wrong here ... although
you unify the parameter
passing (using double[]s) if feel (I'm psychic
remember?) that you're still violating
the LSP. IMHO resizing using one parameter versus
resizing using two parameters
are two different things and can't be unified using
polymorphism (the abstract method
in the base class).
Maybe there should be two abstract resize methods
in the base class. All
subclasses are to decide for themselves what to do
given any of the two ...The basic problem is that circles and triangles don't have too much in common to model a good inheritance tree...

"Abstract" method in a non-abstract class

Hi all.
I have a class "SuperClass" from which other class are extended...
I'd like to "force" some methods (method1(), method2, ...) to be implemented in the inherited classes.
I know I can accomplish this just implementing the superclass method body in order to throw an exception when it's directly called:
void method1(){
throw new UnsupportedOperationException();
}...but I was wondering if there's another (better) way...
It's like I would like to declare some abstract methods in a non-abstract class...
Any ideas?

The superclass just models the information held by
the subclasses.
The information is taken from the database, by
accessing the proper table (one for each subclass).??
What do you mean by "models the information"?
You should use inheritance (of implementation) only when the class satisfies the following criteria:
1) "Is a special kind of," not "is a role played by a";
2) Never needs to transmute to be an object in some other class;
3) Extends rather than overrides or nullifies superclass;
4) Does not subclass what is merely a utility class (useful functionality you'd like to reuse); and
5) Within PD: expresses special kinds of roles, transactions, or things.
Why are you trying to force these mystery methodsfrom the superclass?
It's not mandatory for me to do it... I 'd see it
just like a further way to check that the subclasses
implements these methods, as they have to do.That's not a good idea. If the superclass has no relation to the database, it shouldn't contain methods (abstract or otherwise) related to database transactions.
The subclasses are the classes that handle db
transaction.
They are designed as a binding to a db table.And how is the superclass designed to handle db transactions? My guess (based on your description) is that it isn't. That should tell you right away that the subclasses should not extend your superclass.

Abstract method called in an abstract class

Hello,
I am writing some code that I'd like to be as generic as possible.
I created an abstract class called Chromozome. This abstract class has a protected abstract method called initialize().
I also created an abstract class called Algorithm which contains a protected ArrayList<Chromozome>.
I would like to create a non abstract method (called initializePopulation()) which would create instances of Chromozome, call their method initialize() and full the ArrayList with them.
In a practical matter, only subclass of Algorithm will be used, using an ArrayList of a subclass of Chromozome implementing their own version of initialize.
I have been thinking of that and concluded it was impossible to do. But I'd like to ask more talented peaple before forgetting it !
Thanks,
Vincent

Ok, let's it is not impossible, juste that I had no idea of how doing it :-)
The difficulty is that Algorithm will never have to deal with Chromozome itself, but always with subclass of Chromozome. This is usually not an issue, but in that case, Algorithm is required to create instances of the desired subclass of Chromozome, but without knowing in advance wich subclass will be used (I hope what I say makes any sense).
Actually I may have found a way in the meantime, but maybe not the best one.
I created in Algorithm an abstract method :
protected abstract Chromozome createChromozome()The method initializePopulation will call createChromozome instead of calling directly the constructor and the initialize() method of Chromozome.
Then subclass of Algorithm will implement the method createChromozome using the desired subclass of Chromozome.

Abstract method versus static and non-static methods

For my own curiosity, what is an abstract method as opposed to static or non-static method?
Thanks

>
Following this logic, is this why the "public static
void main" 0r "Main" method always has to be used
before can application can be run: because it belongs
to the class (class file)?
Yes! Obviously, when Java starts up, there are no instances around, so the initial method has to be a static (i.e. class) one. The name main comes from Java's close association with C.
RObin

Non-abstract methods in a Abstract class

Similar Messages

Maybe you are looking for