What are the characteristics of Java inheritance and method overriding?

Concept: Inheritance is one of the three major features of object-oriented grammar. Inheritance can reduce code redundancy and improve programming efficiency. By inheriting a subclass, you can freely call certain attributes and methods in the parent class. A subclass can only inherit one parent class, and a parent class can be inherited by multiple subclasses. It is like showing us that children inherit their father's property in life. The advantage of overriding is that subclasses can define their own behavior as needed. In other words, subclasses can implement the methods of the parent class as needed, just like golden retrievers and huskies, their characteristics come from dogs, hamsters and squirrels, their characteristics come from mice, and their differences are genetic mutations, which is equivalent to rewriting

Characteristics of inheritance:

1): Java only supports single root inheritance, that is, a class can only have one direct parent class, and a parent class can have multiple subclasses

2): Extract the public attributes of the subclass to generate parent class attributes for inheritance

3): The subclass cannot inherit or overwrite the attributes and resources modified by the parent class private

Characteristics of overriding:

1). The method overridden by the subclass must have the same method name and parameter list as the overridden method of the parent class

2). Overridden by the subclass The return value type of the method cannot be greater than the overridden return value type of the parent class

3). The access permissions used by the methods overridden by the subclass cannot be less than the access permissions of the overridden methods of the parent class. Methods declared as private (i.e. private attributes) in the parent class cannot be overridden

4). The exception thrown by the subclass method cannot be greater than the exception thrown by the overridden method of the parent class

Required Methods or keywords used:

extends: We can inherit through this keyword. Inheritance can be achieved by writing the class or method that needs to be inherited after the keyword

super (): We can use this method to call the properties or methods of the parent class we inherited using

Test class:

package com.ytzl.total;
/*继承*/
public class inherit {
    public static void main(String[] args) {
        son son = new son();//调用子类
        System.out.println(son.a);//调用子类中的属性
        son.a=2;//可以通过子类改变父类中的属性
        System.out.println("更改后的父类属性"+son.a);
        son.myfather();//带调用父类的方法
        son.money();//调用重写的方法w
        son.jng();//调用静态修饰方法
        son.jing();
        System.out.println("子类通过继承方法调用父类中的属性=>"+son.b);//调用父类中的静态属性
        son.two();
    }
}

Parent class:

package com.ytzl.total;
public class father {
    int a=0;
    static int b=2;
    private int one=4;//被私有属性修饰后将不能别子类调用或继承,
    protected int two=0;
    protected void two(){//该方法只能被子类继承重写不能被调用
        System.out.println("我是protected方法");
    }
    public void setOne(int one) {
        this.one = one;
    }
    public void money(){
        System.out.println("我是被子类重写的方法");
        System.out.println("父类的属性=>"+a);
    }
    public void myfather(){
        System.out.println("我是被子类继承的方法");
    }
    public static void jing(){
        System.out.println("你好");
    }
    public static void jng(){
        System.out.println("你好");
    }
    private void dong(){
        System.out.println("私有方法");
    }
}

Subclass:

package com.ytzl.total;
public class son extends father{
    //方法的重写
    public void money(){
        super.money();//通过继承过去父类的money方法里的内容
        System.out.println("重写后的方法");
        System.out.println("被继承后"+super.a);//通过super来继承父类的属性
        System.out.println("继承后的protected属性=>"+super.two);//通过super来继承protected方法
        super.two();
    }
    public static void jing(){//不能重写静态方法static
        System.out.println("不好");
    }
    private void dong(){//不能重写或者继承父类的私有方法
        System.out.println("私有方法");
    }
    protected void two(){//重写后的protected方法
        System.out.println("我是重写后的protected方法");
    }
}

Result after running:

The above is the detailed content of What are the characteristics of Java inheritance and method overriding?. For more information, please follow other related articles on the PHP Chinese website!