第九节：类和对象【三】【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 = 1003.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这个类的方法。
如果自己写了，就会调用自己的！！！