【169天】黑马程序员27天视频学习笔记【Day08-上】

叨逼叨两句

正式开始了，没有回头路了，勇往直前！！！

08-01：代码块的概述和分类

代码块的作用

代码块的主要作用是限定变量的生命周期，只在代码块内有效，出了就无效了。

代码块的分类

根据其位置和声明的不同进行划分。

1. 局部代码块

   • 在方法中出现，限定变量生命周期，及早释放，提高内存利用率。

2. 构造代码块（初始化块）

   • 在类中方法外出现，多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

3. 静态代码块

   • 在类中方法外出现，并加上static修饰。

   • 用于给类进行初始化，在加载的时候就执行，并且只执行一次。

   • 一般用于加载驱动。

4. 同步代码块（多线程再讲）

package test_heima_08;

public class Demo1_Student {
    public static void main(String[] args){
        Student s1 = new Student();
    }
}

class Student{
    
    private String name;
    private int age;
    
    public Student(){
        {
            System.out.println("局部代码块");
        }
        study();
    }
    
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public int getAge(){
        return age;
    }
        
    public static void study(){
        {
            int x = 3;    //局部代码块
    //        System.out.println(x);
        }
        
        //System.out.println(x);//局部代码块中的局部变量已经被内存释放
    }
    
    
    {
        System.out.println("构造代码块");
    }
    
    static {
        System.out.println("静态代码块");
    }
    
}

代码块的执行顺序

静态代码块——>构造代码块——>局部代码块

08-02：代码块练习

package test_heima_08;

class Demo02 {
    static {
        System.out.println("Demo02静态代码块");
    }
    
    {
        System.out.println("Demo02构造代码块");
    }
    
    public Demo02(){
        System.out.println("Demo02构造方法");
    }
    
}

public class Test_Demo02{
    static {
        System.out.println("Test_Demo02静态代码块");
    }
    
    public static void main(String[] args){
        System.out.println("主方法");
        Demo02 s1 = new Demo02();
        Demo02 s2 = new Demo02();
        
    
    }
}

08-（03-11）

继承的好处

1. 提高代码复用性

2. 提高代码的维护性

3. 让类与类之间产生了联系，是多态的前提

继承的坏处

1. 类的耦合性增强

开发原则

1. 高内聚、低耦合

2. 【耦合：类与类之间的关系】

3. 【内聚：自己完成某件事情的能力】

类的继承特点

1. Java只支持单继承、不支持多继承（一个儿子只能有一个爹）

2. Java支持多层继承（继承体系）

3. 想用共性功能，看最顶层父类；想用全部功能，看最底层子类

继承的注意事项

1. 子类不能继承父类的构造方法

2. 子类不能继承父类的所有非私有成员（成员变量和成员方法）

继承的使用场景

体现"is a"的关系，而非"has a"

继承中成员变量中的关系

1. 子类中出现与父类同名的变量，按“就近原则”，子类有就不用父类的了。【开发中不会干这种没意义的事】

this与super的区别

1. 调用成员变量/方法

   1. this既可以调用本类，也可以调用父类（其实是指调用继承自父类的成员）

   2. super只调用父类

2. 调用构造方法

   1. this只调用本类构造方法

   2. super只调用父类构造方法

继承中构造方法的关系

因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化前，父类必须先初始化。

父类没有无参构造方法的解决方案

具体看视频

1. super

2. this写固定值

3. super写固定值

super和this不能同时出现在一个构造方法

练习

1. 时刻记得，构造方法中有个隐藏的super（）。

2. 该题值得再看一次视频

   1. JVM调用了main方法，main方法进栈。

   2. main方法遇到Zi a = new Zi();然后加载Fu.class和Zi.class，此时静态代码块执行

   3. 开始执行子类构造方法，因为Java中是分层初始化的，先初始化父类，再初始化子类，所以先走父类构造，但是执行父类构造时，发现父类有构造代码块，于是先执行构造代码块

   4. 父类初始化结束后，子类初始化，先执行构造代码块，再执行构造方法。

package test_heima_08;

public class Test_Demo03 {
    public static void main(String[] args){
        Zi a = new Zi();
    }
}

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