Java系列文章目录

---

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

---

1.再谈初始化

在之前代码块相关的文章我们提到一次代码块的执行顺序，这次我们在了解一下父类与子类初始化时代码块的执行顺序。
看代码，你可以先尝试用你已有的知识分析下面代码的执行结果。

class F{
    public F() {
        System.out.println("父类构造方法");
    }
    {
        System.out.println("父类构造代码块");
    }
    static{
        System.out.println("父类静态代码块");
    }
}
class S extends F{
    public S() {
        super();
        System.out.println("子类构造方法");
    }
    {
        System.out.println("子类构造代码块");
    }
    static{
        System.out.println("子类静态代码块");
    }
}
public class Test {
    public static void main(String[] args) {
        S s = new S();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行结果：

先执行父类静态代码块，子类静态代码块，然后分别先执行父类构造代码块和父类构造方法，再执行子类构造代码块和子类构造方法。
当实例化多个对象时：

class F{
    public F() {
        System.out.println("父类构造方法");
    }
    {
        System.out.println("父类构造代码块");
    }
    static{
        System.out.println("父类静态代码块");
    }
}
class S extends F{
    public S() {
        super();
        System.out.println("子类构造方法");
    }
    {
        System.out.println("子类构造代码块");
    }
    static{
        System.out.println("子类静态代码块");
    }
}
public class Test {
    public static void main(String[] args) {
        S s = new S();
        System.out.println("===============");
        S s1 = new S();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

运行结果：

随着类的加载而加载，静态的还是只执行一次。之后还是先执行父类的构造代码块和构造方法，然后在执行子类的构造代码块和构造方法。其实也好理解，因为子类在实例化对象时，先要帮父类调用构造方法，而一个类实例对象的顺序是：静态代码块、构造代码块、构造方法，构造方法都执行完了，那么构造代码块肯定也执行完了。

2.protected关键字

这里直接演示一下protected
1.同一个包中的同一个类

2.同一个包中的不同类

3.不同包中的子类通过super来访问

int a = 10;
int b = 20;
a + b;
a>b;
1
2
3
4

3.继承方式

java不存在多继承，java中解决多继承是通过接口来实现的。
我们并不希望类之间的继承层次太复杂.，一般我们不希望出现超过三层的继承关系.。如果继承层次太多, 就需要考虑对代码进行重构了。
如果想从语法上进行限制继承, 就可以使用 final 关键字

4 final关键字

final关键可以用来修饰变量、成员方法以及类。
1.final修饰成员变量，表示常量(不能被修改)

2.java修饰类，表示此类不能被继承

我们平时使用的string类就是被final修饰的，不能被继承。

3.修饰方法表示该方法不能被重写(后序介绍)

5.组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。
继承是is-a的关系：猫继承动物类—>猫是动物。
组合是has-a的关系：学校由老师和学生组成。
组合：

class Students{

}
class Teachers{

}
class School{
    private Students[] students;//学生类 作为school类的一个数组 可以复用Students里的成员变量和方法
    private Teachers[] teachers;
}
class Primaryschool extends School{//学校可以是小学
    
}
public class Test {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。
这里转载一条很棒的链接，详细分析的继承与组合的优缺点继承和组合。

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔