Introduction:

Normalization is a fundamental concept in Database Management Systems (DBMS) that ensures data organization is efficient, minimizes redundancy, and maintains data integrity. By breaking down complex data into smaller, manageable parts, normalization optimizes data storage and retrieval, making it an essential technique for any well-designed database. In this blog post, we will explore what normalization is, its significance, and the various types of normalization.

What is Normalization?

Normalization, in the context of DBMS, refers to the process of structuring a database to eliminate data redundancy and improve data integrity. It involves decomposing a database into multiple tables, each containing specific data. This systematic organization allows for efficient data retrieval and maintenance, reducing the chances of inconsistencies and anomalies.

Importance of Normalization:

1. Reducing Data Redundancy: By eliminating redundant data, normalization ensures that information is stored in a single place, reducing storage requirements and preventing inconsistencies.

2. Data Integrity: Normalization enforces rules that maintain data integrity, ensuring that data is accurate and consistent across the entire database.

3. Scalability: A well-normalized database can easily scale as new data is added without sacrificing performance or increasing complexity.

4. Simplified Maintenance: Normalization simplifies the task of updating and modifying data, as changes only need to be made in one place.

Types of Normalization:

There are different levels of normalization, each represented by a normal form (NF). The higher the normal form, the more normalized and refined the database becomes.

1. First Normal Form (1NF):
   In 1NF, data is organized into tables, and each attribute contains only atomic (indivisible) values. There are no repeating groups or arrays in any attribute, ensuring that each cell in the table contains a single value.

1NF example:-

2. Second Normal Form (2NF):
2NF builds upon 1NF and eliminates partial dependencies. It requires that every non-prime attribute in a table is fully functionally dependent on the primary key. By splitting the table into multiple related tables, each containing a distinct set of attributes, 2NF further reduces redundancy.

2NF example:-

3. Third Normal Form (3NF):
In 3NF, every non-prime attribute must be non-transitively dependent on the primary key. This form helps remove transitive dependencies, further improving data integrity.

3NF Example:-

4. Boyce-Codd Normal Form (BCNF):
BCNF is an extension of 3NF and aims to eliminate all functional dependencies between non-prime attributes. It ensures that every determinant (an attribute that uniquely determines another attribute) is a candidate key.

Conclusion:

Normalization is a crucial process in database design, enabling efficient storage, retrieval, and maintenance of data while enhancing data integrity. By organizing data into well-structured tables, normalization reduces redundancy and ensures consistency across the database. Understanding the different normalization forms empowers database designers to create robust and scalable databases that meet the needs of modern applications and business requirements.

This blog will help give you a thorough understanding of the underlying principles of object-oriented programming and its concepts.

What is Object-Oriented Programming?

Object-oriented programming (OOP) is a fundamental programming paradigm based on the concept of “objects”. These objects can contain data in the form of fields (often known as attributes or properties) and code in the form of procedures (often known as methods).

What is a Class?

A class is defined as a collection of objects. You can also think of a class as a blueprint from which you can create an individual object. It is a logical entity. It can’t be physical.

To create a class, we use the keyword class.

Example of class:

class Car {
  // fields
  String color;
  String brand;
  
  // constructor
  Car(String color, String brand){
    this.color = color;
    this.brand = brand;
  }

  // method
  void break(){
    System.out.println("Break...");
  }
}

In the above example, we have fields (also called variables) and methods, which represent the state and behavior of the object, respectively.

Note that in Java, we use fields to store data, while we use methods to perform operations.

Note that a class should always start with an uppercase first letter.

What is an Object?

An object is an entity in the real world that can be distinctly identified. Objects have states and behaviors. In other words, they consist of methods and properties to make a particular type of data useful.

Example of object:

public class Main {
  public static void main(String[] args) {
    // creating object
    Car obj = new Car();
    
    // assigning initial values
    obj.color = "Black";
    obj.brand = "TATA";

    // accessing members through reference variable
    System.out.println(obj.color);
    obj.break();
  }
}

Key Principles of Object-Oriented Programming.

There are the four main principles of the Object-Oriented Programming paradigm. These principles are also known as the pillars of Object-Oriented Programming.

The four main principles of Object-Oriented Programming are:

1. Encapsulation
2. Inheritance
3. Abstraction
4. Polymorphism

Encapsulation

Encapsulation is a process of wrapping code and data together into a single unit, for example, a capsule which is mixed of several medicines.

We can create a fully encapsulated class in Java by making all the data members of the class private. Now we can use setter and getter methods to set and get the data in it.

Let me give you an example that demonstrates how the get and set methods work:

Example of Encapsulation:

public class Student {
  private String name; // private = restricted access

  // Getter
  public String getName() {
    return name;
  }

  // Setter
  public void setName(String newName) {
    this.name = newName;
  }
}

Inheritance

Inheritance allows classes to inherit attributes and methods of other classes. This means that parent classes extend attributes and behaviors to child classes. Inheritance supports reusability.

A simple example that explains the term inheritance is that human beings (in general) inherit certain properties from the class “Human” such as the ability to speak, breathe, eat, drink, and so on.

We group the “inheritance concept” into two categories:

• subclass (child) — the class that inherits from another class.
• superclass (parent) — the class being inherited from.

To inherit from a class, we use the extends keyword.

In the below example, the JerryTheMouse class is created by inheriting the methods and fields from the Animal class.

JerryTheMouse is the subclass and Animal is the superclass.

Example of Inheritance:

class Animal {

  // field and method of the parent class
  String name;

  public void eat() {
    System.out.println("I can eat");
  }
}

// inherit from Animal
class JerryTheMouse extends Animal {

  // new method in subclass
  public void display() {
    System.out.println("My name is " + name);
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of the subclass
    JerryTheMouse mouse = new JerryTheMouse();

    // access field of superclass
    mouse.name = "Jerry, the mouse";
    mouse.display();

    // call method of superclass
    // using object of subclass
    mouse.eat();

  }
}

Abstraction

Abstraction is a process of hiding the implementation details and showing only functionality to the user.

A simple example to explain abstraction is to think about the process that comes into play when you send an email. When you send an email, complex details such as what happens as soon as it is sent and the protocol that the server uses are hidden from you.

When you send an e-mail, you just need to enter the email address of the receiver, the email subject, type the content, and click send.

You can abstract stuff by using abstract classes or interfaces.

The abstract keyword is a non-access modifier, used for classes and methods:

• Abstract class: is a restricted class that cannot be used to create objects. To access it, it must be inherited from another class.
• Abstract method: A method that doesn’t have its body is known as an abstract method. We use the same abstract keyword to create abstract methods.

The body of an abstract method is provided by the subclass (inherited from).

Example of Abstraction:

abstract class Shape {
   // Abstract method to calculate area (no implementation)
   public abstract double calculateArea();
}

class Circle extends Shape {
 private double radius;

 public Circle(double radius) {
   this.radius = radius;
 }

 @Override
 public double calculateArea() {
   return Math.PI * radius * radius;
 }
}

class Square extends Shape {
 private double side;

 public Square(double side) {
   this.side = side;
 }

 @Override
 public double calculateArea() {
   return side * side;
 }
}

Polymorphism

Polymorphism refers to the ability of an object to take on many forms. Polymorphism normally occurs when we have many classes that are related to each other by inheritance.

Polymorphism is similar to how a person can have different characteristics at the same time.

For instance, a man can be a father, a grandfather, a husband, an employee, and so forth — all at the same time. So, the same person possesses different characteristics or behaviors in different situations.

Example:

We are going to create objects Cow and Cat, and call the animalSound() method on each of them.

class Animal {
  public void animalSound() {
    System.out.println("An animal can make a sound.");
  }
}

class Cow extends Animal {
  public void animalSound() {
    System.out.println("A cow says: Moooo");
  }
}

class Cat extends Animal {
  public void animalSound() {
    System.out.println("A cat says: Meeooww");
  }
}

class Main {
  public static void main(String[] args) {
    Animal myAnimal = new Animal();
    Animal myCow = new Cow();
    Animal myCat = new Cat();
        
    myAnimal.animalSound();
    myCow.animalSound();
    myCat.animalSound();
  }
}

Inheritance and polymorphism are very useful for code reusability. You can reuse the attributes and methods of an existing class when you create a new class.

Interfaces

An interface is a collection of abstract methods. In other words, an interface is a completely "abstract class" used to group related methods with empty bodies.

An interface specifies what a class can do but not how it can do it.

Example:

// create an interface
interface Language {
  void getName(String name);
}

// class implements interface
class ProgrammingLanguage implements Language {

// implementation of abstract method
  public void getName(String name) {
    System.out.println("One of my favorite programming languages is: " + name);
  }
}

class Main {
  public static void main(String[] args) {
    ProgrammingLanguage language = new ProgrammingLanguage();
    language.getName("Java");
  }
}

Conclusion

We have looked at some of the main object-oriented programming concepts in this blog. Having a good understanding of these concepts is essential if you want to use them well and write good code.