【JAVA】java类与对象（万字讲解)

Java 是一门纯面向对象的语言 (Object Oriented Program ，简称 OOP) ，在面向对象的世界里，一切皆为对象。面 向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情 。用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好

1.2 面向对象与面向过程

1. 传统洗衣服过程

传统的方式： 注重的是洗衣服的过程 ，少了一个环节可能都不行。

而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另一种放方式。

按照该种方式来写代码，将来 扩展或者维护起来会比较麻烦。

2. 现代洗衣服过程

以 面向对象方式来进行处理，就不关注洗衣服的过程 ，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的 。

注意： 面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

二：类定义和使用

面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。

上图左侧就是 对洗衣机简单的描述，该过程称为对洗衣机对象 ( 实体 ) 进行抽象 ( 对一个复杂事物的重新认知 ) ，但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java 语言。

2.1：简单认识类

类是用来对一个实体 ( 对象 ) 来进行描述的 ，主要描述该实体 ( 对象 ) 具有哪些属性 ( 外观尺寸等 ) ，哪些功能 ( 用来干啥) ，描述完成后计算机就可以识别了。

比如：洗衣机，它是一个品牌，在 Java 中可以将其看成是一个类别。

属性：产品品牌，型号，产品重量，外观尺寸，颜色 ...

功能：洗衣，烘干、定时 ...

2.2：类的定义格式

在 java 中定义类时需要用到 class 关键字 ，具体语法如下：
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
class 为定义类的关键字， ClassName 为类的名字， {} 中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

注意：类是更复杂的结构体最核心的区别就是类中可以有属性和方法

这样也有个好处：内聚性就更高。

class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width; // 宽
public double height; // 高
public String color; // 颜色
public void washClothes(){ // 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){ // 脱水
System.out.println("脱水功能");
}
public void setTime(){ // 定时
System.out.println("定时功能");
}
}
采用 Java 语言将洗衣机类在计算机中定义完成，经过 javac 编译之后形成 .class 文件，在 JVM 的基础上计算机就可以识别了。

注意事项：

类名注意采用大驼峰定义

成员前写法统一为 public ，后面会详细解释

此处写的方法不带 static 关键字 . 后面会详细解释

类定义多注意事项：
1：定义类的时候一般是一个文件只能定义一个类。(一个文件也可以定义多个类但是要求一个文件中，只能有一个类设定为public)

2：当指定public的类之后当前文件夹必须和public的类名一致的（idea帮助外面创建好了）

3：java中没有声明这样的说法

eg：举个例子

定义一个Dog类：

public class Dog {  
    public String name;  
    public String category;  
    public int year;  
  
    public void brak() {  
        System.out.println("汪汪汪");  
    }  
  
    public void eat(String food) {  
        System.out.println("正在吃" + food);  
    }  
}

定义一个洗衣机类：

public class WashMachine {  
    public String name;  
    public String brand;  
    public int price;  
    //创建方法  
    public void wash(){  
        System.out.println("洗衣方法");  
    }  
    public void dry(){  
        System.out.println("甩干功能");  
    }  
    public void settime(){  
        System.out.println("定时功能");  
    }  
}

定义一个日期类

public class Date {  
    public int year;  
    public int month;  
    public int day;  
  
    public void setDate(int y, int m, int d) {  
        year = y;  
        month = m;  
        day = d;  
    }  
    public void Dateprint(){  
        System.out.println(year +","+month+","+day);  
    }  
  
    public static void main(String[] args) {  
        Date date = new Date();  
     date.setDate(2025,9,15);  
     date.Dateprint();  
    }  
  
}

注意事项：

1. 一般一个文件当中只定义一个类

2. main 方法所在的类一般要使用 public 修饰 ( 注意： Eclipse 默认会在 public 修饰的类中找 main 方法 )

3. public 修饰的类必须要和文件名相同

4. 不要轻易去修改 public 修饰的类的名称，如果要修改，通过开发工具修改 ( 给同学演示 ) 。

三：类的实例化（创建对象）

具体是要使用对象的成员（属性和方法）
. 成员访问运算符
现在的调用方法对象名.方法（参数）

之前调用方法：
方法（参数）
为什么呢？
有没有static 没有static必须按照对象名.方法（参数）
有static就不需要对象名。

3.1：什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型 ，与 int ， double 类似，只不过 int 和 double 是 java 语言自带的内置类型，而类是用户自定义了一个新的类型，比如上述的：PetDog 类和 Student 类。它们都是类 ( 一种新定义的类型) 有了这些自定义的类型之后，就可以使用这些类来定义实例 ( 或者称为对象 ) 。

用类类型创建对象的过程，称为类的实例化 ，在 java 中采用 new 关键字，配合类名来实例化对象。创建的对象就是实例

public void eat(String food){  
    //方法中可以直接使用前面创建的成员变量（属性）  
    System.out.println(name+ "正在吃"+food);//这个名字就体现到了  
    //运行：  
    //大黄正在吃狗粮
再练习一个：
Dog dog1 = new Dog();  
dog1.name="毛毛";  
dog1.eat("肉");
//运行：
//毛毛正在吃肉

每个对象中，都会吧包含独列的一组属性在里面。

用dog调用eat，就是根据dog中的引用找到对应的name

使用dog1调用eat，就是根据dao1的引用找到对应的name

注意事项

1 new 关键字用于创建一个对象的实例.

2 使用 . 来访问对象中的属性和方法.

3 同一个类可以创建多个实例.

类中也有方法：
jvm中也有一种专门的内存的空间：方法区一个类中的方法，都是只在内存中有一份的，但被所有对象共用。
idea中会把成员变量用紫色标识出来

3.2 类和对象的说明

1. 类只是 一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员 .

2. 类是一种自定义的类型 ，可以用来定义变量 .

3. 一个类可以实例化出多个对象， 实例化出的对象占用实际的物理空间，存储类成员变量

4. 做个比方。 类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图 ，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

四：this引用

4.1：为什么要有this引用

先看一个日期类的例子
public class Date {  
    public int year;  
    public int month;  
    public int day;  
  
    public void setday(int year,int month,int day){//设置日期，不然都是空  
  
//        year=year;  
//        month=month;  
//        day=day;  
        //运行 0-0-0        
        this.year=year;  
        this.month=month;  
        this.day=day;  
        //this 这是一个特殊的引用，只是在方法中使用，作用就是表示当前的实例  
    }  
    public void printDate() {  
        System.out.println(year+"-"+month+"-"+day);  
    }  
  
    public static void main(String[] args) {  
        Date date=new Date();  
        date.setday(2025,9,16);//  
  
        date.printDate();  
    }  
}

以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过Date类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。

但是细思之下有以下两个疑问：

1.形参名不小心与成员变量名相同：
public void setDay(int year, int month, int day){

year = year;

month = month;

day = day;

}
那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？估计自己都搞不清楚了。

2. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和printDate函数如何知道打印的是那个对象的数据呢？

一切让 this 引用来揭开这层神秘的面纱。

4.2：什么是this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}
注意：this引用的是调用成员方法的对象
public static void main(String[] args) {
Date d = new Date();
d.setDay(2020,9,15);
d.printDate();
}
//this 这是一个特殊的引用，只是在方法中使用，作用就是表示当前的实例

//通过date来调用setDate的date这一个引用就是setDate中的this
就是this-》（指向）data或者this-》date1

this 引用的特性
1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
2. this只能在"成员方法"中使用（不能在main中，不能在static修饰的方法中。）
3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象（this的内容不能修改）
4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法，this负责来接收

在代码层面来简单演示 ---> 注意：下图右侧中的 Date 类也是可以通过编译的

五：对象的构造及初始化

5.1：初始化

初始化：设置初始值，设置变量都要设置初始值。
eg:要让代码通过编译，非常简单，只需在正式使用a之前，给a设置一个初始值即可。如果是对象：
Date date = new Date（），此处只是给date这个引用初始化。
Date date=new Date();  
date.setday(2025,9,16);//  
date.printDate();
需要调用之前写的 SetDate 方法才可以将具体的日期设置到对象中。

5.2：构造方法

1：概念

构造方法 ( 也称为构造器 ) 是一个特殊的成员方法， 名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次 。

eg：

不需要自己调用，idea编译器自动执行我们就不需要调用setday方法

然后调用printDate就打印出来我们构造方法的年月日。
可以给构造函数指定参数。

全局：
public class Date {  
    public int year;  
    public int month;  
    public int day;  
  
    public void setday(int year,int month,int day){//设置日期，不然都是空  
//出现参数和变量名字一样 就可以使用this  
//        year=year;  
//        month=month;  
//        day=day;  
        //运行 0-0-0        this.year=year;  
        this.month=month;  
        this.day=day;  
        //this 这是一个特殊的引用，只是在方法中使用，作用就是表示当前的实例  
    }  
    public void printDate() {  
        //如果方法中不存在局部变量名字和成员变量冲突，不写this也可以  
        System.out.println(year+"-"+month+"-"+day);  
    }  
    public Date(){  // 无参构造方法
        year=2024;  
        month=11;  
        day=11;  
        System.out.println("调用构造方法");  
    }  
    public Date(int year,int month,int day){  // 带有三个参数的构造方法
        this.year=year;  
        this.month=month;  
        this.day=day;  
        System.out.println("调用第二个构造方法");  
    }  
  
  
    public static void main(String[] args) {  
  
//        Date date=new Date();//第一个构造方法  
//        date.printDate();//第一个构造  
  
//       Date date=new Date(2024,2,12);//这个就是第二个参数构造  
//       date.printDate();//第二个  
  
      // date.setday(2025,9,16);这个就是设置参数set，然后打印  
      // date.printDate();  
  
       // Date date2=new Date();        
       //date2.setday(2025,9,17);       
       // date2.printDate();    }  
}
上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载

2：特性

特性
1. 名字必须与类名相同
2. 没有返回值类型，设置为void也不行
3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

5.如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

eg：
public class Date {  
    public int year;  
    public int month;  
    public int day;  
  
    public void setday(int year,int month,int day){//设置日期，不然都是空  
//出现参数和变量名字一样 就可以使用this  
//        year=year;  
//        month=month;  
//        day=day;  
        //运行 0-0-0        this.year=year;  
        this.month=month;  
        this.day=day;  
        //this 这是一个特殊的引用，只是在方法中使用，作用就是表示当前的实例  
    }  
    public void printDate() {  
        //如果方法中不存在局部变量名字和成员变量冲突，不写this也可以  
        System.out.println(year+"-"+month+"-"+day);  
    }
public static void main(String[] args) {  
    Date d=new Date();  
    d.printDate();

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
6. 构造方法中，可以通过this调用其他构造方法来简化代码

public class Date {
public int year;
public int month;
public int day;
// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
public Date(){
//System.out.println(year); 注释取消掉，编译会失败
this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}

注意：

this(...) 必须是构造方法中第一条语句

不能形成环

public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

5.3：代码块初始化

    //代码快初始化
{
    year=2025;
    month=9;
    day=10;
   System.out.println("代码块初始化");
}

直接使用{}创建变量。

5.4：就地初始化

在声明成员变量时，就直接给出了初始值。

注意：三种初始化顺序：
1：就地初始化
2：代码块初始化 =接下来后面执行的逻辑会覆盖前面的
3：构造方法

5.5：idea快捷键创建构造方法

    //idea也能快速生成  alt+ins


    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

六：对象打印

6.1：使用toString

toString是一个特殊的方法当打印对象的时候编译器会自动调用toString，把对象转换为String：

public class Date {  
    public int year=2022;  
    public int month=9;  
    public int day=4;
    
    public void setday(int year, int month, int day){//设置日期，不然都是空  
//出现参数和变量名字一样 就可以使用this  
//        year=year;  
//        month=month;  
//        day=day;  
        //运行 0-0-0        this.year=year;  
        this.month=month;  
        this.day=day;  
        //this 这是一个特殊的引用，只是在方法中使用，作用就是表示当前的实例  
    }
    public void printDate() {  
    //如果方法中不存在局部变量名字和成员变量冲突，不写this也可以  
    System.out.println(year+"-"+month+"-"+day);  
}
public String toString(){  
    return year+"-"+month+"-"+day;  
}  //固定写法
public static void main(String[] args) {  
    Date date=new Date();  
    System.out.println(date);
    }

idea也可以自动生成 （还是alt+ins）
//也有快捷键alt+ins  
@Override  //在一个方法或者类上面 可以添加@xxxxx，这样的语法规则，称为注解，相当于对于这个类/方法进行补充说明
public String toString() {  
    return "Date{" +  
            "year=" + year +  
            ", month=" + month +  
            ", day=" + day +  
            '}';  
}

步骤：

运行：

小题：

错题：1：一个类只能创建一个实例化对象（不可以，我们可以创建date1 date2 多个引用，使用同一个类）

2：一个引用可以同时指向多个对象。（不可以，地址会发生改变如果我们重新指向新对象，堆上面就会开辟一片内存，给引用传地址，然后引用的地址就会发生改变，就不可以，但是两个引用可以指向同一个对象）

3：person p=null 表示p这个引用指向空对象（错 java中不存在空对象，可以认为p不指向任何对象，也可以说是一个空引用）

4：一个类没有定义构造方法，该类就不会默认生成构造方法（错 idea会自动生成构造方法，000）

七：包（package）

7.1：包的概念

创建目录，把一些有相关联关系的类，放到目录当中，java就把这样的管理类的目录，称为包。

7.2：包的创建

代码上方idea就会自动添加package语句，来进行声明这个类，属于那个包。

包右键 open in explorer 找到文件目录
包就是目录，可以帮助我们组织代码结构

这个explorer就是window自带的文件资源管理器。

由于包中包含一个文件，所以显示的时候就会简化显示。

如果包含多个包，就不会这样了，就按照目录排序了。

使用包的时候，有一个约定俗称的规则：
每一个程序的包名都是唯一的 =>使用公司/组织的域名倒叙形式来表示。（com.sougo）

7.3：包的用处

别人写的代码，通常会使用包组织起来。

要想使用别人的代码，就需要在你当前代码，导入对于的包。

导入Date类。（这个import Scanner也用过，idea自动生成）存在感不多哈哈哈。

如果idea没有自动，我们可以手动添加。（alt+回车）

import java.util.*;//*相当于通配符，导入该包的中的所有类。

有好有坏，实际开发中如果这么写，就会吧没有用的包导入进去了。

引入包：不仅能够使类得到整理，更干净整洁
也有一个作用可以使当前名字得到管理。（避免名字出现冲突）

如果自己写一个Date类，别人也写一个Date，导入的是那个包就无法确定。编译器就无法正确解析。（类相同，可以包不能相同）

package object;
import java.util.Date;
public class Package {
    public static void main(String[] args) {
        //使用一下java标准库的Date
        //java.util.Date date=new java.util.Date();
        Date date = new Date();
        System.out.println(date);
    }
}
导入Date包然后我们就可以使用里面的类、变量。

运行：

小建议：就是我们导入包不要使用通配符，使用那个包导入那个。

7.4：常见的包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入。

2. java.lang.reflect:java 反射编程包 ;

3. java.net: 进行网络编程开发包。

4. java.sql: 进行数据库开发的支持包。

5. java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要

6. java.io:I/O 编程开发包。

八：封装（重点）

8.1：封装的概念

把一些细节隐藏起来，简化程序员思考负担。

广义：把细节藏起来创建方法就是把方法实现的细节藏起来把类实现的细节藏起来实现网络协议也是把下层协议藏起来
有狭义：专门把类这一种情况，把类实现的细节藏起来：就是把类中的方法和属性（只能在类内部使用外面感知不到~~~）

8.2：限定符

private 修饰属性/方法，只能在类内部使用的

：被封装起来了，

public 修饰属性/方法，可以在类外部使用的

：外面仍然能使用

仍然需要保留一部分内容供外面使用，比如笔记本的键盘，usb接口，耳机接口......

通常的原则：

1：哪些属性/方法要private，哪些要public，取决于实际使用的代码场景

2：原则上，一般属性需要private（属性一般无脑设），方法有些设为public，有些需要private。（就看用户需求）

比如：给电脑插上显示器=》这种情况就是public

给电脑更换cpu 内存显卡 =》这种情况就需要封装起来使用private。cpu很娇贵的，操作不当就报废了。

8.3：private的实例

代码解释：

创建了一个Student类：
package object;

public class Student {
    //变量的都可以封装
    private int id ;

    private String name;

    private int age;

    private String gender;//性别， gender，取值应该是male 和 female ，不要写man、woman

    private double score;

    public void homework(){
        System.out.println("同学正在做作业");
    }//方法可以public
    public void study(){
        System.out.println("学习");
    }

}
然后我们转到package类：（图片看，会出现报错信息）

报错信息就是Student类我们把name变量封装了，外部就不可以使用。

我们再修改一下把Student中的类中变量修改为public：

这样就不会报错，因为我们修改的name变量类型。

private：修饰的属性/方法只能在类内部使用（只能在自己类使用）
不影响成员变量的生命周期（跟随整个对象，对象没有人使用就会被gc自动回收掉）
成员变量作为对象的一部分在堆上。局部变量在栈上在每个方法的栈帧上。
局部变量作用域只是局限于当前{}，生命周期也是局限于当前{} 。

还有一种方法，就是使用方法间接调用private变量

上代码：

第一个红框：就地初始化

第二个：Study方法

package类；

运行：

创建变量肯定是要使用的，就是给他做出限制。如果封装了就不能直接使用，需要用方法去调用使用。（就相当使用public方法，这样的方法背后就是在使用private成员）

直接使用变为间接使用。

还有在Student中创建的成员变量String gender（性别），怎么去创建或者打印呢？

这是Student类，中创建set、get方法去创建、打印。

转到package项目中：

就用这样，不能直接使用被封装的gender成员变量，我们就使用方法初始化、然后打印。

idea也能自动生成get set

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

九：Static成员

9.1：static修饰成员变量

java中static 修饰属性 =》所有该类的属性，公用同一份属性：
package object;

public class Test {
    public int n=10;
    static public int m=20;

    public static void main(String[] args) {
        Test t1=new Test();
        t1.n=100;
        t1.m=200;

        Test t2=new Test();
        t2.n=1000;
        t2.m=2000;

        System.out.println("t1.n="+t1.n);
        System.out.println("t1.m="+t1.m);
        System.out.println("t2.n="+t2.n);
        System.out.println("t2.m="+t2.m);
    }
}
运行：

t1.m和t2.m访问的是同一个m
图片更有说服力：

int n=100;不发生改变，两个人都定义了但是m在方法区，两个人都调用了同一个m。

【静态成员变量特性】（还有一种类属性的说法）

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

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

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

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )
（不加static的属性是伴随对象的一生，new出对象到这个对象GC）

（加static的属性是伴随类的一生程序启动开始、到程序结束为止。）

9.2：static修饰成员方法

static修饰方法和类相似，而和实例就无关了。

static 修饰属性，决定属性储存位置

static修饰方法，不影响方法的储存位置。（方法都是在方法区，都是和类在一起）

没有static，就能通过实例化.方法名的方式来调用。此时方法内部也可以实现实例属性，

其他的实例方法有static，就能通过类名.方法名的方式来调用。

public void func(){
        System.out.println(n);
        System.out.println(m);
    }

    public void fun2(){
        func();
        staticfun();
    }
    //类方法中
    //类方法只能使用类属性，不能使用实例属性。
    public static void staticfun(){
        //不能调用普通方法
        func();
图片：

普通方法可以调用方法和static修饰的方法

但是static修饰的方法不能调用普通方法

static修饰的方法，里面没有this！！！！

注意：

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

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

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

就是

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

十：代码块

10.1：代码块概念以及分类

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

普通代码块

构造块

静态块

同步代码块

10.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

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

10.3：构造代码块

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

在类的定义中，写{}；

{}里面写的内容就是针对成员的初始化操作；

执行时机是在new对象的时候，在构造方法之前。
public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

10.4：静态代码块

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

执行时机是在类加载的时候。

注意事项

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

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

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

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

静态代码块是比构造代码块先执行。

十一：总结

本文系统地介绍了Java面向对象编程(OOP)的核心概念。主要内容包括：1. 面向对象基础：通过洗衣机案例对比面向过程与面向对象的区别，强调对象交互的思想；2. 类与对象：详细讲解类的定义格式、成员变量/方法、实例化过程，以及类与对象的关系；3. 封装特性：介绍private/public修饰符的使用，通过getter/setter方法实现数据隐藏；4. 构造方法：说明构造方法的特点、重载规则和初始化顺序；5. 特殊关键字：深入解析this引用和static修饰符的用法及注意事项；6. 代码块：区分普通代码块、构造代码块和静态代码块的不同作用；7. 包管理：解释包的创建、导入和使用规范。文章采用大量代码示例辅助理解，并强调面向对象设计的内聚性、封装性和重用性等优势。