# Object oriented principles

## Class & Object

* Classes and Objects are basic concepts of Object Oriented Programming which revolve around the real life entities.

### Class

* A class is a user defined blueprint or prototype from which objects are created.
* It represents the set of properties or methods that are common to all objects of one type.
*   **Class declaration includes,**

    1. **Access specifiers:** A class can be public or has default access _(package private)_.
    2. **Class name:** The name should begin with a capital letter & then follow camel case convention.
    3. **Superclass:**_(if any)_: The name of the class's parent _(superclass)_, if any, preceded by the keyword **extends**.
       * Implicit super class of all java classes is `java.lang.Object`.
    4. **Interfaces:**_(if any)_: A comma-separated list of interfaces implemented by the class, preceded by the keyword **implements**.
       * A class can implement more than one interface.
    5. **Body:** Class body is surrounded by `{}`.
    6. **Constructors:** Used for initializing new objects.
    7. **Fields:** Variables that provides the state of the class and its objects.
    8. **Methods:** Used to implement the behavior of the class and its objects.

    ```java
      eg : Student,Employee,Flight,PurchaseOrder, Shape ,BankAccount
    ```

### Object

* It is a basic unit of Object Oriented Programming and represents the real life entities.
* A typical Java program creates many objects, which interacts by invoking methods.
*   An object consists of :

    | Construct | Description                                                                                                                           |
    | --------- | ------------------------------------------------------------------------------------------------------------------------------------- |
    | State     | It is represented by attributes of an object _(properties of an object)_.                                                             |
    | Behavior  | It is represented by methods of an object _(actions upon data)_                                                                       |
    | Identity  | It gives a unique identity to an object and enables one object to interact with other objects. eg : Emp id / Student PRN / Invoice No |
* Creating an object
  * The `new` operator instantiates a class by allocating memory for a new object and returning a reference to that memory. The `new` operator also invokes the class constructor.
  * Constructor is a special method having same name as the class name with no explicit return type and may be parameterized or parameter less _(Default constructor)_.
  * Parameterized constructor is used initialize the state of the object.
  * If a class does not explicitly declare any constructor, then the Java compiler automatically provides a no-argument constructor, called the **default constructor**.
  * This default constructor implicitly calls the super class's no-argument constructor i.e., `java.lang.Object` class's constructor.

### Usage of this

1. To unhide, instance variables from method local variables _(to resolve the conflict)_.

```java
  this.name=name;
```

2. To invoke the constructor, from another overloaded constructor in the same class. _(constructor chaining -> to avoid duplication)_

### Encapsulation in Java

* Encapsulation is defined as the wrapping up of data & code as a single unit. It is the mechanism that binds together code and the data it manipulates.
* It's is a protective shield that prevents the private data from being accessed by the code outside this shield.
* The variables or data of a class is hidden from any other class and can be accessed only through any member function/method of own class in which they are declared.
* As in encapsulation, the data in a class is hidden from other classes, so it is also known as data-hiding.
* Tight Encapsulation can be achieved by declaring all the variables in the class as private and writing public methods as its accessors.

#### Advantages of Encapsulation:

1. Data Hiding (security)
2. Increased flexibility: We can make the variables of the class as read-only or write only or r/w.
3. Reusability: Encapsulation also improves the re-usability and easy to change with new requirements.
4. Testing code is easy.

* **Summary**
  * Encapsulation, consists of Data hiding + Abstraction.
  * Information hiding is achieved by private data members & supplying public accessors.
  * Abstraction is achieved by supplying an interface to the Client (customer).
  * Highlighting only WHAT is to be done & not highlighting HOW it's internally implemented.

### method local variables v/s instance data members

* Method local variable are allocated on stack, by default uninitialized.
* Javac(compiler) doesn't allow accessing ANY(primitive type or reference type) un-initialized variable.
* Instance data members are allocated on heap, initialized to default values.

```
  boolean ---> false
  int --> 0
  double --> 0.0
  ref types --> null
```
