萌新卷妹带你从头复习JavaSE--包与继承2

✨欢迎关注🖱点赞🎀收藏⭐留言✒

🔮本文由京与旧铺原创，csdn首发！

😘系列专栏：java学习

💻首发时间：🎞2022年10月18日🎠

🎨你做三四月的事，八九月就会有答案，一起加油吧

🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦

🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲

💬推荐一款模拟面试、刷题神器👉[点击进入网站

2.继承

2.1什么是继承？

先来看一段代码：

class Dog {
    public String name;
    public int age;
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭！");
    }
    public void run() {
        System.out.println(name + "正在跑！");
    }
}
​
class Bird {
    public String name;
    public int age;
    public Bird(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "正在吃饭！");
    }
​
    public void fly() {
        System.out.println(name + "正在飞！");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗", 18);
        dog.run();
        dog.eat();
        Bird bird = new Bird("小鸟", 19);
        bird.fly();
        bird.eat();
    }
}
复制代码

我定义了两个类，一个是$Dog$，另一个是$Bird$，里面存放了两种动物的行为与特征，但是我们发现它们有不少共同点，比如它们都有名字，年龄，都会吃饭，这是所有动物都有的特征与行为，所以我们不妨将这些共同的特征封装成一个类$Animal$，然后在定义$Dog,Bird$类的时候后面加上extends Animal，这代表$Dog,Bird$类继承了类$Animal$，$Dog,Bird$类中不需要定义名字，年龄字段，吃饭的方法，就能使用这些成员变量和方法，这就叫做$继承$。其中$Dog,Bird$为子类（导出类），$Animal$类为父类（基类，超类）。所谓继承，就是子类继承父类的字段和方法，private修饰的成员子类不能继承，或者说能继承，但是子类不能访问它，因为private的属性就是只能在类中进行访问，子类与父类不是同一个类，所以子类访问不了父类private修饰的成员。

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name + "在吃饭！");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public void run() {
        System.out.println(name + "正在跑！");
    }
}
​
class Bird extends Animal{
    public Bird(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public void fly() {
        System.out.println(name + "正在飞！");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗", 18);
        dog.run();
        dog.eat();
        Bird bird = new Bird("小鸟", 19);
        bird.fly();
        bird.eat();
    }
}
复制代码

2.2类的继承

前面用了一个实例引出了什么是继承，接下来我们来讨论一下继承的一些细节。打个比方我们不妨将图纸分为两类，一类具有共性，另一类具有特性，具有特性的图纸继承了具有共性的图纸，则具有共性的图纸（类）称为父类（基类，超类），具有特性的图纸（类）称为子类，两者的关系是子类继承父类，子类实例化出的对象就相当于两张图纸实例的一个对象，继承往往具有子类is a 父类或者子类is like a父类。

2.2.1继承的特征

继承的特征指的是对共性的抽取 ，使用$extends$关键字进行处理，能够对代码进行重复使用。

2.2.2Java中继承的规则

✨基本规则：

1. Java中的继承是单继承，不能同时继承多个类（两个或两个以上），但是可以连续继承。
2. 子类构造时，需 先 对父类帮助进行构造。
3. $super$关键字表示父类对象的引用（不能出现在静态方法中），可以使用该关键字调用父类的构造方法与成员。

⭐️关于$super$：

1. $super()$，调用父类的构造方法。
2. $super.func()$，调用父类的成员方法。
3. $super.data$，访问父类的成员变量。
4. $super()$在子类构造方法没有写，默认调用父类无参构造。

细心的同学已经发现了，上面所写的代码，并没有发现子类帮助父类进行构造，但是程序依然可以正常运行，其实当没有定义任何构造方法时，编译器会自动生成一个不带参数的构造方法，父类中没有定义构造方法，所以父类会生成一个不带参数的构造方法，子类的构造方法如果没有帮助父类调用构造方法时，相当于会自动生成不带参数的$super()$，所以程序依然可以正常运行。相当于下面的代码：

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name + "在吃饭！");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public void run() {
        System.out.println(name + "正在跑！");
    }
}
​
class Bird extends Animal{
    public Bird(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public void fly() {
        System.out.println(name + "正在飞！");
    }
}
复制代码

如果在父类中定义了一个带参数的构造方法，如果子类没有调用父类的构造方法，则会报错。 我们再来看一段代码：

class Animal {
    public String name;
    public int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(name + "在吃饭！");
    }
}
class Dog extends Animal{
    public Dog(String name, int age) {
        super("动物", 1);
        this.name = name;
        this.age = age;
    }
    public void run() {
        System.out.println(name + "正在跑！");
    }
    public void fatherClass() {
        System.out.println(super.name + super.age);
    }
}
public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗", 18);
        dog.fatherClass();
    }
}
复制代码

✨这个程序会输出什么呢？ $A.小狗18$ $B.动物1$ 你们觉得是哪个选项呢？我们了看看输出结果： 答案是A。为什么呢？这段代码首先帮助父类进行构造name = "动物" age = 1，然后子类再构造name = "小狗" age = 18，因为子类中没有name age，所以两者访问的都是父类对象的name age，所以输出小狗18。

当然如果子类中有name age，则会输出动物1。

class Animal {
    public String name;
    public int age;
    public Animal(String name, int age) {
        this.age = age;
        this.name = name;
    }
    public void eat() {
        System.out.println(name + "在吃饭！");
    }
}
class Dog extends Animal {
    public String name;
    public int age;
    public Dog(String name, int age) {
        super("动物", 1);
        this.name = name;
        this.age = age;
    }
    public void run() {
        System.out.println(name + "正在跑！");
    }
    public void fatherClass() {
        System.out.println(super.name + super.age);
    }
}
​
public class Test2 {
    public static void main(String[] args) {
        Dog dog = new Dog("小狗", 18);
        dog.fatherClass();
    }
}
复制代码

2.3访问权限

除了public, private, default（包访问权限），还有一个protected访问权限关键字，范围是在default的基础是加上父子类。注意default是默认权限，不需要使用关键字修饰成员。

我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用public. 另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 还是更希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 "谁" 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用).

✨如果一个类不想被继承可以使用关键字final修饰类。 final修饰字段（变量），则变量只能初始化赋值一次，不能修改，相当于常量。 final修饰方法，则方法不能重写（下一篇博客详细介绍）。

2.4this与super区别

✨super来引用父类对象，用this来引用当前对象。

⭐️相同点：

1. 均可以调用构造方法，但是两者不能同时出现在同一构造方法。
2. 调用某构造方法时必须放在另一个构造方法第一行。
3. 都不能放在静态方法中使用。

⭐️不同点：

1. 引用对象不同。
2. super()从子类中调用父类的构造方法，this()调用当前类的构造方法。