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

# Problem Statement 

Write a code that has:
* A **parent** *class* named `Account`. 
  * Inside it *define*: 
    * a protected double member `balance`    
    * `public void Withdraw(double amount)` 
    * `public void Deposit(double amount)`
    * `public void printBalance()`
   

* Then, there are **two derived** *classes* 
  * `Savings` class  
     * has a *private* member `interestRate` set to **0.8**
     * `Withdraw(double amount)` deducts *amount* from *balance* with *interestRate*
        * `Deposit(double amount)` adds *amount* in *balance* with *interestRate*
        * `printBalance()` displays the balance in the *account*
  * `Current` class 
     * `Withdraw(double amount)` deducts *amount* from *balance*
        * `Deposit(double amount)` adds *amount* in *balance*
        * `printBalance()` displays the balance in the *account*

## Input 
* In the `Savings` class, `balance` is set to **50000** in the parametrized constructor
* In the `Current` class, `balance` is set to **50000** in the parametrized constructor



## Output
Balance before withdrawing from the savings account
Balance after withdrawing from the savings account

Balance before withdrawing from the current account
Balance after withdrawing from the current account

## Sample Input

```Java

    // 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();  

```

## Sample Output
```Java
    Balance in your saving account: 51800.0
    Balance in your saving account: 46400.0

    Balance in your current account: 51000.0
    Balance in your current account: 48000.0
```



In this challenge, we'll implement an Account class along with two derived classes, Savings and Current.

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

Challenge 3: Implement an Account Class using Polymorphism

Problem Statement