How to use Java language inheritance

How to use Java language inheritance

Inheritance in Java language is an important object-oriented programming feature. It makes the connection between classes closer and the reusability of code also increases. has been greatly improved. In Java programming, inheritance is used to create a new class, which can inherit all properties and methods of the existing class, and can also add its own properties and methods to extend and improve the existing class. This article will introduce in detail the use of Java language inheritance, including the definition of inheritance, characteristics of inheritance, implementation of inheritance, precautions for inheritance, etc.

1. The definition of inheritance

Inheritance is an important feature in object-oriented programming. It allows us to directly use the methods and properties of existing classes when designing classes, thus saving time. and energy. In Java, inheritance is implemented through the extends keyword. The newly created subclass can inherit the properties and methods of the parent class, and can add its own properties and methods.

The core of inheritance is the inheritance of the parent class by the subclass. The subclass will obtain all non-private properties and methods of the parent class, and can extend the parent class by rewriting or adding new methods. The two classes with an inheritance relationship are called parent class and child class. The parent class has some common properties and methods, while the child class extends new properties and methods on this basis.

2. Characteristics of inheritance

1. Code reusability

Inheritance is a way of code reuse. Subclasses can inherit the code of the parent class , properties and methods, thus avoiding the problem of repeatedly writing the same code and improving the reusability of the code. In inheritance, subclasses can access existing data through the methods and attributes of the parent class, and can also inherit the behaviors and functions of the parent class, reducing code redundancy and using existing code to implement new functions.

2. Inherited hierarchy

In Java, there are multiple classes that can be inherited by subclasses, forming a class hierarchy. The most basic class in this structure is the java.lang.Object class, and the rest of the classes inherit the Object class. In this hierarchy, subclasses can inherit the members and methods of the parent class, and can extend new methods and properties on this basis.

3. Method rewriting

In inheritance, a subclass can redefine a method with the same name as the parent class. This process is called method rewriting. When overriding a method, the subclass must follow the rules for overriding the parent class, that is, the method name, parameter type, and return value type must be the same as those of the parent class, or the return value type of the subclass must be a child of the parent class's return value type. kind. Subclasses can also choose not to override methods in the parent class and will inherit them. This process is called method inheritance.

4. Inherited access control

In Java, there are four access rights to member variables and methods: public, private, protected and default. Among them, public has the broadest access rights. access permissions, while private has the least permissions. In inheritance, a subclass can inherit the public and protected members of the parent class, but cannot inherit the private members of the parent class. Even if the subclass can access the protected methods and properties of the parent class, these methods and properties are not visible to other classes.

3. How to implement inheritance

Inheritance in Java can be achieved through the keyword extends. The syntax format is:

访问修饰符 class subclass-name extends parent-class-name {
   // 子类继承父类的成员和方法
}

In a subclass, you can inherit the parent class All non-private methods and properties, you can also override the methods of the parent class or add your own methods and properties. A subclass can only inherit from one parent class, and a parent class can be inherited by multiple subclasses.

The following is an example of inheritance:

public class Animal {
   public void move() {
      System.out.println("Animal can move");
   }
}

public class Dog extends Animal {
   public void move() {
      System.out.println("Dog can move");
   }
}

public class TestDog {
   public static void main(String args[]) {
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move(); // 执行 Animal 类的方法
      b.move(); // 执行 Dog 类的方法
   }
}

In the above example, the Animal class is the parent class, the Dog class is the subclass, and the Dog class inherits the move() method of the parent class Animal , and redefined a method of its own.

4. Notes on inheritance

1. Constructors cannot be inherited

In Java, when a subclass inherits a parent class, the constructor cannot be inherited. , the subclass needs to define its own constructor. In a subclass, you can use the super keyword to call the constructor of the parent class to initialize the parent class.

2. When a subclass overrides a parent class method, the access permissions cannot be more stringent

In Java, when a subclass overrides a parent class method, the access permissions need to be the same or more stringent Loose, not stricter. For example, the access permission of a parent class method is public, and the access permission of a subclass method cannot be set to private or protected permissions.

3. The parent class pointer can point to the subclass object, but not the other way around.

Polymorphism in Java allows the parent class pointer to point to the subclass object. This This situation is called upward transformation. But the reverse is not true. For example, the pointer of the Dog class cannot point to an object of the Animal class.

4. Final methods cannot be overridden

In Java, if a method in the parent class is defined as final, then the subclass cannot override this method, that is to say , final methods cannot be overridden. This restriction is to prevent subclasses from modifying the original methods and affecting the correctness of the program.

5. Inheritance and combination

In Java, in addition to inheritance, there is another common way of code reuse, which is combination. Composition is to use an instance object of one class as a member variable of another class to extend its own properties and methods. Unlike inheritance, composition relates two classes in a compositional manner rather than an inheritance manner. You need to choose according to the actual situation when using it.

Summary

Inheritance in Java language is an important object-oriented programming feature, which can optimize code reuse and reduce development costs. When using inheritance, you need to pay attention to issues such as access rights of parent classes and subclasses, constructors, and method rewriting to ensure the correctness and security of the program. Of course, in actual development, inheritance is not necessarily the best way to reuse code. Combination is also a feasible option. You can choose according to the actual situation.

The above is the detailed content of How to use Java language inheritance. For more information, please follow other related articles on the PHP Chinese website!