erweitert Schlüsselwort in Java

Das Schlüsselwort extends wird in Java verwendet, um anzuzeigen, dass eine Klasse von einer Oberklasse erbt. Dies ist ein grundlegender Aspekt der objektorientierten Programmierung in Java, der es einer neuen Klasse ermöglicht, Felder und Methoden von einer bestehenden Klasse zu erben.

Verwendung

Das Schlüsselwort extends wird in Klassendeklarationen verwendet, um eine Vererbungsbeziehung zwischen zwei Klassen herzustellen.

Syntax

class SubclassName extends SuperclassName {
    // class body
}Bereitgestellt von

• SubclassName: Der Name der neuen Klasse, die geerbt wird.
• SuperclassName: Der Name der bestehenden Klasse, von der geerbt wird.

Beispiele

Beispiel 1: Grundlegende Vererbung

class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Inherited method
        dog.bark(); // Method of Dog class
    }
}Bereitgestellt von

In diesem Beispiel erweitert die Klasse Dog die Klasse Animal und erbt deren Methode eat. Die Klasse Dog hat auch eine eigene Methode bark. Wenn eine Instanz von Dog erstellt wird, können sowohl die geerbte Methode eat als auch die Methode bark aufgerufen werden.

Beispiel 2: Überschreibende Methoden

class Animal {
    void sound() {
        System.out.println("This animal makes a sound.");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("The cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound(); // Overridden method
    }
}Bereitgestellt von

Hier erweitert die Klasse Cat die Klasse Animal und überschreibt die Methode sound, um ihre eigene Implementierung bereitzustellen. Die Anmerkung @Override wird verwendet, um anzuzeigen, dass die Methode außer Kraft gesetzt wird.

Beispiel 3: Vererbende Felder

class Person {
    String name;
}

class Employee extends Person {
    int employeeId;
}

public class Main {
    public static void main(String[] args) {
        Employee emp = new Employee();
        emp.name = "John Doe"; // Inherited field
        emp.employeeId = 12345;
        System.out.println("Name: " + emp.name + ", Employee ID: " + emp.employeeId);
    }
}Bereitgestellt von

In diesem Beispiel erweitert die Klasse Employee die Klasse Person und erbt deren Feld name. Die Klasse Employee hat auch ein eigenes Feld employeeId.

Tipps und bewährte Praktiken

• Setze die Vererbung mit Bedacht ein: Vererbung sollte verwendet werden, wenn es eine eindeutige "ist-a"-Beziehung zwischen der Unterklasse und der Oberklasse gibt.
• Methoden ordnungsgemäß überschreiben: Verwende die @Override Annotation, wenn du Methoden überschreibst, um sicherzustellen, dass du eine Methode der Superklasse korrekt überschreibst.
• Vermeide tiefe Vererbungshierarchien: Tiefe Vererbungshierarchien können es schwierig machen, den Code zu verstehen und zu pflegen. Ziehe Komposition der Vererbung vor, wenn es angebracht ist.
• Zugriff auf Methoden der Oberklasse: Verwende super, um bei Bedarf Methoden der Oberklasse aus der Unterklasse aufzurufen.

  class Animal {
      void eat() {
          System.out.println("This animal eats food.");
      }
  }
  
  class Dog extends Animal {
      void eat() {
          super.eat(); // Call superclass method
          System.out.println("The dog eats dog food.");
      }
  }Bereitgestellt von

• Konstrukteursverkettung: Verwende super(), um den Konstruktor der Oberklasse vom Konstruktor der Unterklasse aus aufzurufen.

  class Person {
      Person(String name) {
          System.out.println("Person's name is " + name);
      }
  }
  
  class Employee extends Person {
      Employee(String name, int employeeId) {
          super(name); // Call superclass constructor
          System.out.println("Employee ID is " + employeeId);
      }
  }Bereitgestellt von

Vererbung verstehen

Vererbung ist ein Schlüsselkonzept der objektorientierten Programmierung (OOP), das eine Beziehung zwischen einer allgemeineren Oberklasse und einer spezifischeren Unterklasse herstellt. Diese Beziehung ermöglicht es der Unterklasse, Attribute und Methoden von der Oberklasse zu erben, was die Wiederverwendbarkeit des Codes und die logische Strukturierung fördert.

• Is-A-Beziehung: Das Schlüsselwort extends steht für eine "is-a"-Beziehung. Ein Dog ist zum Beispiel ein Animal, und ein Employee ist ein Person.
• Einzelvererbung: Java unterstützt Einfachvererbung, d.h. eine Klasse kann nur eine andere Klasse erweitern, um Mehrdeutigkeit und Komplexität zu vermeiden.
• Kombinieren von Erweiterungen und Implementierungen: Eine Klasse kann eine andere Klasse erweitern und mehrere Schnittstellen gleichzeitig implementieren. Diese Kombination ermöglicht es einer Klasse, von einer Oberklasse zu erben und sich an mehrere Verträge zu halten, die durch Schnittstellen definiert sind.

class Animal {
    void move() {
        System.out.println("This animal moves.");
    }
}

interface Pet {
    void play();
}

class Dog extends Animal implements Pet {
    void bark() {
        System.out.println("The dog barks.");
    }

    public void play() {
        System.out.println("The dog plays.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.move();  // Inherited method from Animal
        dog.bark();  // Method of Dog class
        dog.play();  // Implemented method from Pet interface
    }
}Bereitgestellt von

In diesem Beispiel erweitert die Klasse Dog die Klasse Animal und implementiert die Schnittstelle Pet, um die Kombination aus Vererbung und Schnittstellenimplementierung zu veranschaulichen.