The concept of inheritance:
The same attributes and methods in multiple classes are extracted and put into a new class (parent class)
There is no need to repeatedly define these properties and methods in multiple classes. You only need to write unique properties and methods in your own class. Use the extends keyword to inherit the parent class to use the properties and methods in the parent class.
Inheritance is one of the important means to achieve code reuse in Java. Only single-root inheritance is supported in Java, that is, a class can only have one direct parent class
How to use inheritance:
Syntax: (parent class)
[access modifier] class Pet {
// public properties and methods
}
Write a subclass, inherit the parent class
[access modifier] class Dog extends Pet {
//Subclass-specific properties and methods
}
Subclass accesses parent class members
Access the parent class constructor:
super();
super(name);
Access parent class properties:
super.name;
access parent class method
super.print();
(1) Use the super keyword, super represents the parent class object
(2) Called in the subclass constructor and must be the first sentence
(3) Cannot access properties and methods defined as private in the parent class
super keyword
The super keyword to access the members of the superclass:
1) super can only appear in methods and constructors of subclasses
2) When super calls the constructor, it can only be the first sentence
3) super cannot access the private members of the parent class
Invocation of constructors under inheritance conditions
◆Calling rules of constructors under inheritance conditions:
The subclass constructor does not explicitly call the superclass's parameterized constructor through super
The method does not explicitly call its own other constructors through this
The system calls the no-argument constructor of the parent class by default
■The subclass constructor explicitly calls the parameterized constructor of the parent class through super.
Execute the corresponding constructor of the parent class instead of the no-argument constructor of the parent class
The subclass constructor explicitly calls its own other constructors through this,
Apply the above two rules in the corresponding construction method
Which resources can a subclass inherit from the parent class:
1) public modified resources,
2) You can inherit resources modified by default modifiers in the same package as subclasses
3) You can inherit protected modified resources, regardless of whether the parent class and the child class are in the same package
4) Cannot inherit resources that are modified with private in the parent class
5) Cannot inherit the constructor of the parent class
When to use inheritance?
■Inheritance is similar to the real world
●As long as "cats are mammals", many attributes and behaviors of cats are
Self-explanatory
The Tibetan Mastiff is a dog
(The design that conforms to the is-a relationship uses inheritance)
Inheritance is a way of code reuse
(puts properties and behaviors common to subclasses into parent class)
What are the benefits of inheritance:
It is convenient to modify the code and reduce the amount of code
Code:
father
package Exercises; public class Pet { //Define properties and encapsulate them with the private modifier private String name;//name private int health;//health value private int love;//intimacy //No-argument constructor public Pet() { } //Argument constructor public Pet(String name, int health, int love) { super(); this.name = name; this.health = health; this.love = love; } //get, set method public String getName() { return name; } public void setName(String name) { this.name = name; } public int getHealth() { return health; } public void setHealth(int health) { this.health = health; } public int getLove() { return love; } public void setLove(int love) { this.love = love; } //Define method to output object information public void printInfo(){ System.out.println("Pet Nickname:"+this.getName()+" "+"Health value:"+this.getHealth()+" "+"Intimacy:"+this.getLove()); } }
Cat subclass 1
package Exercises; public class Cat extends Pet { //Define the unique properties of the Cat class private String color; public Cat() { super();//Call the no-argument constructor in the parent class Pet class } public Cat(String name, int health, int love, String color) { super(name, health, love); this.color = color; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } }
Dog subclass 2
package Exercises; public class Dog extends Pet{ //strain is a unique attribute of the Dog class, other classes do not have it, so it is defined in the Dog class private String strain; //No-argument constructor public Dog() { } //Argument constructor public Dog(String name, int health, int love, String strain) { super(name, health, love); this.strain = strain; } //get, set method public String getStrain() { return strain; } public void setStrain(String strain) { this.strain = strain; } }
Penguin Subclass 3
package Exercises; public class Penguin extends Pet { //Define properties unique to the Penguin class private String sex;//gender public Penguin() { super();//super represents the parent class Pet object, so this place means calling the no-argument constructor of the parent class } //Argument constructor public Penguin(String name, int health, int love, String sex) { super(name, health, love);//Indicates that the parameterized constructor of the parent class Pet class is called this.sex = sex; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public void aa(){ System.out.println("Pet Nickname:"+getName()+" "+" Health value:"+getHealth()+" "+" Intimacy:"+getLove()+" gender:"+getSex()); } }
object
package Exercises; public class Test { public static void main(String[] args) { // Create Dog class object Dog dog1=new Dog("little black", 89, 78, "Husky"); //There is no setName( ) method in the Dog class, but the DOg class object dog1 can be called, because the Dog class inherits the Pet class, so dog1 can call the setName( ) method in the parent class Pet class dog1.setName("two fools"); dog1.printInfo(); //Create Penguin class object Penguin Pen1=new Penguin("Q pet",78,98,"male"); Pen1.setHealth(100); Pen1.setName("penguin"); Pen1.aa(); //Create a Cat class object Cat cat1=new Cat("tom", 99, 97, "White"); cat1.printInfo(); } }