Java继承

目录

继承的实际案例：

继承的好处：

案例：

1.传统方法，不使用继承

2.新技术，使用继承

继承中子类对父类的属性和方法的使用：

调用属性或方法的关系

细节（复习必看）：

最后要说的话：

---

概念：

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承的实际案例：

生活中儿子继承父亲，父亲继承爷爷，猫和狗继承动物

继承的好处：

继承可以降低代码编写的冗余度，提高编程的效率。

案例：

创建一个小学生和一个大学生，设置其名字、年龄、分数的信息并打印信息。

1.传统方法，不使用继承

小学生类

//小学生->模拟小学生考试的情况
public class Pupil {
    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }

    public void testing() {
        System.out.println("小学生" + name + " 正在开始小学属性..");
    }
    public void showInfo() {
        System.out.println("小学生名" + name + " 年龄" + age + " 成绩" + score);
    }
}

大学生类 

public class Graduate {
    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }

    public void testing() {
        System.out.println("大学生" + name + " 正在开始大学属性..");
    }
    public void showInfo() {
        System.out.println("大学生名" + name + " 年龄" + age + " 成绩" + score);
    }
}

测试

public class Extend01 {
    public static void main(String[] args) {
        Pupil pupil = new Pupil();
        pupil.name = "jack";
        pupil.age = 10;
        pupil.testing();
        pupil.setScore(80);
        pupil.showInfo();

        Graduate graduate = new Graduate();
        graduate.name = "金角大王";
        graduate.age = 20;
        graduate.testing();
        graduate.setScore(65);
        graduate.showInfo();
    }
}

2.新技术，使用继承

学生类

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);
    }
}

小学生

public class Pupil extends Student {
    public void testing() {
        System.out.println("小学生" + name + " 正在开始小学属性..");
    }
}

大学生

public class Graduate extends Student {
    public void testing() {
        System.out.println("大学生" + name + " 正在开始大学属性..");
    }
}

测试

public class Extend02 {
    public static void main(String[] args) {
        Pupil pupil = new Pupil();
        pupil.name = "jack";
        pupil.age = 10;
        pupil.testing();
        pupil.setScore(80);
        pupil.showInfo();

        Graduate graduate = new Graduate();
        graduate.name = "金角大王";
        graduate.age = 20;
        graduate.testing();
        graduate.setScore(65);
        graduate.showInfo();
    }
}

这里可以看出继承的优势，让Pupil类和Graduate类共有的属性和方法提取到Student类中。

学生可以分很多，小学生、初中生、高中生等等，由此可见继承降低代码编写的冗余度。

继承中子类对父类的属性和方法的使用：

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.name);
        System.out.println(son.getAge());
        System.out.println(son.hobby);
    }
}

class GrandPa { //爷类
    String name = "大头爷爷";
    String hobby = "旅游";
}

class Father extends GrandPa { //父类
    String name = "大头爸爸";
    int age = 40;

    public int getAge() {
        return age;
    }
}

class Son extends Father { //子类
    String name = "小头儿子";
}

调用属性或方法的关系

 要按照查找关系来返回信息 
（1） 首先看子类是否该属性 
（2） 如果子类有这个属性，并且可以访问，则返回信息 
（3） 如果子类没有这个属性，就看父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息..） 
（4） 如果父类没有就按照（3）的规则，继续找上级父类，直到Object

细节（复习必看）：

public class Base {
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;
    public Base() {
        System.out.println("base()....");
    }

    public Base(String name, int age) {
        //do nothing...
        System.out.println("子类Base(String name, int age)构造器被调用....");
    }

    public Base(int n1) {
        this.n1 = n1;
        System.out.println("66666");
    }

    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");
    }

    public void calltest400() {
        test400();
    }
}

public class Sub extends Base {

    public Sub(String name, int age) {
        this("jack");
        System.out.println("子类Sub(String name, int age)构造器被调用");
    }
    public Sub(String name) {
        super("cuihshuai", 10);
        //do nothing...
        System.out.println("子类Sub(String name)构造器被调用....");
    }

    public Sub() {
        super("jack", 20);
        System.out.println("Sub....");
    }
    
    public void sayOk() {
        System.out.println("n1=" + n1 + " n2=" + n2 + " n3=" + n3);
        test100();
        test200();
        test300();
        //test400();
        System.out.println("n4=" + getN4());
        calltest400();
    }
}

public class ExtendsDetail {
    public static void main(String[] args) {
        System.out.println("=====第3个=======");
        Sub sub2 = new Sub("jack",20); //创建了子类对象 sub
        sub2.sayOk();
    }
}

1.子类集成了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能再蕾蕾中直接访问，要通过父类提供的公共的方法去访问。

2.子类必须调用父类的构造器，完成父类的初始化（使用super）

这里的super("jack", 20);其实就是Base("jack", 20);

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

4.如果希望指定去调用父类的某个构造器，则显式的调用一下

5.super在使用时，需要放在构造器的第一行

这个情况下算是一个例外，如果说先执行的话，应该是this("jack");先执行，但是没有执行完，super("cuishuai", 10);是第一个先执行完的语句。

6.super()和this()都只能放在第一行，因此这两个方法不能共存一个构造器

最后要说的话：

好长时间没有写文章了，这段时间正好复习Java基础知识，让之前的代码重新翻出来看一下并写文章，看文章的卷王们有多长时间没有写文章了