Return to Java Declared abstract, Abstract declaration, Abstract

• abstract - The abstract keyword is used to declare abstract methods and abstract classes. An abstract method has no implementation defined; it is declared with arguments and a return type as usual, but the body enclosed in curly braces is replaced with a semicolon. The implementation of an abstract method is provided by a subclass of the class in which it is defined. If an abstract method appears in a class, the class is also abstract. Attempting to instantiate an abstract class will fail at compile time.“ (LrnJav 2023)

“A class may be declared abstract (§8.1.1.1), and must be declared abstract if it is incompletely implemented; such a class cannot be instantiated, but can be extended by subclasses. The degree to which a class can be extended can be controlled explicitly (§8.1.1.2): it may be declared sealed to limit its subclasses, or it may be declared final to ensure no subclasses. Each class except Object is an extension of (that is, a subclass of) a single existing class (§8.1.4) and may implement interfaces (§8.1.5).” (JvLngSpc17 2021, Chapter 8 - Classes)

The `abstract` keyword is a fundamental part of Java, indicating that a class or method is abstract. This summary will compare its use in Java with its application in other programming languages, exploring similarities, differences, and unique characteristics. We'll include code examples and references to official documentation.

In Java, the `abstract` keyword is used to declare a class or a method as abstract. An abstract class cannot be instantiated directly, and any class containing one or more abstract methods must also be declared abstract. Abstract methods in Java are method signatures without an implementation. The Java documentation provides a comprehensive guide on abstract classes and methods (https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html).

```java abstract class Animal {

   abstract void makeSound();

```java class Dog extends Animal {

   void makeSound() {
       System.out.println("Bark");
   }

C# also uses the `abstract` keyword in a similar manner to Java. It can be applied to classes and methods but not to variables. Abstract classes and methods in C# serve the same purpose: to define methods that must be implemented by subclasses. The Microsoft documentation elaborates on abstract classes and methods in C# (https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract).

```csharp abstract class Vehicle {

   public abstract void Drive();

```csharp class Car : Vehicle {

   public override void Drive() {
       Console.WriteLine("Car drives");
   }

Python does not have an `abstract` keyword. Instead, the Abstract Base Classes (ABCs) module provides functionalities for defining abstract base classes and abstract methods using decorators. The Python documentation provides insights into abstract base classes and methods (https://docs.python.org/3/library/abc.html).

```python from abc import ABC, abstractmethod

class Shape(ABC):

   @abstractmethod
   def area(self):
       pass

```python class Circle(Shape):

   def __init__(self, radius):
       self.radius = radius

   def area(self):
       return 3.14 * self.radius * self.radius

PHP uses the `abstract` keyword for classes and methods similarly to Java and C#. An abstract class or method in PHP is declared with the `abstract` keyword. The PHP documentation provides details on abstract classes and methods (https://www.php.net/manual/en/language.oop5.abstract.php).

```php abstract class Controller {

   abstract protected function execute();

```php class HomeController extends Controller {

   protected function execute() {
       echo "Home Controller executing";
   }

TypeScript, being a superset of JavaScript, does not have an `abstract` keyword native to JavaScript. However, TypeScript itself supports the `abstract` keyword for classes and methods, allowing for defining abstract classes and methods that must be implemented in derived classes. The TypeScript documentation covers abstract classes and methods (https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).

```typescript abstract class Logger {

   abstract log(message: string): void;

```typescript class ConsoleLogger extends Logger {

   log(message: string) {
       console.log(message);
   }

the `ConsoleLogger` class implements the abstract `log` method from the `Logger` class.

The `abstract` keyword plays a crucial role in object-oriented programming languages like Java, C#, and PHP, providing a mechanism for defining classes and methods that cannot be instantiated or invoked directly. Each language has its nuances and specific syntax for implementing abstract classes and methods. Python and JavaScript (through TypeScript) offer their mechanisms for achieving similar functionality, highlighting the versatility and importance of abstract concepts in software development. Understanding how `abstract` works across different languages can help developers design more flexible, reusable, and maintainable code.