Explore the fundamentals of OOP in Java. Gain insights into inheritance, polymorphism, and more to write clean, modular, reusable code through interactive exercises and practical challenges.

cpp17.tar.gz

Object-oriented programming (OOP) has been around for decades. As the original object-oriented language, Java is a mainstay in the world of computer programming. 

Having a foundation in OOP Java concepts will allow you to write cleaner, more modular, and more reusable code, as well as make it easier for you to understand the codebases of different companies you might be interested in joining.

Starting with the basics and reviewing complex topics like inheritance and polymorphism, this course is filled with illustrations, exercises, quizzes, and hands-on challenges. You’ll walk away with an understanding of classes and objects behavior and be able to easily create simple, efficient, reusable and secure code.

Learn Object-Oriented Programming in Java

// Account Class
class Account {
  
  protected double balance; // protected variable

  public Account(double balance) { // parametrized constructor
    this.balance = balance;
  }

  // member functions
  public void Deposit(double amount){}
  public void Withdraw(double amount){}
  public void printBalance(){}
  
}

// Savings class extended from Account class
class Savings extends Account {
  
  double interestRate = 0.8; // member variable

  public Savings(int balance) { // parametrized contructor
    super(balance); // calling base class constructor
  }

  // Implementation of member functions
  public void Deposit(double amount) {
    balance += amount + (amount * interestRate);
  }

  public void Withdraw(double amount) {
    balance -= amount + (amount * interestRate);
  }

  public void printBalance() {
    System.out.println("Balance in your saving account: " + balance);
  }
  
}

// Current class extended from the Account class
class Current extends Account {

  public Current(int balance) { // Parametrized constructor
    super(balance); // calling base class constructor
  }

  // Implementation of public member functions
  public void Deposit(double amount) {
    balance += amount;
  }

  public void Withdraw(double amount) {
    balance -= amount;
  }

  public void printBalance() {
    System.out.println("Balance in your current account: " + balance);
  }
  
}

class Demo {
  
  public static void main(String args[]) {
    // creating savings account object
    Account SAccount = new Savings(50000);
    
    SAccount.Deposit(1000);
    SAccount.printBalance();

    SAccount.Withdraw(3000);
    SAccount.printBalance();

    System.out.println();

    // creating current account object
    Account CAccount = new Current(50000);
    CAccount.Deposit(1000);
    CAccount.printBalance();

    CAccount.Withdraw(3000);
    CAccount.printBalance();  
  }
  
}

// Base Class
class Shape {

  // Private Data Members
  private double area;
  
  public Shape() { // Default Constructor
  	area = 0;
  }

  // Getter Function
  public double getArea() {
    return area;
  }
  
}

// Derived Class
class Circle extends Shape { 
  
  private double radius;
  
  public Circle(double radius) { // Constructor
    this.radius = radius;
  }
  
  // Overridden the Method getArea() which returns the area of Rectangle

  public double getArea() {
    
   return (radius*radius) * 3.14; 
  }
  
}

## Explanation

* We have implemented the `Account` class which has the **balance** double variable, and three public methods **Deposit(double amount), Withdraw(double amount)** and **printBalance()** 

* Implemented `Savings` and `Current` classes extended from the `Account` class through the `extend` keyword

* `Savings` class has private double **interestRate** variable and following methods:
  * `Withdraw(double amount)` deducts *amount* from the *balance* with *interestRate*

   * `Deposit(double amount)` adds *amount* in the *balance* with *interestRate*
   * `printBalance()` displays the balance in the *account*

* `Current` class has following methods:
   * `Withdraw(double amount)` deducts *amount* from *balance*
   * `Deposit(double amount)` adds *amount* in *balance*
   * `printBalance()` displays the balance in the *account*`
   

* Created *Savings* and *Current* object by calling parametrized constructors of the classes and printed their balance by calling their respective methods

This review provides a detailed analysis to solve the 'Implement an Account Class using Polymorphism' challenge.

Introduction to Object-Oriented Programming

Classes and Objects

Project: Amazon's Top 50 Bestselling Books Dataset

Data Hiding

Composition, Aggregation and Association

Project: Java Slam Dunk: Coding Skills Through Basketball

Object Oriented Programming in Java - Exam I

Inheritance

Polymorphism

Abstract Classes and Interfaces

Project: Doctor on Call

Object Oriented Programming in Java - Exam II

Solution Review: Implement an Account Class using Polymorphism

Solution