Tasting OOP in JAVA

JAVA OOP explained and tasks

OOP

Understand how to define classes and create objects in Java. Focus on constructors, methods, fields, and the new keyword.

Let's dive into a lesson on Java Object-Oriented Programming (OOP), focusing first on classes and objects. We'll cover the fundamentals and then proceed with a practical code task for you to apply what you've learned.

Understanding Classes and Objects in Java

In Java, a class is a blueprint for creating objects. An object is an instance of a class, containing attributes (fields) and methods to represent and manipulate its data.

Defining a Class

To define a class in Java, you use the class keyword followed by the class name. By convention, class names in Java should start with an uppercase letter.

public class Car { // Fields, constructors, and methods go here }

Fields (Attributes)

Fields are variables within a class that represent the attributes of an object. They can have various access levels (private, protected, public).

public class Car 
{ 
private String color; 
private String model; 
private int year; 
}

Constructors

A constructor is a special method that is called when an object is instantiated. It initializes the object's fields. A class can have more than one constructor, each with different parameters.

Methods

Methods define the behavior of an object. They can modify fields, perform computations, and return information about the object.

Creating an Object

To create an object, use the new keyword followed by the class constructor.

Code Task

Now, it's your turn to practice. Follow these steps to reinforce your understanding:

1. Create a Class: Define a class named Book. It should have three fields: title (String), author (String), and yearPublished (int).

2. Constructor: Create a constructor for the Book class that initializes the three fields.

3. Method: Add a method named displayBookInfo to the Book class. This method should print the book's details in the format: "Title: [title], Author: [author], Year Published: [yearPublished]".

4. Instantiate and Call: In the main method of another class, create an object of the Book class and call the displayBookInfo method to display the book's details.

This task will help you understand how to define classes, create objects, and utilize constructors and methods in Java. Give it a try, and let me know if you have any questions or need further explanations!

---

Encapsulation

Encapsulation is a fundamental concept of OOP that restricts direct access to an object's data and methods from outside the class and enables the safe modification of its internal properties. In Java, encapsulation is achieved through the use of access modifiers and getter/setter methods.

Access Modifiers

• private: The field or method is accessible only within its own class.

• public: The field or method can be accessed from any other class.

• protected: The field or method can be accessed within its own package and by subclasses.

Implementing Encapsulation

To implement encapsulation, you typically declare class fields as private and provide public getter and setter methods to access and update the values of these fields.

Code Task

1. Implement Encapsulation: Modify the Book class to encapsulate its fields. Add getter and setter methods for title, author, and yearPublished.

2. Use Getters/Setters: In a main method (in another class or the same class if you prefer), create a Book object, and use the setter methods to set its fields. Then, call the displayBookInfo method to print the details.

3. Experiment with Encapsulation: Try accessing the fields directly from the main method to see what happens (you should get an error because the fields are private). This demonstrates how encapsulation protects the data.

By completing this task, you'll deepen your understanding of encapsulation and why it's a cornerstone of OOP.

---

Polymorphism in Java

Polymorphism is a core concept in object-oriented programming that allows objects to be treated as instances of their parent class rather than their actual class. The two main types of polymorphism in Java are:

1. Compile-time Polymorphism (Method Overloading): This occurs when multiple methods in a class have the same name but different parameter lists (different number of parameters or parameter types).

2. Runtime Polymorphism (Method Overriding): This is achieved when a subclass provides a specific implementation of a method already provided by its parent class.

Compile-time Polymorphism (Method Overloading)

You've already seen an example of runtime polymorphism with method overriding in the EBook class. Now, let's focus on compile-time polymorphism.

Code Task

1. Add Overloaded Methods: Inside the Book class, add an overloaded method displayInfo(). This method should take one argument, boolean showYear, which controls whether to include the yearPublished in the output. If showYear is true, display the year; otherwise, omit it.

2. Experiment with Overloading: In your main method, create a Book object and call both versions of displayBookInfo to see the different outputs based on the showYear parameter.

This task will help you understand how method overloading allows a class to have multiple methods with the same name but different parameter lists, providing more ways to interact with an object. Once you've implemented this, you've taken another step in mastering Java's OOP features! Feel free to share your implementation or ask for further clarification.

---

Abstraction

Abstraction is an OOP concept that focuses on hiding the complex implementation details and showing only the necessary features of an object. In Java, abstraction is achieved using abstract classes and interfaces.

Abstract Classes

• You cannot create objects of an abstract class; they are meant to be subclassed.

• You can have abstract methods (methods without a body) that must be implemented by subclasses.

Interfaces

• An interface in Java is a completely abstract class that is used to group related methods with empty bodies.

• Implementing an interface allows a class to become more formal about the behavior it promises to provide.

Code Task: Implementing Abstraction

Let's add an abstract method and interface to our example:

1. Create an Interface: Define an interface named Readable with a method readContent() that any class implementing Readable must define.

javaCopy code

public interface Readable { void readContent(); }

2. Implement the Interface in Book and EBook: Modify both Book and EBook to implement the Readable interface. Provide an implementation of the readContent() method in both classes.

Task

Implement the Readable interface as shown above and add the readContent method to both Book and EBook. This will demonstrate how Java uses interfaces to achieve abstraction and enforce a contract for implementing classes.

Once you've done this, you'll have a practical understanding of abstraction in Java. Feel free to share your implementation or ask any questions if you need further clarification!

---

Understanding Abstract Classes

1. Abstract Class: A class that is declared with the abstract keyword. It cannot be instantiated, meaning you cannot create objects of an abstract class directly.

2. Abstract Methods: Methods declared within an abstract class that do not have an implementation. Subclasses are required to provide implementations for these methods.

Task: Define an Abstract Class and Subclass It

Let's redefine our Book class as an abstract class and include at least one abstract method in it. We will then modify the EBook class to implement the abstract method.

Step 1: Make Book Abstract

First, we'll make Book an abstract class and add an abstract method called getMedium that subclasses will use to specify the medium of the book (e.g., "Physical", "Digital").

Step 2: Implement the Abstract Method in EBook

Since EBook extends Book, it must provide an implementation for the getMedium abstract method.

Task for You

• Implement another subclass of Book, say PhysicalBook, and provide an implementation for the getMedium method that returns "Physical" to indicate the medium.

• Experiment with creating instances of EBook and PhysicalBook, calling their displayBookInfo and getMedium methods to see polymorphism and abstraction in action.

This exercise will help you understand how abstract classes and methods are used to enforce a contract that must be fulfilled by subclasses, promoting a consistent API while allowing for different implementations in subclasses.

---

Additional Readings:

Beyond abstraction, classes, objects, encapsulation, inheritance, and polymorphism, there are a few more concepts and patterns in OOP that you might find useful:

• Composition: This is a design principle where you build classes that contain instances of other classes to achieve complex functionalities. This is often summarized by the phrase "has-a" relationship.

• Interfaces: While we touched on interfaces with the Readable example, remember that Java 8 introduced default and static methods in interfaces, allowing them to have a method body. Java supports multiple interface inheritance, meaning a class can implement multiple interfaces.

• Association, Aggregation, and Composition: These are concepts that describe how objects associate with each other through their relationships. Association is a broad term for any kind of connection between objects, aggregation implies a directional relationship without ownership, and composition implies ownership (where one class is a part of another class's definition).

• Design Patterns: Design patterns are standardized solutions to common software design problems. Familiarizing yourself with design patterns like Singleton, Factory, Observer, Strategy, and more can help you write more efficient and manageable code.

• SOLID Principles: These are five design principles intended to make software designs more understandable, flexible, and maintainable.

---

Resources

https://www.youtube.com/watch?v=GdzRzWymT4c

https://www.jetbrains.com/idea/download/?section=windows