Interface and Abstract Classes 1

Author: yankeexe

.gitignore

@@ -0,0 +1,3 @@
+practice_self
+General/
+*.class

Interface and Abstract Class/Crashable.java

@@ -0,0 +1,11 @@
+public abstract class Crashable{
+    /**variables defined inside abstract need not be constants like in the Interface */
+    boolean carDrivable = true;
+    
+    public void youCrashed(){
+        this.carDrivable = false;
+    }
+
+    public abstract void setCarStrength(int carStrength);
+    public abstract int getCarStrength();
+}

Interface and Abstract Class/Drivable.java

@@ -0,0 +1,13 @@
+ /**Interfaces are basically compact */
+public interface Drivable {
+    double PI = 3.14;
+    double getSpeed();
+    void setSpeed(double speed);
+
+    /**Whenever we are defining methods inside an interface, they are already abstract methods.
+     * Meaning: here `void setSpeed(double speed)` is in fact:`public abstract void setSpeed(double speed)`;
+     */
+
+     int getWheel();
+     void setWheels(int numWheels);
+}

Interface and Abstract Class/NewVehicle.java

@@ -0,0 +1,24 @@
+public class NewVehicle{
+    public static void main(String[] args)
+    {
+
+        /**This is with the parameterized constructor */
+        Vehicle car = new Vehicle(4,50);
+        System.out.println("The number of wheels on a car is: " + car.numberOfWheels);
+        System.out.println("The top speed of the car is: " + car.theSpeed);
+        System.out.println("The strength of the car is: " + car.carStrength);
+
+        /**If it was the default constructor then we have to work like this */
+        Vehicle bike = new Vehicle();
+        bike.numberOfWheels = 2;
+        bike.setSpeed(100);
+        System.out.println("Number of wheels on a bike is: " + bike.numberOfWheels);
+        System.out.println("Speed of bike is: " + bike.theSpeed);
+
+        /**Use of Abstract Class methods */
+        car.setCarStrength(100);
+        System.out.println("The strength of car is: " + car.carStrength);
+
+
+    }
+}

Interface and Abstract Class/Vehicle.java

@@ -0,0 +1,47 @@
+/**abstract class goes before Interface that's why we write extends Crashable before implements Interface */
+public class Vehicle extends Crashable implements Drivable {
+    
+    int numberOfWheels = 4;
+    double theSpeed = 0;
+    int carStrength = 0;
+
+    /**All the methods of Drivable Interface.
+     * When we are implementing an interface,
+     * the class should contain all the methods
+     * of the interface.
+     */
+    public double getSpeed(){
+        return theSpeed;
+    }
+
+    public void setSpeed(double speed){
+        this.theSpeed = speed;
+    }
+
+    public int getWheel(){
+        return numberOfWheels;
+    }
+
+    public void setWheels(int numWheels){
+        this.numberOfWheels = numWheels;
+    }
+
+    /**Parameterized Constructor */
+    public Vehicle(int wheels, double speed){
+        this.numberOfWheels = wheels;
+        this.theSpeed = speed;
+    }
+
+    /**Default Constructor */
+    public Vehicle(){
+
+    }
+
+    /**Derived from Abstract Class */
+    public void setCarStrength(int carStrength){
+        this.carStrength = carStrength;
+    }
+    public int getCarStrength(){
+        return this.carStrength;
+    }
+}