Shulou(Shulou.com)06/02 Report--

This article mainly explains "what are the characteristics of Java inheritance". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Let the editor take you to learn "what are the characteristics of Java inheritance"?

Inheritance:

Extract the same content from multiple classes to another class, and then use the keyword extends to implement inheritance

Benefits of inheritance:

1. Improve the reusability of the code

two。 Improve the maintainability of the code only by modifying the contents of the parent class

3. There is an inheritance relationship between classes, laying the groundwork for the following polymorphism, which requires inheritance in order to do polymorphism.

The disadvantages of inheritance:

1. The coupling of the class is enhanced, and a parent class changes, and so does the subclass.

two。 Only a single inheritance, not multiple inheritance, can be multi-tier inheritance, the son inherits the father, the father inherits the grandfather

/ / you can inherit multiple layers of class GrandFather {} class Father extends GrandFather {} class Son extends Father {} / / you cannot inherit multiple layers, such as the features of class Son extends Father,Mother {} inheritance:

1. In order to initialize a subclass, you must first initialize the parent class and have a father before you can have a son.

two。 Subclasses can only inherit non-private members of the parent class

You can understand it through the code and comments in the following case

Class Father2 {int num = 20; Father2 () {System.out.println ("this is the father's no-parameter construction method");} private void fun1 () {System.out.println (num);}} class Son2 extends Father2 {public void fun2 () {System.out.println (num); / / System.out.println (num2) / / the subclass cannot inherit the private member variable of the parent class}} public class ExtendsDemo2 {public static void main (String [] args) {Son2 son2 = new Son2 (); son2.fun2 (); / / the parent's constructor is also implemented. To initialize the subclass, you must first initialize the parent class / / run the result: this is the parent's parameterless constructor, 20 / / son2.fun1 () / / cannot access the private member method of the parent class}}

3. The subclass cannot inherit the constructor of the parent class, which belongs to the class itself, but the constructor of the parent class can be accessed through the super keyword, because if you want to initialize the subclass, you must initialize the parent class first, which is initialized through the constructor

4. Do not use inheritance for some functions. When the syntax of two classes satisfies what is what, you can use inheritance. For example, dogs, cats, and tigers are all animals.

The relationship between inheritance and member variables:

a. When the member variable of the subclass has the same name as the member variable in the parent class

Find: 1. First search within the local scope of the method, and if found, it will be returned.

two。 If you cannot find it in the local scope of the method, look for it in the member location of this class (member variable), and return if you find it.

3. If you can't find it in the member location, look for it in the parent member location, and return if you find it.

4. If it cannot be found in the parent member position, an error is reported.

b. When the name of the member variable of a subclass is different from that of the parent class: visit whoever the name is

The difference between this keyword and super keyword

Difference: this represents the current object that calls the class, and super represents the identification of the storage space of the parent class (reference to the parent class, which can manipulate members of the parent class)

How to use it:

1. Access the member variable this. The member variable accesses the member variable in this class, super. Member variables access member variables in the parent class

/ access member variables class Father3 {int num= 10;} class Son3 extends Father3 {int num= 20; public void show () {int num= 30; System.out.println (num); System.out.println (this.num); System.out.println (super.num) in this class and parent class with this and num keywords }} public class ExtendsDemo3 {public static void main (String [] args) {Son3 son3 = new Son3 (); son3.show ();}}

two。 Access construction method

To initialize a subclass, you must first initialize the parent class, because the subclass inherits the data of the parent class and may even use the parent class's

Data, so the initialization of the parent class must be completed before the subclass initialization

Note: the first sentence of the constructor of each subclass defaults to super ()

/ / when this case is executed, the parameterless constructor of the parent class is accessed first, and then the parameterized constructor of the subclass class Father8 {int age; Father8 () {System.out.println ("no-parameter constructor in the parent class");} Father8 (String s) {System.out.println ("this is the constructor of the parent class with parameters" + s) }} class Son8 extends Father8 {Son8 () {System.out.println ("no parameter construction method of subclass");} Son8 (String s) {System.out.println ("subclass construction method with parameters" + s);}} public class ExtendsDemo7 {public static void main (String [] args) {Son8 S1 = new Son8 ("Xiao Wang");}}

In the execution result of the above case, we will first visit the parameterless constructor of the parent class, and then access the parameterized constructor of the subclass, because there is a hidden super () in the parameterless constructor of the subclass. If we want to access the parameterless constructor of the parent class, we need to handwrite a super (parameter); to guide the parameterized constructor of the parent class.

3. Access member method: this. Member method (), super. Member method ()

1. When the member method name of the subclass is different from that of the parent class, the one that should be called will be called.

2. What should I do when the member method name of the subclass is the same as that of the parent class? (proximity principle)

1) now look for it in this class. If there is one, call it. If you don't go to the parent class, look for it.

2) if there is a method in the parent class, call the

3) if there is no method name to be called in the parent class, an error is reported, indicating that the method cannot be found.

Method overrides:

If the method declaration of the subclass is the same as that of the parent class, this phenomenon is called method rewriting, which occurs in an inherited relationship, and the method declaration of the subclass and the parent class is the same, but the result of the implementation is not the same. For example: I write a study method in the parent class, output "learn java", and also write a declaration of the same study method in the subclass, output "learn higher mathematics". Here, although the declaration of the parent class and the subclass is the same, but our final implementation is different, this is called method rewriting.

At this point, I believe you have a deeper understanding of "what are the characteristics of Java inheritance?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.