第九节：类和对象【三】【static、代码块、对象的打印】

目录

🥇1.什么是封装

📘1.1封装的实现

🎒2.static成员

📒2.1 再谈学生类

​编辑

📗2.2 static修饰成员变量

2.3 static修饰成员方法

📕2.4 static成员变量初始化

🔲3. 代码块

📙3.1 代码块概念以及分类

📒3.2 普通代码块

📘3.3 构造代码块

📗3.4 静态代码块

📁4. 对象的打印

---

 

🌈上节课的封装我们学习了封装，让我们来回忆一下什么是封装！

🥇1.什么是封装

✅对类的细节进行隐藏，提供功能公开的接口来进行和数据进行交互！！

📘1.1封装的实现

class Person {
    private String name;
    public int age;

    private void eat() {
        System.out.println("吃饭！");
    }

    public void show() {
        System.out.println(name+" "+age);
    }
}

public class Tesk {
    public static void main(String[] args) {
        Person person = new Person();
        /*person.name = "zhangsan";
        person.eat();*/ //error
    }

}

🔺name 、eat这两个方法都已经被封装起来了 ，使用private关键字进行了封装。此时，name的权限就变小了。他只能在当前类当中才能访问

❗❗❗特别注意：

public----------哪里都可以访问

default---------包访问权限

private---------当前类中才能访问

🎒2.static成员

📒2.1 再谈学生类

class Student {
    private String name;
    private int age;
    private String classRoom; //上课的教室

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public  void doClass() {
        System.out.println("上课！");
    }
}

public class Tesk2 {
    public static void main(String[] args) {
        Student student1 = new Student("xiaowen", 10);
        Student student2 = new Student("xiaowen1", 20);
        Student student3 = new Student("xiaowen2", 15);
        System.out.println("fsfa");

    }
}

🙈假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，就没必要每次都写出来，只需要一次即可

✅之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

那么就可以修改代码：

private String classRoom;--------->private static String classRoom = "107java直播间";

 ➡️现在就不显示classroom了，那么classroom就在方法区。

📗2.2 static修饰成员变量

👉static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

class Student {
    public String name;
    public int age;
    public static String classRoom = "107java直播间"; //上课的教室

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public  void doClass() {
        System.out.println("上课！");
    }
}

✨当我们在输出的时候：

public static void main(String[] args) {
        System.out.println(Student.classRoom);
    }

静态的成员变量不属于对象，所以不用通过对象的引用来访问，直接可以通过类名就可以访问的

🔺【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

📜此时我们举一个极端的例子：

public static void main(String[] args) {
        Student student1 = null;
        System.out.println(Student.name);
    }

此时这个代码就会空指针异常，student1不指向任何对象。但是name属于student这个对象的，就会产生空指针异常

✅修改为：

public static void main(String[] args) {
        Student student1 = null;
        //System.out.println(Student.name);
        System.out.println(Student.classRoom);
    }

因为classroom不属于任何对象，它的调用是通过类名来调用的。虽然引用等于null，无所谓，因为在类名调用的时候 . 前面其实就是一个类型，它的类型也是student。

2.3 static修饰成员方法

➡️成员方法：静态成员方法/类方法、非静态成员方法

    //非静态成员方法
    public  void doClass() {
        System.out.println("上课！");
    }
    //静态成员方法
    public static void func() {
        System.out.println("staticFunc()");
    }

✨Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

public class Tesk2 {

    public static void main(String[] args) {
        Student.func();
    }
}

1️⃣在静态方法内部，不能直接调用非静态的成员方法

public class Tesk2 {
    public void mainStaticFunc() {

    }

    public static void main(String[] args) {
        mainStaticFunc();
    }
}

 

✅如果想要调用非静态方法： 依赖于对象的引用

public class Tesk2 {
    public void mainStaticFunc() {
    }

    public static void main(String[] args) {
        Tesk2 tesk2 = new Tesk2();
        tesk2.mainStaticFunc();
    }
}

 2️⃣在静态方法内部，不能够直接使用非静态的数据成员（静态方法里边是不能调用this的）

    //静态成员方法
    public static void func() {
        System.out.println(this.name);//error
        System.out.println(name);//error
    }

✅只要是非静态的数据成员，都需要通过对象的引用才能调用

    public static void func() {
        Student student = new Student("BIT",18);
        System.out.println(student.name);
    }

✅在普通的成员方法内部是可以调用静态方法的

class Student {
    //非静态成员方法
    public void doClass() {
        func();
    }
}

public class Tesk2 {
    public static void main(String[] args) {
        Student.func();

    }
}

👉总结：

🔺【 静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

🌈建议：获取静态的成员变量或者是设置静态的成员变量，此时的方法最好是静态的，否则你要是非静态的，必须要实例化对象

📕2.4 static成员变量初始化

📖静态成员变量的初始化分为：

1️⃣就地初始化：在定义时直接给出初始值

public static String classRoom = "107java直播间";

2️⃣默认初始化

3️⃣可以通过提供get和set方法来进行初始化

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

 4️⃣通过代码块进行赋值，继续往后看 :) ~~~

🔲3. 代码块

📙3.1 代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块（非静态代码块/实例化代码块）

静态块

同步代码块（后续讲解多线程部分再谈）

📒3.2 普通代码块

➡️普通代码块：定义在方法中的代码块

public class Main{
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        int x = 100 ;
        System.out.println("x2 = " +x);
    }
}
// 执行结果
x1 = 10
x2 = 100

📘3.3 构造代码块

➡️构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("带有两个参数的构造代码块！");
    }

    //实例代码块
    {
        name = "caocao";
        System.out.println("构造代码块/非静态代码块/实例化代码块！->初始化非静态的数据成员");
    }
    
}

public class Tesk2 {

    public static void main(String[] args) {
        Student student1 = new Student("xiaowen", 10);
        System.out.println(student1.name);
    }
}

 1️⃣由此代码可知：在调用构造方法之前，先执行的是实例代码块(非静态代码块)

由于在调用构造方法之前，先执行的是实例代码块，则最后打印不是caocao，而是xiaowen 

可以简单认为，编译器编译好代码之后，会把非静态代码块拷贝到构造代码块的最前面

2️⃣如果都是非静态的，那么看定义的顺序。谁在前，最后就是哪个值

📗3.4 静态代码块

➡️使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

class Student {
    public String name;
    public int age;
    public static String classRoom = "107java直播间"; //上课的教室


    //实例代码块
    {
        name = "caocao";
        System.out.println("构造代码块/非静态代码块/实例化代码块！->初始化非静态的数据成员");
    }
    //静待代码块
    static {
        System.out.println("静态代码块--》初始化静态数据成员/ 提前准备一些数据");
    }

    //构造方法
    public Student() {
        System.out.println("不带参数的构造方法！");
    }

}

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

 静态代码块先执行（大的角度--------先执行静态代码块、再执行非静态代码块、最后执行构造方法）

❗❗❗ 注意事项

静态代码块不管生成多少个对象，其 只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含 多个静态代码块，在编译代码时，编译器会按照定义的 先后次序依次执行(合并)

实例代码块只有在创建对象时才会执行

📁4. 对象的打印

public class Tesk {
    public static void main(String[] args) {
        Person person = new Person("zhangsan",10);
        person.setName("gaobo");
        System.out.println(person.getName());
        person.show();
        /*person.name = "zhangsan";
        person.eat();*/ //error
    }

}

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

// 打印结果：day20210829.Person@1b6d3586

➡️如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}
// 输出结果：[Jim,男,18]

✨总结：

对于你想输出一个对象的引用的值的时候，如果你没有自己写一个toS挺方法，那么就会调用Object这个类的方法。

如果自己写了，就会调用自己的！！！