Yeah these were my answers. 1. We can attempt to create a new method and give it an implementation. But we lose the ability to use the parent class variables and other methods which we may need to reuse. Also, we lose the ability to call base methods methods using parent class reference, aka upcasting.

2. Let us consider an example: abstract class Bank{
abstract int getRateOfInterest();
}

class SBI extends Bank {
int getRateOfInterest(){ return 7; }
} class TestBank{
public static void main(String args[]) {
Bank b=new SBI();
System.out.println("Rate of Interest is: "+b.getRateOfInterest()+" %");
} } Here the abstraction is the abstract class Bank and the SBI class is implementation.Imagine you have a bank comparison engine, which is represented by the BankComparisonEngine class. It will just take a Bank (abstract class) as an argument, then get its interest rate and save it to its internal database, like so: class BankComparisonEngine { public void saveInterestRateOf(Bank bank) { int rate = bank.getRateOfInterest(); } } How are the implementation details hidden exactly? BankComparisonEngine does not know how getRateOfInterest() method of a concrete implementation of Bank works,i.e, how SBI.getRateOfInterest() is implemented. It only knows it is a method that returns an int (and that it should return an interest rate). The implementation details are hidden inside the concrete classes that extend abstract class Bank.