Why abstract classes

Pals,
Abstract classes help us in abstracting common code. The same can be achieved by using a plain java class with static methods and extending them. What extra does this abstract keyword provides

Thanks fro the reply , but still im confused ,
partial implementations can also be done using the
Plain class (say class A)and having a non static
method in it (say methA(). Another class can can
extend this class A and use / override this(methA())
partial implementation of class A. I googled but
couldnt find an explaining answerIn the JDK that you downloaded is src.zip. Unzip it. Look at the source code for some of the abstract classes and the concrete classes that extend them.
For example, in List implementations, how you implement the add method is very much dependent on how the list is implemented. It's very different for a LinkedList vs. an ArrayList. It's highly dependent on the data structure that holds the list's elments. There's no reasonable way to implement it in the base class, so it's abstract.
The addAll method, on the other hand, can be implemented completely in terms of other methods and is not dependent on the implementation details. You simply iterate over the collection that's passed in as an arg, and for each of its elements, you call this list's add() method. So addAll can be implemented in the base class--all subclasses can use the same implementation.

Similar Messages

Abt Abstract Class

Hi,
Why Abstract classes have constructors
We cant create instance of Abstract Class so when these constructors are called.
Thanks in advance
Amar

We cant create instance of Abstract Class so
Class so when these constructors are called.IIRC, you can create an instance of the non-abstract subclass which extends the abstract class. When you invoke the constructor of the subclass, it calls the constructor of the superclass too. The constructor of the abstract class might be needed to initialize something, for example!
BTW, don't write "abt".. it's irritating! And post such questions on Java Programming forum.
xH4x0r

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

Why cannot create instance to an abstract class?

Dear Developers....
abstract class can create be its own constructor but why they didn't create object

We cann't create an object for abstract class
because they have abstract methods which depends on
its subclass for its implementation. if it is
possible to create the object for abstract class
means then you can call a method which has no
implementation(abstract methods) which is a illegal
one thats what the ruleWhat about classes with no abstract members?
public abstract class A {}No danger of accessing anything illegal here.
The rule is far more simple. By declaring a class as abstract, the creator defines that no instances of this class may exist. Period. If you could create instances, the class wouldn't be abstract anymore, per definition. It's like asking why a green light doesn't shine red. If it would, it wouldn't be green anymore.

Why use abstract classes?

Why should I use abstract classes instead of a regular class with empty method bodies? Just better design? Is there some logical or performance based reason?

Why should I use abstract classes instead of aregular
class with empty method bodies? Just better design?Is
there some logical or performance based reason?Because it describes what you're doing.
If you define a "regular" class with empty message
bodies, everyone who looks at it will say "WTF is he
trying to do" or, if they're charitable, "Look,
Harvey, someone who's trying to make Java look just
like C++!".
sigh Maybe answers like THIS are why people keep asking the same question.
Here's a couple things an abstract class does that a "regular" class with empty methods bodies doesn't:
1) An abstract class cannot be instantiated.
2) An abstract class forces it's abstract methods to be implemented.
If you were to extend a non-abstract class with empty method bodies, you wouldn't have to override the methods... you could just leave them empty. An abstract class forces it.
There's a lot more reasons... those are a couple obvious ones.

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.

Why interfaces why not abstract classes?

why they are using interfaces concept in JDBC or struts2.0 why not abstract classes?
thanks in advance.

user5287726 wrote:
jverd wrote:
user5287726 wrote:
Interfaces are more flexible. For certain definitions of flexible, yes, but not for others.
A Java class can only inherit one class, but it can implement multiple interfaces.Which has absolutely nothing to do with why JDBC declares interfaces rather than abstract classes.How does your post even attempt to answer the OP's question?OP asked: "why they are using interfaces concept in JDBC or struts2.0 why not abstract classes?" I'm pointing out that your post does not address the question asked. And of course your answer is wrong anyway.
As for addressing the OP's question, I did that in my first response.

Why a nested class can instantiate an abstract class?

Hi people!
I'm studying for a SCJP 6, and i encountered this question that i can figure it out but i don't find any official information of my guess.
I have the following code:
public class W7TESTOQ2 {
    public static void main(String[] args) {
       // dodo dodo1 = new dodo();
        dodo dodo2 =new dodo(){public String get(){return "filan";}};
        dodo.brain b = dodo2.new brain(){public String get(){return "stored ";}};
        System.out.print(dodo2.get()+" ");
        System.out.println(b.get());
abstract class dodo
    public String get()
        return "poll";
    abstract class brain
        public abstract String get();
}I know that abstract classes cannot be instantiated but i see that in this example, with a nested anonymous class it does (dodo and brain classes). My guess is that declaring the nested class it makes a subclass of the abstract class and doing so it can be instantiated. But i can't find any documentation about this.
Does anybody know?
Really thanks in advance.
Regards,
Christian Vielma

cvielma wrote:
Another question about this. Why can't i declare a constructor in the nested class? (it gives me return type required)You cannot declare a constructor, because in one line you're declaring a new class (the anonymous inner class) as well as constructing an instance of it.
What you can do, however, is if the abstract class (or the superclass, in any case, it doesn't need to be abstract) defines several constructors, you can call them.
public abstract MyClass {
    public MyClass() {
        // Default do nothing constructor
    public MyClass(String s) {
        // Another constructor
// Elsewhere
MyClass myclass = new MyClass("Calling the string constructor") {
};But you can't define your own constructors in the anonymous inner class.
Also, since the class is anonymous, what would you name the constructor? :)
Edited by: Kayaman on 26.6.2010 22:37

Abstract classes: Why do they need constructors?

As we cannot instantiate an abstract class. Why does an abstract class need a constructor?.can anyone please help me out..Thnq in advance
OBELISK

import java.util.*;
import static java.lang.System.out;
interface LineItem{
    public int getCost();
abstract class AbstractLineItem implements LineItem{
protected String name;
AbstractLineItem(String name){
     this.name = name;
public String toString(){
    return this.name+" "+getCost();
public abstract int getCost();
class ProductItem extends AbstractLineItem{
   private int quantity, peritem;
   ProductItem(String name, int quantity, int peritem){
     super(quantity+" "+name);
     this.quantity = quantity;
     this.peritem = peritem;
   public int getCost(){
     return this.quantity*this.peritem;
class FlatFeeItem extends AbstractLineItem{
   private int fee;
   FlatFeeItem(String name, int fee){
     super(name);
     this.fee = fee;
   public int getCost(){
     return this.fee;
public class Test{
public static void main(String ... args){
    List<LineItem> items = new ArrayList<LineItem>();
    items.add(new ProductItem("Banana",6,1));
    items.add(new FlatFeeItem("Some boring thing or another",35));
    items.add(new ProductItem("Kiwi",3,3));
    for(LineItem item : items)
      out.println(item);
}

Why are we using Abstract class?

Why are we using Abstract class? What is specify use of Abstract class?

The way I understand it....and I may be wrong because
I am very new....is that by making the class abstract
you will add abstract methods to it. Those abstract
methods MUST be defined in in any subclass that
inherits from the abstract class thereby making the
abstract a template for subclasses.
If your animal class is abstract then you would need
an abstract method (Which is just siganture, no body)
of say "numberOfLegs". Then in your dog and cat
classes which extend animal you must define a
"numberOfLegs" method with appropriate code.it isn't mandatory for an abstract class to have abstract methods. if a class does have abstract methods, the class must be abstract. but the following is perfectly legal
public abstract class NoAbstractMethods {
public void doStuff() {
// do stuff
}a subclass of an abstract class can also be abstract, and as such need not implement any additional methods

Why Immediate and ultimate super class extends in one abstract class ?

What�s a need to extents the two super class in single class
public abstract class ProcessorServlet extends HttpServlet implements Servlet

What�s a need to extents the two super class in
single class
public abstract class ProcessorServlet extends
HttpServlet implements Servlet
Only one class is being extended. HttpServlet.
Servlet is an interface.
You may only extend ONE class. You may implement as many interfaces as you like (there is probably some limit but not worth worrying about).

Calling a method from an abstract class in a seperate class

I am trying to call the getID() method from the Chat class in the getIDs() method in the Outputter class. I would usually instantiate with a normal class but I know you cant instantiate the method when using abstract classes. I've been going over and over my theory and have just become more confused??
Package Chatroom
public abstract class Chat
   private String id;
   public String getID()
      return id;
   protected void setId(String s)
      id = s;
   public abstract void sendMessageToUser(String msg);
Package Chatroom
public class Outputter
public String[] getIDs()
     // This is where I get confused. I know you can't instantiate the object like:
        Chat users=new Chat();
        users.getID();
I have the two classes in the package and you need to that to be able to use a class' methods in another class.
Please help me :(

I have just looked over my program and realised my class names are not the most discriptive, so I have renamed them to give you a clearer picture.
package Chatroom
public abstract class Chatter
private String id;
public String getID()
return id;
protected void setId(String s)
id = s;
I am trying to slowly build a chatroom on my own. The Chatter class is a class that will be used to represent a single logged in user and the user is given an ID when he logs in through the setId and getID() methods.
package Chatroom;
import java.util.Vector;
public class Broadcaster
private Vector<Chatter> chatters = new Vector<Chatter>();
public String[] getIDs()
// code here
The Broadcaster class will keep a list of all logged-in users keeps a list of all the chats representing logged-in users, which it stores in a Vector.I am trying to use the getIDs() method to return an array of Strings comprising the IDs of all logged-in users, which is why im trying to use the getID() method from the Chat class.
I apologise if I come across as clueless, it's just I have been going through books for about 4 hours now and I have just totally lossed all my bearings

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.

"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 class extends other class?

What happens when a abstract class extends other class?
How can we use the abstract class late in other class?
Why do we need an abstract class that extends other class?
for example:-
public abstract class ABC extends EFG {
public class EFG{
private String name="";
private int rollno="";
private void setName(int name)
this.name=name;
private String getName()
return this.name;
}

shafiur wrote:
What happens when a abstract class extends other class?Nothing special. You have defined an abstract class.
How can we use the abstract class late in other class?Define "Late". What "other class"?
Why do we need an abstract class that extends other class?Because it can be useful to define one.

Why abstract classes

Similar Messages

Maybe you are looking for