Encapsulation combines data and methods that operate on that data within a single unit (class) and restricts access to internal details. Benefits include: 1) Better control over data access and modification, 2) Ability to change implementation without affecting code using the class, 3) Prevention of unauthorized access, 4) Support for validation when setting values. Implemented using private fields with public getter/setter methods.
The Liskov Substitution Principle states that objects of a superclass should be replaceable with objects of its subclasses without affecting program correctness. In Java, this means subclass methods should: accept parameters of same/wider types, return same/narrower types, throw same/fewer exceptions, and maintain superclass invariants. Violations indicate poor inheritance hierarchy design.
Object cloning creates a copy of an object using the clone() method from Object class. Classes must implement Cloneable interface and override clone(). Shallow cloning copies object references, while deep cloning creates new instances of referenced objects. Considerations include: handling circular references, maintaining invariants, and dealing with final fields. Alternative approaches include copy constructors or static factory methods.
The instanceof operator checks if an object is an instance of a class, superclass, or interface. It returns true for any class in the inheritance chain or implemented interfaces. Since Java 16, pattern matching with instanceof allows direct casting and variable declaration. Useful for type-safe downcasting but overuse can indicate poor design or violation of polymorphism principles.
Constructors initialize object state during creation. In inheritance, superclass constructors are called before subclass constructors. If no constructor is defined, Java provides default no-arg constructor. Constructor chaining using this() and super() must follow specific rules: can't call both in same constructor, must be first statement. Proper constructor design is crucial for object initialization and invariant maintenance.
SOLID principles are: Single Responsibility (classes have one reason to change), Open-Closed (open for extension, closed for modification), Liskov Substitution (subtypes must be substitutable), Interface Segregation (clients shouldn't depend on unused methods), Dependency Inversion (depend on abstractions). Implementation involves proper interface design, inheritance hierarchies, and dependency management.
The four main principles are: 1) Encapsulation: implemented through access modifiers (private, protected, public) and getter/setter methods, 2) Inheritance: achieved using 'extends' keyword for class inheritance and 'implements' for interfaces, 3) Polymorphism: supported through method overriding and method overloading, 4) Abstraction: implemented using abstract classes and interfaces.
Abstract classes can have both abstract and concrete methods, instance variables, constructors, and can provide default method implementations. Interfaces (before Java 8) could only have abstract methods and constants. Since Java 8, interfaces can have default and static methods, and since Java 9, private methods. A class can implement multiple interfaces but extend only one abstract class.
The 'super' keyword refers to the parent class object. It's used to: 1) Call parent class constructor (super()), 2) Access parent class methods when overridden in child class (super.methodName()), 3) Access parent class fields when hidden by child class fields. It must be the first statement in constructor if used for constructor calling.
Composition creates a 'has-a' relationship where one class contains objects of another class. Inheritance creates an 'is-a' relationship where one class is a specialized version of another. Composition is preferred when you want to reuse code without creating tight coupling, more flexible for runtime behavior changes, and follows 'favor composition over inheritance' principle. Inheritance is appropriate when subclass is truly a specialized version of superclass.
Java supports four types of inner classes: 1) Regular inner classes (non-static nested classes) with access to outer class members, 2) Static nested classes without outer class instance access, 3) Local classes defined in methods, 4) Anonymous classes for one-time use. Inner classes can access private members of outer class and are useful for encapsulation and callback implementations.
Method dispatch determines which method implementation to call. For overloaded methods, selection is based on compile-time types of arguments (static dispatch). For overridden methods, selection is based on runtime type of object (dynamic dispatch). Understanding this is crucial for polymorphic behavior and avoiding subtle bugs with method resolution.
Abstract methods in interfaces declare method signatures without implementation, requiring implementing classes to provide implementation. Default methods (Java 8+) provide default implementation in interfaces, allowing interface evolution without breaking existing implementations. Default methods can be overridden, and conflicts must be resolved when implementing multiple interfaces.
Method binding is the process of linking a method call to its definition. Static binding (compile-time) occurs with private, static, and final methods where the compiler knows which method to call. Dynamic binding (runtime) occurs with virtual methods that can be overridden, where the actual object type determines which method is called. Dynamic binding enables polymorphism in Java.
Singleton ensures a class has only one instance and provides global access to it. Implemented using private constructor and static instance method. Limitations include: making unit testing difficult, potentially violating single responsibility principle, creating global state, and threading issues. Modern alternatives include dependency injection and proper object lifecycle management.
Cohesion measures how strongly related and focused the responsibilities of a class are. Coupling measures the degree of interdependence between classes. High cohesion (class does one thing well) and loose coupling (minimal dependencies) are desired. Achieved through proper encapsulation, interface-based design, and dependency injection. Important for maintainability and reusability.
Method overriding occurs when a subclass provides a specific implementation of a method declared in its superclass. The method must have the same signature and a return type that is covariant with the parent's return type. The @Override annotation helps catch errors by ensuring the method actually overrides a superclass method. It's a good practice to always use @Override when intending to override methods.
Marker interfaces are empty interfaces used to mark or tag a class as having certain properties (e.g., Serializable, Cloneable). They don't contain methods but provide runtime type information through instanceof operator. While annotations now provide similar functionality, marker interfaces have advantages: compile-time type checking and the ability to create type hierarchies.
The diamond problem occurs in multiple inheritance when a class inherits from two classes that have a common ancestor, creating ambiguity about which version of inherited methods to use. Java avoids this by not supporting multiple class inheritance, only allowing multiple interface inheritance. With interfaces, the most specific default method implementation is used, or compilation fails if ambiguous.
Sealed classes (Java 17+) restrict which classes can inherit from them using 'permits' clause. They provide more control over class hierarchy, ensuring only intended subclasses exist. Subclasses must be declared 'final', 'sealed', or 'non-sealed'. Useful for domain modeling, API design, and pattern matching exhaustiveness checking.
