Dasar PBO Python #6 - Konsep Class Polymorphism

Summary

In this video, the concept of polymorphism in Object-Oriented Programming (OOP) is explored using Python. Polymorphism allows methods with the same name to behave differently depending on the class of the object calling them. Through the example of two employee classes, 'PegawaiKontrak' (Contract Employee) and 'PegawaiTetap' (Permanent Employee), the script demonstrates how a shared method, 'biodata', can print distinct outputs based on the object type. The video highlights the flexibility, reusability, and scalability that polymorphism offers in simplifying and optimizing code in OOP.

Takeaways

• 😀 Polymorphism is a concept in Object-Oriented Programming (OOP) where classes can have multiple forms or behaviors.
• 😀 The term 'polymorphism' comes from 'poly' meaning 'many' and 'morph' meaning 'forms'.
• 😀 Polymorphism is not only applicable to classes but is also present in Python through functions and methods.
• 😀 In OOP, polymorphism allows methods with the same name to perform different tasks based on the class context.
• 😀 The example shows two classes: 'ContractEmployee' and 'PermanentEmployee', both having the same 'biodata' method but with different behaviors.
• 😀 The 'ContractEmployee' class prints 'I am a contract employee', while the 'PermanentEmployee' class prints 'I am a permanent employee'.
• 😀 The principle of polymorphism allows for method overloading where methods with identical names can have different implementations.
• 😀 The 'biodata' method is called for different objects (ContractEmployee and PermanentEmployee), demonstrating polymorphism in action.
• 😀 Using polymorphism, you can loop through a collection of objects and call the same method on all of them, resulting in different outputs based on their class.
• 😀 Polymorphism enhances code flexibility, making it easier to manage and extend in future development.
• 😀 The video concludes by reinforcing that polymorphism is an important concept in OOP, promoting cleaner and more efficient coding practices.

Q & A

What is the concept of polymorphism in object-oriented programming (OOP)?

Polymorphism in OOP refers to the ability of different classes to have methods with the same name, but the methods can behave differently depending on the class type of the object calling the method. It allows for a flexible and reusable code structure.

What do the words 'poly' and 'morph' mean in the context of polymorphism?

'Poly' means 'many' and 'morph' means 'form' in Greek. When combined, 'polymorphism' means 'many forms', reflecting the concept that the same method name can have different implementations based on the class.

Can polymorphism be applied only to classes in Python?

No, polymorphism is not restricted to classes only. In Python, polymorphism can also be observed in functions, especially with built-in functions that behave differently depending on the context or argument types.

What is an example of polymorphism provided in the transcript?

An example given is the `biodata` method, which is defined in two different classes, `PegawaiKontrak` (contract employee) and `PegawaiTetap` (permanent employee). Both classes have a method named `biodata`, but it prints different messages depending on whether the object is from the 'contract' or 'permanent' class.

How does polymorphism benefit programming in terms of code efficiency?

Polymorphism helps to reduce code duplication by allowing a single method name to be used for multiple classes, even though the method's implementation may vary. This makes the code more maintainable, concise, and readable.

What is the difference between the `PegawaiKontrak` and `PegawaiTetap` classes?

The `PegawaiKontrak` class represents a contract employee, while the `PegawaiTetap` class represents a permanent employee. Both classes contain a `biodata` method, but the output of the method differs based on the class: one prints 'Saya pegawai kontrak' (I am a contract employee) and the other prints 'Saya pegawai tetap' (I am a permanent employee).

How does polymorphism simplify looping through objects of different classes?

Polymorphism allows the use of the same method on objects of different classes, making it easier to loop through them in a list. For example, when looping through a list of `PegawaiKontrak` and `PegawaiTetap` objects, the same `biodata` method can be called on each object, and the correct behavior is automatically executed depending on the object's class.

What would happen if two methods with the same name are defined in different classes in Python?

If two methods with the same name are defined in different classes, Python will not raise an error. When the method is called on an object, Python will execute the version of the method that corresponds to the object's class. This behavior demonstrates polymorphism.

What role does inheritance play in polymorphism in object-oriented programming?

Inheritance allows one class to inherit properties and methods from another class, making polymorphism possible. In the example given, `PegawaiKontrak` and `PegawaiTetap` could both inherit from a common superclass (e.g., `Pegawai` or 'Employee'), and their individual implementations of the `biodata` method would still demonstrate polymorphism.

Why is the use of polymorphism considered a good practice in object-oriented design?

Polymorphism is considered a good practice because it allows for more flexible and scalable code. It enables objects of different types to be treated in a unified way, reducing the need for condition-based code and making it easier to extend the program with new classes and methods without disrupting existing code.