OOP

There are four levels. private limits a member to its declaring class; package-private (no keyword written) opens it to the same package; protected adds subclasses in any package; public opens it to everyone. Encapsulation means keeping fields private and exposing behaviour through methods, so a class can change its internals without breaking callers.

An abstract class can hold instance state, constructors, and partly-implemented methods, but a class extends only one, so it models an "is-a" relationship. An interface is a pure contract a class can implement many of, modelling a "can-do" capability; since Java 8 it may carry default and static methods, yet its fields are constants and it has no constructor or per-instance state.

A marker interface is an empty interface that declares no methods; implementing it simply tags a class with metadata. The JVM or a library then checks that type at runtime to decide behaviour. Serializable marks a class as safe to serialize, and Cloneable lets Object.clone() succeed. The class gains no methods — it only carries the tag.

Overloading means several methods share one name but differ in parameter lists; the compiler picks one by argument types, so it is resolved at compile time. Overriding means a subclass redefines a superclass method with the same signature; the JVM picks the version by the object's actual runtime type, so it is resolved at runtime via dynamic dispatch.

super references the immediate superclass from inside a subclass. super.method() calls the parent's version of an overridden method, and super.field reaches a hidden parent field. super(...) invokes a superclass constructor and must be the first statement in the subclass constructor; if omitted, the compiler inserts an implicit super() call to the no-arg parent constructor.

this is a reference to the current object on which an instance method or constructor runs. Its common use is disambiguation: this.name = name distinguishes a field from a same-named parameter that shadows it. The this(...) form chains to another constructor of the same class for code reuse and, like super(...), must be the first statement in the constructor.

Java nests classes four ways. An inner (non-static) class holds an implicit reference to its enclosing instance, so it can read the outer object's members directly. A static nested class has no such link and behaves like a top-level class scoped inside another. A local class is declared inside a method, and an anonymous class is a one-shot inner class defined and instantiated in a single expression.

default gives an interface method a body that every implementer inherits and may override — that is how Java 8 could add methods to published interfaces without breaking them. static methods belong to the interface itself, are called as Iface.of(...), and are not inherited. private methods, added in Java 9, are helpers that share code between default and static bodies and stay invisible to implementers.

Double-brace initialization is new HashSet<>() {{ add("a"); }}: the outer braces create an anonymous subclass, and the inner braces are that subclass's instance-initializer block running the calls. It is an anti-pattern — it emits an extra class file, cannot extend final classes, and the anonymous instance holds an implicit this$0 reference to the enclosing object, which can leak memory.

Cloneable declares no clone() — it only tells Object.clone() not to throw, and Object.clone() is protected and native, so every class must re-declare a public clone() and call super.clone(). The copy it produces bypasses constructors, is shallow (mutable fields stay shared), and cannot assign final fields. A copy constructor or static factory is the recommended alternative.

The diamond problem is the ambiguity when one type inherits the same member along two paths and the compiler cannot tell which to use. Java forbids extending more than one class, so state inheritance stays unambiguous. It does allow multiple interfaces, and when two supply a clashing default method the class must override it and pick a version explicitly via Interface.super.method().

No. A private method is invisible to subclasses, a final method is sealed against redefinition, and a static method belongs to the class, not an instance. A same-signature static method in a subclass does not override but hides the parent's: the call is resolved by the reference type at compile time, not the object's runtime type, so there is no polymorphism — unlike a true instance override.