Object-Oriented Programming in Java

Study Notes

Classes and Objects:
- A class is a blueprint or template that defines the properties and behavior of an object.
- An object is an instance of a class, and has its own set of attributes (data) and methods (functions).
Inheritance:
- Inheritance is a mechanism where a new class (sub-class) can inherit the properties and behavior of an existing class (super-class).
- The sub-class inherits all the fields and methods of the super-class and can also add new fields and methods or override the ones inherited from the super-class.
Polymorphism:
- Polymorphism is the ability of an object to take on multiple forms.
- This can be achieved through method overriding or method overloading.
- Method overriding is when a sub-class provides a different implementation of a method already defined in its super-class.
- Method overloading is when multiple methods with the same name can be defined with different parameter lists.
Abstraction:
- Abstraction is the concept of showing only the necessary information to the outside world while hiding the internal details.
- In Java, abstraction is achieved through abstract classes and interfaces.
Encapsulation:
- Encapsulation is the concept of bundling data and methods that operate on that data within a single unit (class).
- In Java, encapsulation is achieved through access modifiers (public, private, protected) and getters/setters.

Single Responsibility Principle (SRP):
- A class should have only one reason to change.
- A class should have only one responsibility or single purpose.
Open-Closed Principle:
- A class should be open for extension but closed for modification.
- A class should be able to add new functionality without modifying its existing code.
Liskov Substitution Principle:
- A sub-class should be able to substitute its super-class.
- A sub-class should be able to be used in place of its super-class without affecting the correctness of the program.

Code Reusability:
- OOP allows for code reuse through inheritance and polymorphism.
- Code reuse reduces the amount of code that needs to be written and maintained.
Modularity:
- OOP promotes modularity by breaking down a large program into smaller, independent modules (classes).
- Modularity makes it easier to develop, test, and maintain a program.
Easier Maintenance:
- OOP makes it easier to maintain a program by allowing for changes to be made at a single point without affecting the entire program.
- OOP promotes loose coupling between classes, making it easier to modify one class without affecting others.

Classes and Objects:
- Classes define properties and behavior of objects
- Objects are instances of classes with own attributes and methods
Inheritance:
- Mechanism where sub-class inherits properties and behavior of super-class
- Sub-class can add new fields and methods or override inherited ones
Polymorphism:
- Ability of object to take on multiple forms through method overriding or overloading
- Overriding: sub-class provides different implementation of method already defined in super-class
- Overloading: multiple methods with same name defined with different parameter lists
Abstraction:
- Concept of showing only necessary information to outside world while hiding internal details
- Achieved through abstract classes and interfaces in Java
Encapsulation:
- Concept of bundling data and methods that operate on that data within a single unit (class)
- Achieved through access modifiers (public, private, protected) and getters/setters in Java

Single Responsibility Principle (SRP):
- Class should have only one reason to change
- Class should have only one responsibility or single purpose
Open-Closed Principle:
- Class should be open for extension but closed for modification
- Class should be able to add new functionality without modifying existing code
Liskov Substitution Principle:
- Sub-class should be able to substitute its super-class
- Sub-class should be able to be used in place of its super-class without affecting program correctness

Code Reusability:
- OOP allows for code reuse through inheritance and polymorphism
- Code reuse reduces amount of code to be written and maintained
Modularity:
- OOP promotes modularity by breaking down large program into smaller, independent modules (classes)
- Modularity makes it easier to develop, test, and maintain a program
Easier Maintenance:
- OOP makes it easier to maintain a program by allowing for changes at a single point
- OOP promotes loose coupling between classes, making it easier to modify one class without affecting others