java类的继承-保姆级篇

Posted 2021-09-11 栗子~~

文章目录

• 前言
• • java类的继承-保姆级篇
  • • 01 继承的基本概念:
    • • 01::02 继承中涉及的角色:
      • 01::03 类的继承格式:
    • 02 子类对象的实例化过程
    • 03 super() 关键字
    • 04 如何限制子类使用父类的属性
    • 05 重写
    • 06 扩展:重载和重写的区别：

前言

  如果您觉得有用的话，记得给博主点个赞，评论，收藏一键三连啊，写作不易啊^ _ ^。
  而且听说点赞的人每天的运气都不会太差，实在白嫖的话，那欢迎常来啊!!!

---

java类的继承-保姆级篇

01 继承的基本概念:

即扩展已有类的功能。

01::02 继承中涉及的角色:

【父类】:父类有时候也被称为超类(super class)
【子类】:子类有时候称为派生类

01::03 类的继承格式:

继承格式举例:

class 父类  // 定义父类
{
}
class 子类 extends 父类 // 用 extends 关键字实现类的继承 {
}

注:在 java 中只允许单继承，而不允许多重继承，也就是说一个子类只能有一 个父类，但是 java中却允许多层继承。

多层继承的格式举例:

class A {}
class B extends A {}
class C extends B {}

由上面可以发现类 B 继承了类 A，而类 C 又继承了类 B，也就是说 类 B 是类 A 的子类，而类 C 则是类A 的孙子类。

---

02 子类对象的实例化过程

实例化过程:

子类对象实例化
-> 子类会默认先去调用父类中的无参构造方法
-> 之后再 调用本类中的相应构造方法。

论点验证:

class Father{
    public Father(){
        System.out.println("this is Father");
    }
}
class Son extends  Father{
    public Son(){
        System.out.println("this is Son");
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
    }
}

效果:

上述效果说明了我上述的论点的准确性。
注:实际上在子类中的构造函数中隐含了一个默认的super()，即:

class Son extends  Father{
    public Son(){
        super();
        System.out.println("this is Son");
    }
}

你可以照着上述的代码敲一下，将super()加到 你的子类的默认构造函数上，运行一下，看看还正不正确。

---

03 super() 关键字

作用:完成子类调用父类 中的内容，即调用父类中的属性或方法。

例子:

class Father{
    public Father(){
        System.out.println("this is Father");
    }
    public void work(){
        System.out.println("上班了");
    }
}
class Son extends  Father{
    public Son(){
        super();
        System.out.println("this is Son");
    }


    public void work(){
        super.work();
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.work();
    }
}

效果:

---

04 如何限制子类使用父类的属性

将父类要限制的属性进行私有化，这样的话，子类继承父类就没法使用父类的该私有化属性了。
例子:

class Father{
    private String name;
    public Father( ){
        System.out.println("this is Father");
    }
}
class Son extends  Father{
    public Son(){
        System.out.println("this is Son");
    }
    public void work(){
        name = "";
    }
}

这么看，不直观，那这么看呢!

---

05 重写

即当一个子类继承一父类， 而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中 的这个方法复写了父类中的方法。同理，如果子类中重复定义了父类中已有的属性， 则称此子类中的属性复写了父类中的属性。

重写的格式:

class Super
{
访问权限 方法返回值类型 方法 1（参数 1）
   {}
}
class Sub extends Super
{
访问权限 方法返回值类型 方法 1（参数 1） 重写父类中的方法
   {}
}

注:子类重写父类中的方法时，被子类重写的方法不能拥有比父类中更严格的访问权限。
下面我们来做一个论证:
我们猜猜下面的代码有没有问题;

class Father{
    public Father( ){
        System.out.println("this is Father");
    }
    private void work(String param){
        System.out.println("Father work!!!-"+param);
    }
}
class Son extends  Father{
    public Son(){
        System.out.println("this is Son");
    }
    public void work(String param){
        System.out.println("Son work!!!-"+param);
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.work("加加加");
    }
}

不同点:父类的方法的权限是private，子类的权限是public
答案是可以的，运行一下，看看效果。

那这样行不行呢:

class Father{
    public Father( ){
        System.out.println("this is Father");
    }
    public void work(String param){
        System.out.println("Father work!!!-"+param);
    }


}
class Son extends  Father{
    public Son(){
        System.out.println("this is Son");
    }


    void work(String param){
        System.out.println("Son work!!!-"+param);
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.work("加加加");
    }
}

答案是不可以的，看看效果:

但是，如果换成这样就没问题了。

class Father{
    public Father( ){
        System.out.println("this is Father");
    }
    private void work(String param){
        System.out.println("Father work!!!-"+param);
    }


}
class Son extends  Father{
    public Son(){
        System.out.println("this is Son");
    }


    void work(String param){
        System.out.println("Son work!!!-"+param);
    }
}
public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.work("加加加");
    }
}

我们在看一下权限的比较:

作用域	当前类	同一 package	子孙类	其他 package
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

通过上述论证，说明了什么，说明了子类重写父类中的方法时，被子类复写的方法不能拥有比父类中更严格的访问权限，比较绕，大白话即子类方法的权限大于父类方法的权限。

---

06 扩展:重载和重写的区别：

重载 :表示同一类中可以有多个相同名称的方法但是他们的参数列表必须不同。
》>》>》>》>》>》>》>》>》>》>》>注:

1. 在使用重载时只能通过不同的参数样式。例如，不同的参数类型，
   不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类
   型必须不一样，例如可以是 fun(int,float)，但是不能为 fun(int,int)）；
2. 不能通过访问权限、返回类型、抛出的异常进行重载；
3. 方法的异常类型和数目不会对重载造成影响；
4. 对于继承来说，如果某一方法在父类中是访问权限是 priavte，那
   么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新
   方法，而不会达到重载的效果。

重写 :子类中的方法可以和父类中的某个方法名称和参数完全一样， 之后通过子类创建的实例对象来调用该方法， 相当于把父类中那个定义的完全相同的那个方法给覆盖了。
》>》>》>》>》>》>》>》>》>》>》>注:

1. 覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能
   达到覆盖的效果；
2. 覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3. 覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，
   或者是其子类；
4. 被覆盖的方法不能为 private，否则在其子类中只是新定义了一个
   方法，并没有对其进行覆盖。