# Introduction to Object-Oriented Programming (OOP)

#### Introduction to OOP concepts

Object-Oriented Programming (OOP) is a programming paradigm that uses objects to represent real-world entities and their interactions. OOP emphasizes concepts such as encapsulation, inheritance, and polymorphism to organize code and make it more reusable and modular.

#### Classes and objects

In Java, a class is a blueprint or template for creating objects. An object is an instance of a class and represents a specific instance of the data and behaviors defined in the class.

Here's an example of a simple class in Java:

```java
public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}
```

In this example, we define a `Person` class with two private instance variables `name` and `age`, and a constructor that takes two arguments to initialize these variables.

We also define two getter methods, `getName()` and `getAge()`, which returns the values of the `name` and `age` instance variables, respectively.

To create an instance of this class, we use the `new` keyword to allocate memory for the object and call the constructor:

```java
Person p = new Person("John", 30);
```

Now `p` refers to a newly-allocated `Person` object with the name "John" and age 30.

#### Encapsulation, inheritance, and polymorphism

Encapsulation, inheritance, and polymorphism are three key concepts in OOP that help organize code and make it more modular and reusable.

Encapsulation refers to the practice of hiding the internal implementation details of a class from external code and providing a public interface for interacting with the class. In Java, we can use access modifiers like `public`, `private`, and `protected` to control the visibility of class members.

Inheritance is a mechanism that allows a new class to be based on an existing class, inheriting its data and behavior. In Java, we use the `extends` keyword to create a subclass that inherits from a superclass.

Polymorphism is the ability of an object to take on many forms. In Java, polymorphism is achieved through method overriding and method overloading.

Here's an example of inheritance in Java:

```java
public class Student extends Person {
    private int id;
    
    public Student(String name, int age, int id) {
        super(name, age);
        this.id = id;
    }
    
    public int getId() {
        return id;
    }
}
```

In this example, we define a `Student` the class that extends the `Person` class. The `Student` the class adds a new instance variable `id`, and a constructor that takes three arguments to initialize `name`, `age`, and `id`.

We also define a `getId()` the method that returns the value of `id`.

Since `Student` extends `Person`, it inherits all the data and behavior defined in `Person`, including the `name` and `age` instance variables, and the `getName()` and `getAge()` methods.

That covers the basics of OOP in Java!