abstract added.

Signed-off-by: Someshdiwan <[email protected]>

Author: Someshdiwan

Section13AbstractClasses/src/Abstract.md

@@ -0,0 +1,104 @@
+An abstract class in Java can contain both abstract and concrete methods. 
+This is one of the key features that distinguishes abstract classes from interfaces (prior to Java 8). 
+
+An abstract class can have any of the following:
+
+1. Abstract methods (methods without a body)
+2. Concrete methods (methods with a body)
+3. Instance variables
+4. Constructors
+5. Static methods and variables
+
+This flexibility allows abstract classes to provide a common structure and some implemented functionality while 
+leaving other methods to be implemented by subclasses. 
+
+For example:
+
+```java
+abstract class Shape {
+    protected String color;
+
+    public Shape(String color) {
+        this.color = color;
+    }
+
+    abstract double calculateArea(); // abstract method
+
+    public void displayColor() { // concrete method
+        System.out.println("Color: " + color);
+    }
+}
+```
+
+
+Yes, an abstract class can contain final methods. 
+
+Final methods in Java are methods that cannot be overridden by subclasses. 
+
+Including final methods in an abstract class can be useful when you want to provide a method implementation that 
+should not be changed by any subclass. 
+
+This allows you to enforce certain behavior across all subclasses of the abstract class. 
+
+Here's an example:
+
+```java
+abstract class Vehicle {
+    abstract void startEngine();
+
+    final void stopEngine() {
+        System.out.println("Engine stopped");
+    }
+}
+
+class Car extends Vehicle {
+    @Override
+    void startEngine() {
+        System.out.println("Car engine started");
+    }
+
+    // Cannot override stopEngine() as it's final in the superclass
+}
+```
+
+Yes, an abstract class can extend another abstract class. 
+
+This is perfectly valid in Java and can be useful for creating a hierarchy of abstract classes, 
+
+each adding or refining abstract or concrete methods. 
+
+When an abstract class extends another abstract class, it is not required to implement the abstract methods of its 
+superclass. 
+
+It can choose to implement some, all, or none of the abstract methods, 
+and can also add new abstract or concrete methods. 
+
+For example:
+
+```java
+abstract class Shape {
+    abstract double calculateArea();
+}
+
+abstract class TwoDimensionalShape extends Shape {
+    abstract double calculatePerimeter();
+}
+
+class Circle extends TwoDimensionalShape {
+    private double radius;
+
+    public Circle(double radius) {
+        this.radius = radius;
+    }
+
+    @Override
+    double calculateArea() {
+        return Math.PI * radius * radius;
+    }
+
+    @Override
+    double calculatePerimeter() {
+        return 2 * Math.PI * radius;
+    }
+}
+```

Section13AbstractClasses/src/AbstractIMP.md

@@ -0,0 +1,94 @@
+You cannot create an instance of an abstract class in Java.
+
+Abstract classes are designed to be incomplete and serve as a base for other classes.
+
+They may contain abstract methods, which have no implementation, making it impossible to instantiate them directly.
+
+However, you can create instances of concrete subclasses that extend the abstract class and provide implementations
+for all abstract methods.
+
+What happens if a subclass of an abstract class doesn't implement all the abstract methods?
+Ans:
+If a subclass of an abstract class doesn't implement all the abstract methods, the subclass itself becomes abstract.
+This means that the subclass cannot be instantiated either. To create a concrete class, all abstract methods 
+from the superclass must be implemented. 
+
+If you want to leave some methods unimplemented, you must declare the subclass as abstract as well:
+
+```java
+abstract class Shape {
+    abstract double calculateArea();
+}
+
+abstract class Rectangle extends Shape {
+    // calculateArea() is not implemented, so Rectangle is also abstract
+}
+```
+
+Yes, an abstract class can have a constructor in Java. Although abstract classes cannot be instantiated directly, 
+they can have constructors. 
+
+These constructors are called when an instance of a concrete subclass is created. 
+
+Constructors in abstract classes are useful for initializing common fields or performing common setup operations for 
+all subclasses. 
+
+For example:
+
+```java
+abstract class Animal {
+    protected String name;
+
+    public Animal(String name) {
+        this.name = name;
+    }
+
+    abstract void makeSound();
+}
+
+class Dog extends Animal {
+    public Dog(String name) {
+        super(name); // Calls the constructor of the abstract class
+    }
+
+    @Override
+    void makeSound() {
+        System.out.println(name + " barks");
+    }
+}
+```
+
+A key difference between abstract classes and interfaces in Java is that abstract classes can have constructors,
+while interfaces cannot.
+
+Abstract classes can have instance variables, constructors, and both abstract and non-abstract methods.
+
+Interfaces, on the other hand, can only have constants (public static final fields), abstract methods, default methods,
+and static methods.
+
+They cannot have constructors or instance variables.
+This difference allows abstract classes to initialize state and provide common implementation,
+while interfaces focus on defining a contract for implementing classes.
+
+When overriding an abstract method in a subclass, you can use the same access modifier as the abstract method or a less 
+restrictive one. 
+
+This follows the general rule for method overriding in Java. For example, if an abstract method is declared as protected, 
+the overriding method in the subclass can be declared as protected or public, but not private. 
+
+This allows for greater flexibility in the subclass while maintaining the contract defined by the abstract class. 
+
+For instance:
+
+```java
+abstract class Parent {
+    protected abstract void method();
+}
+
+class Child extends Parent {
+    @Override
+    public void method() { // Less restrictive, so it's allowed
+        // implementation
+    }
+}
+```