**Course Title:** Comprehensive Java Programming: From Basics to Advanced Concepts **Section Title:** Abstraction and Interfaces in Java **Topic:** Implement an abstract class and an interface in a program to demonstrate abstraction and polymorphism.(Lab topic) **Objective:** By the end of this lab, you will be able to: * Implement an abstract class and an interface in a Java program * Demonstrate abstraction and polymorphism using abstract classes and interfaces * Understand the benefits of using abstract classes and interfaces in Java programming **Abstract Classes and Interfaces** In Java, an abstract class is a class that cannot be instantiated and is designed to be inherited by other classes. An interface is a abstract class with no implementation. Both abstract classes and interfaces are used to achieve abstraction and polymorphism in Java programs. **Implementing an Abstract Class** Let's create an abstract class called `Vehicle` that has two abstract methods: `startEngine()` and `accelerate()`. ```java public abstract class Vehicle { public abstract void startEngine(); public abstract void accelerate(); } ``` Now, let's create two concrete classes `Car` and `Truck` that extend the `Vehicle` abstract class. ```java public class Car extends Vehicle { @Override public void startEngine() { System.out.println("Car engine started"); } @Override public void accelerate() { System.out.println("Car accelerating"); } } public class Truck extends Vehicle { @Override public void startEngine() { System.out.println("Truck engine started"); } @Override public void accelerate() { System.out.println("Truck accelerating"); } } ``` **Implementing an Interface** Let's create an interface called `VehicleInterface` that has two methods: `startEngine()` and `accelerate()`. ```java public interface VehicleInterface { void startEngine(); void accelerate(); } ``` Now, let's create two concrete classes `Motorcycle` and `Bicycle` that implement the `VehicleInterface` interface. ```java public class Motorcycle implements VehicleInterface { @Override public void startEngine() { System.out.println("Motorcycle engine started"); } @Override public void accelerate() { System.out.println("Motorcycle accelerating"); } } public class Bicycle implements VehicleInterface { @Override public void startEngine() { System.out.println("Bicycle has no engine"); } @Override public void accelerate() { System.out.println("Bicycle accelerating"); } } ``` **Demonstrating Abstraction and Polymorphism** Now, let's create a `VehicleTest` class that demonstrates abstraction and polymorphism using the abstract class and interface. ```java public class VehicleTest { public static void main(String[] args) { Vehicle vehicle = new Car(); vehicle.startEngine(); vehicle.accelerate(); vehicle = new Truck(); vehicle.startEngine(); vehicle.accelerate(); VehicleInterface vehicleInterface = new Motorcycle(); vehicleInterface.startEngine(); vehicleInterface.accelerate(); vehicleInterface = new Bicycle(); vehicleInterface.startEngine(); vehicleInterface.accelerate(); } } ``` **Output:** ``` Car engine started Car accelerating Truck engine started Truck accelerating Motorcycle engine started Motorcycle accelerating Bicycle has no engine Bicycle accelerating ``` **Key Concepts:** * Abstract classes and interfaces are used to achieve abstraction and polymorphism in Java programs. * Abstract classes can have both abstract and non-abstract methods, while interfaces can only have abstract methods. * Concrete classes that extend an abstract class or implement an interface must provide implementation for all abstract methods. **Practical Takeaways:** * Use abstract classes and interfaces to define a contract that must be implemented by concrete classes. * Use polymorphism to write generic code that can work with different types of objects. **What's Next?** In the next topic, we will introduce you to Java's Collection Framework, which provides a set of interfaces and classes to store and manipulate collections of objects. If you have any questions or need help with this topic, please leave a comment below. External Resources: * Oracle Java Documentation: [Abstract Classes and Interfaces](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) * Java Tutorial by Tutorials Point: [Abstract Classes and Interfaces](https://www.tutorialspoint.com/java/java_abstract_interface.htm) We hope this helps! Let us know if you have any questions or need further clarification.