1. Access Control Modifiers: These limit how members (attributes and methods) of a class can be accessed from outside the class. Common modifiers include:
* Public: Members are accessible from anywhere.
* Private: Members are only accessible from within the class itself. This enforces encapsulation and data hiding.
* Protected: Members are accessible from within the class and its subclasses (inherited classes).
* Internal (C#), Package-private (Java): Members are accessible only within the same package or namespace.
Example (Python - using naming conventions to simulate access control):
```python
class MyClass:
def __init__(self, value):
self._protected_attribute = value # Protected attribute (convention)
self.__private_attribute = value * 2 # Private attribute (name mangling)
def public_method(self):
print("Public method accessed")
def _protected_method(self): # Protected method (convention)
print("Protected method accessed")
def __private_method(self): # Private method (name mangling)
print("Private method accessed")
obj = MyClass(5)
print(obj._protected_attribute) # Accessing protected attribute (works, but discouraged)
obj.public_method()
obj._protected_method() # Accessing protected method (works, but discouraged)
#print(obj.__private_attribute) # Accessing private attribute (fails)
#obj.__private_method() # Accessing private method (fails)
#Name mangling allows access to the private attribute through the following but should be avoided:
print(obj._MyClass__private_attribute)
obj._MyClass__private_method()
```
2. Methods: Methods define the actions a class can perform. Well-designed methods control the manipulation of the class's internal state.
3. Encapsulation: Bundling data (attributes) and methods that operate on that data within a class. This protects the internal state from external modification and misuse. Access control modifiers are crucial for encapsulation.
4. Inheritance: Creating new classes (subclasses) based on existing classes (superclasses). Subclasses can inherit attributes and methods, and override or extend their behavior. This allows for controlled modification and extension of functionality.
5. Polymorphism: The ability of objects of different classes to respond to the same method call in their own specific way. This provides flexibility and extensibility.
6. Composition: Creating a class by combining instances of other classes. This allows for building complex objects from simpler ones, promoting code reuse and better organization.
7. Exception Handling: Using `try...except` (or similar) blocks to handle potential errors within class methods. This prevents unexpected crashes and provides graceful error recovery.
8. Static Methods and Class Methods: These methods are associated with the class itself, not specific instances. They can be used for utility functions related to the class or for managing class-level state.
Example (Python):
```python
class Dog:
def __init__(self, name, breed):
self.name = name
self._breed = breed # protected attribute
def bark(self):
print("Woof!")
def get_breed(self): # controlled access to the breed attribute
return self._breed
def set_breed(self, new_breed): # controlled modification of the breed attribute
if isinstance(new_breed, str) and len(new_breed) > 0:
self._breed = new_breed
else:
raise ValueError("Invalid breed name")
my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.get_breed()) # Accessing breed through a getter method
my_dog.set_breed("Labrador") # Modifying breed through a setter method
print(my_dog.get_breed())
#my_dog._breed = "Invalid Breed" # Direct modification is not ideal and might be prevented with __slots__
```
By combining these techniques, you effectively control a class's behavior, protect its internal state, and promote code reusability and maintainability. The specific approach depends on the programming language and the complexity of the class.