What are the negative aspects of Java class Stack inheriting from Vector?

by

Effective Java 2nd Edition, Item 16: Favor composition over inheritance:

Inheritance is appropriate only in circumstances where the subclass really is a subtype of the superclass. In other words, a class B should only extend a class A only if an “is-a” relationship exists between the two classes. If you are tempted to have a class B extend a class A, ask yourself this question: Is every B really an A? If you cannot truthfully answer yes to this question, B should not extend A. If the answer is no, it is often the case that B should contain a private instance of A and expose a smaller and simpler API; A is not an essential part of B, merely a detail of its implementation.

There are a number of obvious violations of this principle in the Java platform libraries. For example, a stack is not a vector, so Stack should not extend Vector. Similarly, a property list is not a hash table, so Properties should not extend Hashtable. In both cases, composition would have been preferrable.

The book goes in greater detail, and combined with Item 17: Design and document for inheritance or else prohibit it, advises against overuse and abuse of inheritance in your design.

Here’s a simple example that shows the problem of Stack allowing un-Stack-like behavior:

    Stack<String> stack = new Stack<String>();
    stack.push("1");
    stack.push("2");
    stack.push("3");
    stack.insertElementAt("squeeze me in!", 1);
    while (!stack.isEmpty()) {
        System.out.println(stack.pop());
    }
    // prints "3", "2", "squeeze me in!", "1"

This is a gross violation of the stack abstract data type.

See also

More Related Contents:

  1. Why is Java Vector (and Stack) class considered obsolete or deprecated?
  2. Can't call method from class 1 in class 2 [closed]
  3. Implicit super constructor Event() is undefined [duplicate]
  4. Can’t get ArrayIndexOutOfBoundsException from Future and SwingWorker if thread starts Executor
  5. At runtime, find all classes in a Java application that extend a base class
  6. Why java classes do not inherit annotations from implemented interfaces?
  7. Calling a subclass method from superclass
  8. Java : If A extends B and B extends Object, is that multiple inheritance
  9. What is the main difference between Inheritance and Polymorphism?
  10. How should I have explained the difference between an Interface and an Abstract class?
  11. Method chaining + inheritance don’t play well together?
  12. Most efficient way to cast List to List
  13. Good reasons to prohibit inheritance in Java?
  14. Java dynamic binding and method overriding
  15. what is the Class object (java.lang.Class)?
  16. Stack overflows from deep recursion in Java?
  17. Access to private inherited fields via reflection in Java
  18. Is it possible to call subclasses’ methods on a superclass object?
  19. Why does the “protected” modifier in Java allow access to other classes in same package?
  20. How do Java method annotations work in conjunction with method overriding?
  21. Java/JAXB: Unmarshall Xml to specific subclass based on an attribute
  22. Hiding Fields in Java Inheritance
  23. Private methods in Inheritance
  24. Why does every object in Java implicitly extend java.lang.Object class?
  25. Java Inheritance – calling superclass method
  26. Java serialization of multidimensional array
  27. Java generic method inheritance and override rules
  28. Call a child class method from a parent class object
  29. Java: Use import or explicit package / class name?
  30. java constructor in class cannot be applied to given types

Leave a Comment