Abstract Classes and Methods Quiz

Study Notes

An abstract class is declared as such and may include abstract methods.
It serves as a blueprint for other classes, defining structure but not allowing instantiation.

Abstract classes cannot be instantiated because they represent abstract concepts (e.g., a generic vehicle).
Instantiation requires a concrete subclass that provides specific functionality.

An abstract method lacks implementation; it is declared with a semicolon, signifying that subclasses must provide the body.
Example: abstract void moveTo(double deltaX, double deltaY);

When subclassing an abstract class, all abstract methods must typically be implemented.
If a subclass does not implement all abstract methods, it must also be marked as abstract.

Both abstract classes and interfaces cannot be instantiated.
They can contain a blend of declared methods, some with and some without implementations.

Abstract Class:
- Can have non-static, non-final fields.
- Can define access modifiers for methods (public, protected, private).
- Can extend only one class, abstract or not.
Interface:
- Fields are implicitly public, static, and final.
- Methods are public; default methods can be defined.
- Can implement multiple interfaces.

Abstract Class:
- Ideal for sharing code among related classes.
- Useful when expecting related classes to have common methods/fields, or require specific access modifiers.
- Allows declaration of non-static, non-final fields to manage object state.
Interface:
- Suitable for unrelated classes to share a contract (e.g., Comparable, Cloneable).
- Focused on defining behavior without dictating implementations.
- Enables multiple inheritance of type.

Abstract Class: AbstractMap, part of the Collections Framework.
AbstractMap Subclasses: Include HashMap, TreeMap, and ConcurrentHashMap.
Interface Examples: Serialization, Cloneable, and Map, which are implemented by HashMap.

Any class implementing an interface must provide implementations for all declared methods in that interface.

An abstract class can implement an interface partially, leaving out one or more methods.
Example structure:
- abstract class X implements Y { /* partial implementation */ }
- class XX extends X { /* implements remaining methods of Y */ }

super: Used to invoke an overridden method from a superclass using super.method.

Inheritance is a mechanism where a new class derives properties and behaviors from an existing class, facilitating code reuse.
Polymorphism allows for methods to be used in different ways depending on the object calling them, enhancing flexibility in programming.