学习大数据的第10天——代码块和继承的一些相关的知识
代码块
局部代码块：
在方法中出现，限定变量的生命周期，及早释放，提高内存的利用
在同一个类中的同一个方法中，如果存在多个局部代码块，执行顺序是自上而下的。
构造代码块：（在创建对象的时候调用）
定义在类中方法外。当一个类中既存在构造代码块也存在构造方法的时候，在创建对象时，会先执行构造代码块，后执行
构造方法。
无论类中有多少个构造代码块，构造代码块之间会先进行自上而下的顺序执行，然后再执行构造方法。
构造代码块 – 构造方法
静态代码块：
在类中方法外定义，并加上static修饰。
静态代码块是优先于其他代码块之前执行，
静态代码块 – 局部代码块 – 构造代码块 – 构造方法
在加载的时候执行，并且只执行一次
public class CodeDemo {
/**
* 静态代码块
*/
static {
int a = 22;
System.out.println(22);
}
CodeDemo(){
int y = 300;
System.out.println(y);
}
/**
* 定义在类中方法外，使用大括号括起来的代码，称之为构造代码块
*/
{
int x = 200;
System.out.println(x);
}
{
int x = 400;
System.out.println(x);
}
{
int x = 500;
System.out.println(x);
}
/**
* 静态代码块
*/
static {
int a = 11;
System.out.println(a);
}
public static void main(String[] args) {
/**
* 局部代码块
*/
{
int x = 10;
System.out.println(x);
}
// System.out.println(x);
{
int y = 20;
System.out.println(y);
}
{
int z = 30;
System.out.println(z);
}
CodeDemo codeDemo = new CodeDemo();
CodeDemo codeDemo1 = new CodeDemo();
// {
// int z = 40;
// System.out.println(z);
// }
}
}
输出的结果：
22
11
10
20
30
200
400
500
300
200
400
500
300
记住静态代码块是跟着类加载而加载出来的
当静态方法跟main方法在同一个类的时候，则这个static代码块是最先运行的
自己练习下列代码块的顺序：（答案自己运行一下多了解，就可以知道代码块的运行顺序）
package com.shujia.yl.day10;
class Student2{
static {
System.out.println("这是在Student2类中静态代码块");
}
Student2(){
System.out.println("这是Student2类中的无参构造方法");
}
{
System.out.println("这是在Student2类中的构造代码块");
}
}
public class CodeTest {
static {
System.out.println("这是在CodeTest类中的静态代码块");
}
public static void main(String[] args) {
System.out.println("开始执行main方法");
{
System.out.println("这是在CodeTest中的局部代码块");
}
Student2 student2 = new Student2();
}
}
通过观察我们发现，name和age这两个成员变量，以及study()学习方法都是相同的
如果我们还继续定义其他的儿子，其他的父亲等等这些类，每定义一次这样的类，是不是就要把这些重复的内容再写一遍。
感觉这样很麻烦。怎么去改进呢？
能不能把这些相同的内容定义到一个独立的类中，然后，让其他的类与这个独立的类产生一个关系，建立好这个关系之后呢，
这些其他的类就具备了这个独立的类的功能。
为了实现这样的基数，java提供了一个技术手段给我们使用，也是一个思想：继承
父亲：
2个儿子
继承如何使用代码表示呢？
代码的格式是什么样子呢？
语句格式：class 子类名 extends 父类名{…}
要实现一个继承关系至少需要2个类
class Fu{}
class Zi extends Fu{}
class Zi extends Fu{}
这里的Zi我们称之为子类，派生类，
这里的Fu我们称之为父类，超类，基类
继承
把多个类相同的内容提取到另外一个类中，然后使用关键字extends来实现继承
如何实现：
利用java提供的关键字：extends来实现继承
语句格式：
class 子类名 extends 父类名{}
继承的好处：
1、提高了代码的复用性 看一看父类
2、提高了代码的维护性 只需要修改父类的内容
3、让类与类之间产生了继承关系，为了后面多态做铺垫（要有继承才能有多态）
继承的坏处：
1、类的耦合性增强了。（内聚）
开发的原则：
低耦合，高内聚
耦合：类与类之间的关系
内聚：类自己本身可以完成的事情
Java中继承的特点：
1、Java中的类class只支持单个继承，不允许多个继承
2、Java中的类支持多层继承（形成了一个继承体系）
使用继承时所需要的注意事项：
1、要想初始化子类，必须先初始化父类 ******
举例：现有父亲，才能有儿子
2、子类只能继承父类的非私有的成员（成员变量和成员方法）
3、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
因为要想初始化子类，必须先初始化父类，是通过构造方法进行初始化的。
4、不要为了部分的功能而去使用继承
class Father5{
int num = 20;
private int num2 = 30;
Father5(){
System.out.println("这是父亲的无参构造方法");
}
private void fun1(){
System.out.println(num);
}
}
class Son5 extends Father5{
public void fun2(){
System.out.println(num);
// System.out.println(num2); // 子类不能继承父类的成员变量
}
}
public class ExtendsDemo4 {
public static void main(String[] args) {
Son5 son5 = new Son5();
son5.fun2();
// son5.fun1(); // 子类不能继承父类的私有成员方法
}
}
继承的使用注意事项2：
类的组成：
成员变量
构造方法
成员方法
引入了继承，我们需要注意在写代码的过程中考虑继承关系带来的影响
继承与成员变量之间的关系：
1、当子类中的成员变量与父类中的成员变量名字一样的时候
查找：（就近原则）
1）先在方法的局部范围内进行查找，如果找到就返回
2）如果在方法局部范围找不到，去本类中成员位置上查找，如果找到就返回
3）如果在中成员位置上找不到，去父类中成员位置上查找，如果找到就返回
4）如果在父类中成员位置上找不到，报错。
2、当子类中的成员变量与父类中的成员变量名字不一样的时候，使用什么变量名，就访问谁
继承中出现的问题：
我们现在不仅仅要输出局部范围内的num，我们还想输出父类中num,怎么办呢？
如果有一个东西，根this相似，也可以代表父类的引用，通过这个东西去访问父类中的数据就好了。
Java替你考虑到了这个问题，提供了一个关键字给我们使用：super
面试题：this关键字与super关键字的使用区别？
this代表的是调用该类的当前对象
super代表的是父类存储空间的标识（父类的引用，可以操作父类的成员）
怎么用呢？
1、访问成员变量
this.成员变量 访问的是本类中的成员变量
super.成员变量 访问的是父类中的成员变量
2、访问构造方法
this(…)
super(…)
3、访问成员方法
this.成员方法()
super.成员方法()
继承与构造方法的关系：
1、要想初始化子类，必选先初始化父类
2、为什么？
因为子类会继承父类的数据，甚至可能会使用父类的数据
所以在子类初始化之前，一定会先完成父类的初始化
注意：
每个子类的构造方法的第一句话默认是super().
class Father8 {
int age;
Father8() {
System.out.println("父类中的无参构造方法");
}
Father8(String s) {
System.out.println("这是父类带参数的构造方法" + s);
}
}
class Son8 extends Father8 {
Son8() {
System.out.println("子类的无参构造方法");
}
Son8(String s) {
System.out.println("子类带参数的构造方法" + s);
}
}
public class ExtendsDemo7 {
public static void main(String[] args) {
Son8 s1 = new Son8("王宇");
}
}
这里创建一个子类的对象，JVM会先将父类先构造，也就是先运行父类的构造方法，再运行子类的构造方法。
当父类中没有无参构造方法的时候，怎么办呢？
1、使用super关键字带参数的形式访问父类的带参数构造方法
2、子类通过this关键字调用本类的其他构造方法
注意，本类其他构造方法也必须可以访问父类拥有的构造方法
使用this关键字间接的调用父类的构造方法
无论在哪里调用父类的构造方法，只要最后保证在子类构造方法内容执行之前完成了父类的初始化就可以了
3、super(…)或者this(…)必须出现在第一条语句上
2、否则就会出现父类的数据进行了多次初始化
（重点）每个类只能初始化一次、
class Father9 {
int age;
// Father8() {
// System.out.println("父类中的无参构造方法");
// }
Father9(String s) {
System.out.println("这是父类带参数的构造方法" + s);
}
}
class Son9 extends Father9 {
Son9() {
super("你好");
System.out.println("子类的无参构造方法");
}
Son9(String s) {
this();
// super("你也好");
System.out.println("子类带参数的构造方法" + s);
// this();
}
}
public class ExtendsDemo8 {
public static void main(String[] args) {
Son9 s1 = new Son9("xxx");
}
}
输出的结果：
这是父类带参数的构造方法你好
子类的无参构造方法
子类带参数的构造方法xxx
继承与成员方法的关系：
1、当子类的成员方法名与父类成员方法名不一样的时候，该调用谁就调用谁的
2、当子类的成员方法名与父类成员方法名一样的时候，怎么办呢？（就近原则）
1)现在本类中查找，如果有就调用，如果没有去父类中查找，
2)如果父类中有方法，就调用父类的
3)如果连父类中都没有要调用的方法名，报错，提示找不到方法。
子类的方法名能不能和父类方法的声明一样？
如果子类的方法声明与父类的方法声明一样，这样的现象叫做方法的重写。
重写现象是发生在继承的关系中。
面试题：
重写与重载的区别：
重写是发生在继承的关系的关系中，重载是发生在本类中。
重载是方法名一致，参数列表不一致就是重载。
重写是方法名，参数列表，返回值都一样，实现不一样，叫方法的重写。
重载的英文单词：overload
重写的英文单词：override
生活中有哪些重写的案例？
水杯–保温杯
class OldPhone{
public void call(String name){
System.out.println("给"+name+"打电话");
}
}
class newPhone extends OldPhone{
@Override
public void call(String name) {
super.call(name);
System.out.println("看抖音");
}
// public void call(String name){
// System.out.println("打电话给"+name);
// System.out.println("看抖音");
// }
}
public class ExtendsDemo10 {
public static void main(String[] args) {
newPhone newPhone = new newPhone();
newPhone.call("xxx");
}
}
面试题
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
Zi z = new Zi(); 请执行结果。
A:静态随着类的加载而加载。
B:静态代码块 -- 构造代码块 -- 构造方法的执行流程
静态代码块 -- 构造代码块 -- 构造方法
C:只要有子父关系，肯定先初始化父亲的数据，然后初始化子类的数据。
结果：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
面试题
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}
铺垫的小知识：
第一个：成员变量有基本类型和引用类型的。
class Demo {
//基本类型
int x = 10;
//引用类型
Student s = new Student();
}
第二个：类的初始化过程
加载class文件
堆中开辟空间
变量的默认初始化
变量的显示初始化
构造代码块初始化
构造方法初始化
第三个：遇到extends，就要知道，先初始化父类数据，然后初始化子类数据。
分层初始化。
super在这里仅仅表示要先初始化父类数据。
记住一个原理：
一个类的初始化过程：
1、栈开辟空间
2、堆开辟空间给对象
3、成员变量的值是系统默认值
4、成员变量显式赋值
5、构造方法赋值
小训练：下图代码的运行结果YXYZ
class X {
Y b = new Y(); // 1
X() {
System.out.print("X"); // 3
}
}
class Y {
Y() {
System.out.print("Y"); //2
}
}
class Z extends X{
Y y = new Y();
Z(){
// super(); //这里的super()存在的意义不大 因为已经初始化过了。
System.out.println("Z");
}
}
public class ExtendsTest2{
public static void main(String[] args) {
new Z();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
