Java_继承使用细节全都在这了

哈喽，小琳我又来啦~~~

废话不多说，我今天总结了关于继承的9条细节，分成四个部分来讲，这是我花了接近一天的时间总结的知识点，希望对我也对你有所帮助哈！

继承快速入门：

package com.hspedu.extend.improve;
//测试
import com.hspedu.extend.Graduate;
import com.hspedu.extend.Pupil;

public class Extends01 {
    public static void main(String[] args) {
        com.hspedu.extend.Pupil pupil = new Pupil();
        pupil.name = "小明~";
        pupil.age = 10;
        pupil.setScore(90);
        pupil.testing();
        pupil.showInfo();
        System.out.println("=========");
        com.hspedu.extend.Graduate graduate = new Graduate();
        graduate.name = "大明~";
        graduate.age = 20;
        graduate.setScore(90);
        graduate.testing();
        graduate.showInfo();
    }
}

package com.hspedu.extend.improve;
//父类
public class Student {
    //共有属性
    public String name;
    public int age;
    private  double score;

    //共有的方法
    public void setScore(double score) {
        this.score = score;
    }

    public void showInfo(){
        System.out.println("小学生名" + name + "年龄" + age +"成绩" + score);
    }
}

package com.hspedu.extend.improve;
//子类
public class Graduate extends Student{
    public void testing(){
        System.out.println("小学生" + name + "正在考数学");
    }
}

继承使用细节1；子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。

看一个例子：

package com.hspedu.extend.Extends02;

    //父类
    public class Bace { 
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;
    // 无参构造器
    public Bace(){
        System . out . println("Base()....");
    }
    //父类提供一个public方法，返回n4
    public int getN4(){
        return n4;
    }
    public void test100() {
        System . out . println("test100");
    }
    protected void test200() {
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
    }

package com.hspedu.extend.Extends02;
//子类
public class Sub extends Bace{
    public Sub() {
        System.out.println("sub...");
    }
    public void sayOk(){//子类方法
        //非私有的属性和方法可以在子类直接访问
        System.out.println(n1 + "" + n2 + "" + n3 );
        //但是私有属性和方法不能在子类直接访问
        test100();
        test200();
        test300();
        //test400();错误
        //通过父类提供的方法去访问
        System.out.println("n4=" +getN4());
    }
}

//测试
package com.hspedu.Extends02;

import com.hspedu.extend.Extends02.Sub;

public class Extend001 {
    public static void main(String[] args) {
        Sub sub = new Sub();
        sub.sayOk();

    }
}

继承使用细节2：1.子类必须调用父类的构造器,完成父类的初始化 2.当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过.

在上面的例子中来看：

//父类
//    // 父类的无参构造器
//    public Bace(){
//        System . out . println("父类Base()....");
//    }
    //指定的有参构造器
    public Bace(String name,int age){
        System.out.println("父类Bace(String name,int age)构造器被调用");
    }

package com.hspedu.extend;
//子类
public class Sub extends Bace{
    //无参构造器
    public Sub() {
        /*
        当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
        如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪一个构造器
        完成对父类的初始化工作，否则编译不会通过
         */
        //super();默认调用父类的无参构造器
        super("smkhy",10);
        System.out.println("子类sub...");
    }
    public Sub(String name){
        super("jhfg",23);
        //do nothing
        System.out.println("Sub(String name)构造器被调用");
    }
}

package com.hspedu.extend;
//测试
public class ExtendsDetail {
    public static void main(String[] args) {
        System.out.println("===第一个对象===");
        Sub sub = new Sub();//创建子类对象sub
        System.out.println("===第二个对象===");
        Sub sub2= new Sub("jgjyg");//创建子类对象sub2
    }
}

运行结果：

继承使用细节3：1.super在使用时，必须放在构造器的第一行，且只能在构造器中使用。2.super和this不能再一个构造器里面。3.如果希望指定去调用父类的某个构造器，则显式的调用一下。

再对上面的例子来看：

 //父类中再来一个有参构造器
    public Bace(String name){
        System.out.println("父类Bace(String name)构造器被调用");
    }

 //子类中再加一个构造器
    public Sub(String name,int age){
        //        super();//父类的无参构造器
        /*
        1.想要调用父类的无参构造器：要么什么都不写，要么用super()
        2.如果希望指定去调用父类的某个构造器，则显式的调用一下
         */
        //super在使用时，必须放在构造器的第一行，且只能在构造器中使用
        //super和this不能再一个构造器里面
        super("jyg");
        System.out.println("子类Sub(String name)被调用");
    }

//测试
//第三个对象
        System.out.println("===第三个对象===");
        Sub sub3= new Sub("jgjyg");//创建子类对象sub3

运行结果：

继承使用细节4：1.Java所有类都是Object的子类，输入ctrl+h就可以看到类的继承关系。2，父类构造器的调用不限于直接父亲，将一直网上追溯直到Object类（顶级父亲）.3,不能滥用继承，子类和父类之间必须满足is-a的逻辑关系。

附上总体的代码啦：

父类：

package com.hspedu.extend;
//父类
public class Bace extends TopBace {
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;
    // 父类的无参构造器
    public Bace(){
        System . out . println("父类Base()....");
    }
    //指定的有参构造器
    public Bace(String name,int age){
        //super();
        System.out.println("父类Bace(String name,int age)构造器被调用");//2
    }
    //父类中再来一个有参构造器
    public Bace(String name){
        System.out.println("父类Bace(String name)构造器被调用");
    }
    //父类提供一个public方法，返回n4
    public int getN4(){
        return n4;
    }
    public void test100() {
        System . out . println("test100");
    }
    protected void test200() {
        System.out.println("test200");
    }
    void test300(){
        System.out.println("test300");
    }
    private void test400(){
        System.out.println("test400");
    }
}

子类：

package com.hspedu.extend;
//子类
//输入ctrl+h就可以看到类的继承关系
public class Sub extends Bace{
    //子类中再加一个构造器
    public Sub(String name,int age){
        //        super();//父类的无参构造器
        /*
        1.想要调用父类的无参构造器：要么什么都不写，要么用super()
        2.如果希望指定去调用父类的某个构造器，则显式的调用一下
         */
        //super在使用时，必须放在构造器的第一行，且只能在构造器中使用
        //super和this不能再一个构造器里面
        super("jyg");
        System.out.println("子类Sub(String name)被调用");
    }
    //无参构造器
    public Sub() {
        /*
        当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器
        如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪一个构造器
        完成对父类的初始化工作，否则编译不会通过
         */
        //super();默认调用父类的无参构造器
        super("smkhy",10);
        System.out.println("子类sub...");
    }
    public Sub(String name){
        super("jhfg",23);
        //do nothing
        System.out.println("子类Sub(String name)构造器被调用");//3
    }
    public void sayOk(){//子类方法
        //非私有的属性和方法可以在子类直接访问
        System.out.println(n1 + "" + n2 + "" + n3 );
        //但是私有属性和方法不能在子类直接访问
        test100();
        test200();
        test300();
        //test400();错误
        //通过父类提供的方法去访问
        System.out.println("n4=" +getN4());
    }
}

创建一个TopBace类

package com.hspedu.extend;

public class TopBace {//父类是object
    public TopBace(){
        //super(); object的无参构造器
        System.out.println("构造器TopBace()被调用");//1
    }
}

测试：

package com.hspedu.extend;
//测试
public class ExtendsDetail {
    public static void main(String[] args) {
//        System.out.println("===第一个对象===");
//        Sub sub = new Sub();//创建子类对象sub
//        System.out.println("===第二个对象===");
//        Sub sub2= new Sub("jgjyg");//创建子类对象sub2
        //第三个对象
        System.out.println("===第三个对象===");
        Sub sub3= new Sub("jgjyg");//创建子类对象sub3

//        sub.sayOk();
    }
}