Interview Questions
The four fundamental principles are: 1) Encapsulation (bundling data and methods that operate on that data within a single unit), 2) Inheritance (creating new classes that are built upon existing classes), 3) Polymorphism (ability of objects to take on multiple forms), and 4) Abstraction (hiding complex implementation details and showing only functionality).
public members are accessible from anywhere, private members are only accessible within the declaring class, and protected members are accessible within the declaring class and its child classes. This helps in implementing encapsulation and controlling access to class members.
Method chaining is a technique where multiple methods are called on the same object in a single line. It's achieved by returning $this from methods, allowing subsequent method calls. For example: $object->method1()->method2()->method3(). This creates more readable and fluent interfaces.
A constructor (__construct) is automatically called when an object is created and is used to initialize object properties. A destructor (__destruct) is called when an object is destroyed or the script ends, used for cleanup tasks. Both are magic methods in PHP.
Dependency injection is a design pattern where objects are passed into a class through constructor or setter methods rather than being created inside the class. This reduces coupling, improves testability, and makes the code more maintainable by implementing inversion of control.
Static methods belong to the class itself and can be called without creating an instance of the class. They cannot access non-static properties/methods using $this. Non-static methods belong to class instances and can access all class members. Static methods are called using the scope resolution operator (::).
Magic methods are special methods that override PHP's default behavior. Common ones include: __construct() (constructor), __destruct() (destructor), __get() (accessing inaccessible properties), __set() (writing to inaccessible properties), __call() (calling inaccessible methods), __toString() (string representation of object).
Composition is when a class contains instances of other classes as properties, while inheritance is when a class extends another class. Composition provides more flexibility and loose coupling ('has-a' relationship) compared to inheritance ('is-a' relationship). Composition is often preferred over inheritance for better maintainability.
Interfaces define a contract for classes by specifying which methods must be implemented. They promote loose coupling, enable polymorphism, and allow different classes to share a common contract. A class can implement multiple interfaces, unlike inheritance where a class can only extend one class.
Abstract classes can have both abstract and concrete methods, while interfaces can only declare method signatures. A class can implement multiple interfaces but extend only one abstract class. Abstract classes can have properties and constructor, while interfaces cannot.
Traits are mechanisms for code reuse in single inheritance languages like PHP. They allow you to define methods that can be used across multiple independent classes. Traits are useful when you need to share functionality between classes that don't share a common inheritance hierarchy.
Late static binding refers to a way of using the static keyword to reference the class that was initially called at runtime rather than the class in which the method is defined. It resolves the limitations of self:: by using static:: to refer to the runtime class.
Method overriding occurs when a child class provides a specific implementation for a method that is already defined in its parent class. The child's method must be defined with the same name and parameters. The parent method can be accessed using parent:: keyword.
The final keyword prevents child classes from overriding a method when used on methods, and prevents class inheritance when used on classes. It's used when you want to prevent further modification of classes or methods for security or design reasons.
Autoloading automatically loads PHP classes when they are used, eliminating the need for multiple include statements. It's implemented using spl_autoload_register() function. PSR-4 is the modern standard for autoloading, which maps namespace prefixes to directory structures.
Shallow cloning (default clone keyword) creates a new object with copied scalar properties but maintains references to objects. Deep cloning involves implementing __clone() method to also clone nested objects. Deep cloning ensures complete independence between original and cloned objects.
Anonymous classes are classes without names, defined on-the-fly. They are useful when you need a simple, one-off object that implements an interface or extends a class. They're commonly used in testing or when you need quick object creation without formal class definition.
Property type declarations allow you to specify the type of class properties. They can be scalar types, arrays, classes, interfaces, or nullable types using ?. They ensure type safety at the property level and help catch type-related errors early.
Constructor property promotion is a shorthand syntax that allows declaring and initializing class properties directly in the constructor parameter list. It reduces boilerplate code by combining property declaration, constructor parameter, and property assignment in one line.
The Observer pattern is a behavioral design pattern where objects (observers) automatically notify their dependents (subscribers) about state changes. PHP provides SplSubject and SplObserver interfaces for implementation. It's commonly used for event handling and maintaining consistency between related objects.
PHP doesn't support traditional method overloading, but it can be simulated using the __call() magic method. This method handles calls to inaccessible or undefined methods, allowing you to implement different behaviors based on the number or types of arguments passed.
The instanceof operator is used to determine if an object is an instance of a specific class, implements an interface, or is an instance of a class that extends another class. It returns true if the object is of the specified type, false otherwise.
Singleton pattern ensures a class has only one instance. It's implemented by making the constructor private, creating a private static instance property, and a public static method to get the instance. The method creates the instance if it doesn't exist or returns the existing one.
Value objects are immutable objects that represent a value rather than an entity. They are used when you need to encapsulate values that have their own business rules and validation. Common examples include Date, Money, or Email value objects.
PHP doesn't support multiple inheritance directly, but it can be achieved through interfaces and traits. A class can implement multiple interfaces and use multiple traits. Traits provide actual method implementations, while interfaces define contracts.
Static binding (self::) refers to the class where the method is defined, while late static binding (static::) refers to the class that was initially called at runtime. Late static binding allows for more flexible inheritance and method calls in static contexts.
Named arguments allow you to pass values to a function by specifying the parameter name, regardless of their order. In OOP, this improves code readability, especially with multiple optional parameters, and makes constructor calls and method invocations more explicit and maintainable.
The __toString() magic method allows you to define how an object should be represented as a string. It's automatically called when an object is used in a string context. It must return a string and can be useful for debugging or displaying object information.