Learn Object-Oriented Programming In 2 Days (Maruk Method)

*** INSTRUCTIONS ABOUT HOW TO STUDY THIS COURSE::

PABLO MARUK METHOD

0 - Write

                 You are going to copy the "definition" part of the lessons description to your notebook.

1 - Read

                 You are going to read the definition of each class in a loud voice.

2 - Listen
                 You are going to listen to the audio with the definitions everyday for 2 weeks (don't need full attention, just listen to it)

3 - Exercise

                 ***DO THE EXERCISES FROM THE EXERCISES LIST ATTACHED IN THIS LESSON. DO IT IN YOUR NOTEBOOK, COPY AND SOLVE IT ACCORDINGLY TO YOUR STUDIES PACE. DO EXERCISE 1 WHEN YOU STUDY LESSON 1, EXERCISE 2 WHEN YOU FINISH LESSON 2 AND SO ON.
Also do the flashcards training from the link below.

Tools:

Notebook - Dedicate one notebook only for this course, the definition and exercises.

Audios - Download all the audios if you wish. But there is a special one with all the definitions, use it!

Flashcards
               https://pablomaruk.com/apps/flashcards/     (this is the link for the flashcards to study it, the best way to memorize theory)

Videos
                 You are going to copy the "definition" part of the lessons description to your notebook.

Keywords

                 You are going to copy the Keywords to your notebook.

In this example:

- We define a class named `Car` with attributes (`brand`, `model`, and `year`) and a method (`displayInfo`) to display information about the car.

- In the `Main` class, we create an object `myCar` of the class `Car` using the `new` keyword.

- We set values for the attributes of `myCar`.

- Finally, we call the `displayInfo` method to print the information about the car.

This demonstrates the basic structure of a class (`Car`) and the creation and usage of an object (`myCar`) of that class in Java.

Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Person` with private attributes (`name` and `age`).

- Public methods (`getName`, `setName`, `getAge`, `setAge`) are provided to access and modify the private attributes. This is encapsulation, as the internal details of the class are hidden.

- In the `Main` class, we create an object `person1` of the class `Person`.

- We use the public methods to set and get the values of the private attributes.

- The validation logic inside the `setAge` method demonstrates the encapsulation of behavior, ensuring that the age cannot be set to a negative value.

This encapsulation ensures that the internal state of the `Person` object is controlled and validated through defined methods, providing a level of data integrity and security.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a base class named `Animal` with an attribute (`species`) and a method (`makeSound`).

- We create a subclass named `Dog` that extends the `Animal` class. The `Dog` class inherits the `species` attribute and the `makeSound` method from the `Animal` class.

- The `Dog` class introduces an additional attribute (`breed`) and overrides the `makeSound` method to provide a specific implementation for dogs.

- In the `Main` class, we create objects of both the base class (`Animal`) and the subclass (`Dog`).

- We demonstrate how the subclass inherits the attributes and methods from the base class, and how the overridden method in the subclass provides specific behavior.

This example illustrates the concept of inheritance, where a subclass inherits the properties and behaviors of a superclass, allowing for code reuse and the establishment of an "is-a" relationship.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a base class named `Shape` with a method (`calculateArea`) that provides a generic implementation for calculating the area of a shape.

- We create two subclasses, `Circle` and `Rectangle`, that extend from the `Shape` class.

- Each subclass overrides the `calculateArea` method to provide a specific implementation for calculating the area of a circle or rectangle.

- In the `Main` class, we create objects of both the `Circle` and `Rectangle` classes, but we declare them using the base class `Shape`.

- We use polymorphism to call the `calculateArea` method on these objects, and Java dynamically dispatches the method calls to the appropriate overridden methods in the subclasses.

This example illustrates polymorphism, where objects of different types (subclasses) can be treated as objects of the same type (base class), allowing for flexibility and extensibility in code design.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define an abstract class named `Shape` with an abstract method (`calculateArea`). Abstract methods have no implementation in the abstract class and must be implemented by concrete subclasses.

- We create two concrete subclasses, `Circle` and `Rectangle`, that extend from the abstract class `Shape`. Each subclass provides a specific implementation for the `calculateArea` method.

- In the `Main` class, we create objects of both the `Circle` and `Rectangle` classes, but we declare them using the abstract class `Shape`.

- The abstract class serves as a template for concrete classes, enforcing the presence of certain methods without specifying how they should be implemented.

This example illustrates abstraction, where the abstract class defines a common interface (in the form of abstract methods) that concrete subclasses must implement. This allows for a high-level view of the system, focusing on essential features without dealing with implementation details.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Person` with attributes (`name` and `age`) and a constructor.

- The constructor is a special method with the same name as the class, and it is invoked automatically when an object is created. It initializes the attributes with values provided during object creation.

- In the `Main` class, we create an object `person1` of the class `Person` using the constructor. We provide values for the `name` and `age` parameters during object creation.

- We call the `displayInfo` method to print the information about the person.

This example demonstrates the use of a constructor to initialize the state of an object during its creation. Constructors are essential for setting up the initial state of objects and are automatically called when objects are instantiated.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Calculator` with multiple overloaded methods named `add`.

- The `add` method is overloaded with different parameter lists. There is one version for adding two integers, another for adding three integers, and another for adding two doubles.

- In the `Main` class, we create an object `myCalculator` of the class `Calculator`.

- We call different overloaded versions of the `add` method, providing different numbers and types of parameters.

- The compiler determines the appropriate method to call based on the number and types of arguments passed.

This example demonstrates method overloading, where multiple methods in the same class have the same name but differ in the number or types of their parameters. Method overloading provides flexibility and improves code readability.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define an interface named `Drawable` with an abstract method (`draw`). Interfaces in Java define a contract for classes to implement.

- We create two classes, `Circle` and `Rectangle`, that implement the `Drawable` interface. Each class provides its own implementation for the `draw` method.

- In the `Main` class, we create objects of the `Circle` and `Rectangle` classes but declare them using the interface type `Drawable`.

- We call the `draw` method on these objects. The compiler allows this, as both classes implement the `Drawable` interface.

This example demonstrates the concept of an interface, where a set of methods is defined without providing the implementation. Classes that implement the interface must provide their own implementation for the interface methods. This promotes code flexibility and allows for the implementation of multiple interfaces by a single class.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We declare a package named "geometry" using the `package` keyword. This package will contain the `Circle` class.

- We define a class called `Circle` within the "geometry" package. The `Circle` class has attributes (`radius`), a constructor, and a method to calculate the area of the circle.

- The `Circle` class is declared as `public` so that it can be accessed from outside the "geometry" package.

Note: When creating packages, the file structure should reflect the package structure. In this example, the file should be saved in a directory named "geometry," and the file itself should be named "Circle.java."

This example demonstrates the use of a package to organize classes into a namespace. Packages help avoid naming conflicts and provide a clear structure to the codebase.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class called `Person` with attributes (`name`, `address`, `age`, `profession`) and a constructor.

- The `name` attribute is private, meaning it can only be accessed within the same class.

- The `address` attribute is package-private (default), meaning it can be accessed within the same package.

- The `age` attribute is protected, meaning it can be accessed within the same package and by subclasses.

- The `profession` attribute is public, meaning it can be accessed from any class.

This example demonstrates the use of access modifiers to control the visibility of class members. Access modifiers are crucial for encapsulation and defining the level of access to attributes and methods in Java.

Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class called `Engine` with a method `start` that simulates starting the engine.

- We define a class called `Car` that uses composition to include an `Engine` as an attribute.

- In the `Car` class constructor, we create an instance of the `Engine` and assign it to the `engine` attribute. This is an example of composition, where one class is composed of another class.

- The `Car` class has a method `start` that delegates the task of starting the car to the `Engine`'s `start` method.

This example illustrates the concept of composition, where one class contains an object of another class to reuse its functionality. Composition is an alternative to inheritance and provides flexibility in designing and building complex systems.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class called `Author` with an attribute `name`.

- We define a class called `Book` that uses aggregation to include an `Author` as an attribute.

- In the `Book` class constructor, an instance of the `Author` is passed as a parameter to associate an author with the book. This is an example of aggregation.

- The `Book` class has a method `displayInfo` to display information about the book and its author.

This example illustrates the concept of aggregation, where one class contains an object of another class to represent a "whole-part" relationship. Aggregation is a form of association that represents a weaker relationship compared to composition.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define an abstract class named `Shape` with an abstract method (`calculateArea`). Abstract classes can have abstract methods without providing an implementation.

- We create two concrete subclasses, `Circle` and `Rectangle`, that extend from the abstract class `Shape`. Each subclass provides its own implementation for the `calculateArea` method.

- In the `Main` class, we create objects of both the `Circle` and `Rectangle` classes but declare them using the abstract class `Shape`.

- The abstract class serves as a common interface, and concrete subclasses provide specific implementations for the abstract methods.

This example illustrates the concept of abstract classes, which are used to provide a common interface for a group of related classes while allowing each class to provide its own implementation for certain methods.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a final class named `FinalClass`. A final class cannot be extended, and no subclass can be created.

- The `name` attribute of the `FinalClass` is declared as `final`, meaning its value cannot be changed once initialized.

- The `displayInfo` method is also declared as `final`, indicating that it cannot be overridden by subclasses.

- In the `Main` class, we create an object of the final class `FinalClass` and demonstrate the use of a final method.

This example illustrates the concept of the `final` keyword, which can be applied to classes, methods, and variables. When applied to a class, it prevents the class from being subclassed. When applied to a method, it prevents the method from being overridden. When applied to a variable, it makes the variable a constant, and its value cannot be modified after initialization.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `MathOperations` with static methods `add` and `multiply`.

- Static methods belong to the class rather than instances of the class, and they can be called directly using the class name.

- In the `Main` class, we call the static methods `add` and `multiply` from the `MathOperations` class without creating an object of that class.

This example illustrates the concept of the `static` keyword, which is used to define members (methods and variables) that belong to the class rather than instances of the class. Static methods can be called without creating an object of the class, making them accessible at the class level.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Person` with attributes (`name` and `age`) and a constructor.

- In the constructor, we use the `this` keyword to distinguish between the instance variables (`this.name` and `this.age`) and the parameters (`name` and `age`).

- The `this` keyword is used to explicitly refer to the instance variables of the class, helping to disambiguate when there is a naming conflict between instance variables and method parameters.

- In the `displayInfo` method, we use the `this` keyword to refer to the instance variables while displaying information about the person.

This example demonstrates the use of the `this` keyword to reference instance variables and distinguish them from local variables or parameters within a class.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a base class named `Vehicle` with an attribute (`brand`) and a constructor.

- We define a subclass named `Car` that extends from `Vehicle` and has an additional attribute (`model`).

- In the `Car` class constructor, we use the `super` keyword to call the constructor of the superclass (`Vehicle`), providing the `brand` parameter.

- The `displayInfo` method in the `Car` class overrides the method in the superclass. Within the overridden method, we use the `super` keyword to call the method of the superclass (`displayInfo`) before adding specific information for the `Car` class.

This example demonstrates the use of the `super` keyword to access members (attributes and methods) of the superclass in a subclass.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a base class named `Animal` with a method `makeSound`.

- We create a subclass named `Dog` that extends from `Animal` and overrides the `makeSound` method with a specific implementation for dogs.

- In the `Main` class, we create objects of both the base class (`Animal`) and the subclass (`Dog`).

- We call the `makeSound` method on both objects. In the case of the `Dog` object, the overridden method in the subclass is invoked.

- The `Dog` class introduces an additional method `wagTail`, which is specific to dogs.

This example illustrates method overriding, where a subclass provides a specific implementation for a method that is already defined in its superclass. It allows a subclass to provide a more specialized behavior while still maintaining the polymorphic behavior through the use of a common interface.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Calculator` with multiple overloaded methods named `add`.

- The `add` method is overloaded with different parameter lists. There is one version for adding two integers, another for adding three integers, and another for adding two doubles.

- In the `Main` class, we create an object `myCalculator` of the class `Calculator`.

- We call different overloaded versions of the `add` method, providing different numbers and types of parameters.

- The compiler determines the appropriate method to call based on the number and types of arguments passed.

This example demonstrates method overloading, where multiple methods in the same class have the same name but differ in the number or types of their parameters. Method overloading provides flexibility and improves code readability.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/

In this example:

- We define a class named `Person` with private attributes (`name` and `age`) and public methods to encapsulate access to these attributes.

- The `setName` and `setAge` methods are used to set the values of private attributes with validation. They prevent invalid values from being assigned.

- The `getName` and `getAge` methods are used to retrieve the values of private attributes, promoting controlled access to the data.

- The `displayInfo` method is a public method that displays information about the person, demonstrating how the encapsulated data can be accessed and utilized.

This example illustrates the concept of encapsulation, where the internal details of a class (attributes) are hidden from the outside and can only be accessed through well-defined public methods. Encapsulation helps in controlling access to the class's data and ensures data integrity through validation.


Access the flashcards:
https://pablomaruk.com/apps/flashcards/