Salesforce OOP: Inheritance & Interfaces
Uploaded by
Naresh ReddySalesforce OOP: Inheritance & Interfaces
Uploaded by
Naresh ReddyCommon questions
Powered by AIComposition can be used as an alternative to inheritance by creating objects from other classes to achieve functionality. Instead of 'Nov15_InheritanceChild' inheriting 'Nov15_InheritanceParent', it could include an instance of a class that provides the needed functionality (e.g., student details and account management). This promotes greater flexibility, as the composed objects' behaviors can be changed at runtime, and classes can be easily replaced or decorated with new features without modifying existing systems, preventing the tight coupling seen in inheritance .
The potential drawbacks of using inheritance include increased complexity and reduced flexibility. In the document, the dependency on a single parent class means any change in 'Nov15_InheritanceParent' affects 'Nov15_InheritanceChild'. Furthermore, tight coupling between base and derived classes can lead to a rigid class hierarchy, making it difficult to adapt the design for new requirements without significant changes. This could lead to potential issues in scalability and maintainability .
Access modifiers determine the visibility of class members to other classes and are crucial in inheritance for encapsulation. In the document, public access modifier allows 'Nov15_InheritanceChild' to access 'studName', 'studBatchnumber', and associated methods from 'Nov15_InheritanceParent'. Proper use of these modifiers upholds encapsulation principles by allowing access to only necessary methods and properties, enhancing the integrity and security of the data within these objects .
In inheritance, constructors initialize object state and establish the necessary setup for instance variables. In the document's examples, when 'Nov15_InheritanceChild' is instantiated, its constructor is called, which in turn accesses the inherited attributes from 'Nov15_InheritanceParent'. The child’s constructor initializes 'mychildstd' using the inherited 'studName'. Constructors in inheritance ensure that the base class state is properly initialized before any specific behavior in the derived class is executed .
Inheritance in OOP allows a class, known as the child or derived class, to inherit attributes and behaviors (methods) from another class, known as the parent or base class. This promotes code reusability because you can create new functionalities or modify existing ones without altering the original code in the parent class. For example, in the provided class structure, 'Nov15_InheritanceChild' inherits properties like 'studName' and methods like 'myparentaccount()' from 'Nov15_InheritanceParent'. This allows the child class to use or override these properties and methods, demonstrated when 'Nov15_InheritanceChild' constructs its own account object 'accChild' using the inherited 'myparentaccount()' method .
Interfaces in OOP define a contract for classes, specifying methods that must be implemented without dictating how these methods should be implemented. This allows different classes to offer the same functionality while containing different internal implementations. In the document, the 'Nov15_Interface' is an example of this concept, defining a contract with methods 'start()' and 'execute()'. The class 'Nov15_IntefaceChild' implements this interface, providing its own implementations for these methods, hence allowing different classes to behave interchangeably at runtime by adhering to the same interface .
Method overriding allows a child class to provide a specific implementation of a method that is already defined in its parent class. This is beneficial for achieving polymorphism, allowing for dynamic method resolution and more flexible code. In the document, method overriding is shown in 'Nov15_InheritanceChild', which overrides 'prentStudentCreat()' from 'Nov15_InheritanceParent'. The child class changes the implementation to set different student details, such as changing the 'name' property to 'Mani' from 'Joshna', as illustrated when 'Nov15_InheritanceChild' and 'Nov15_InheritanceParent' are used polymorphically .
The 'virtual' keyword in inheritance structures is used to indicate that a method can be overridden in any derived class. It provides a baseline implementation which a derived class can choose to modify. In the document, 'Nov15_InheritanceParent' uses 'virtual' for the method 'prentStudentCreat()', indicating that derived classes such as 'Nov15_InheritanceChild' can provide an alternate implementation, thus facilitating polymorphic behavior .
Dynamic method dispatch is demonstrated through method overriding and polymorphic execution. In the document, an instance of 'Nov15_InheritanceChild' is referenced through a 'Nov15_InheritanceParent' type. When 'prentStudentCreat()' is called on this reference, the overridden method in 'Nov15_InheritanceChild' executes. This happens because, at runtime, the instance's actual class type determines which method implementation to invoke, a key feature of polymorphism .
Polymorphism in OOP allows objects of different classes to be treated as objects of a common superclass. It manifests in the examples through method overriding and the use of interface-based polymorphism. In the document, 'Nov15_InheritanceChild' overrides 'prentStudentCreat()', allowing it to modify behavior when accessed through a reference of type 'Nov15_InheritanceParent'. This is significant because it supports the implementation of flexible and maintainable code, where more generalized code is used to manipulate more specialized types as displayed by the creation and execution of 'Nov15_InheritanceChild' objects through a parent class type .