永遠相信 美好的事情即將發生

默认初始化#

对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如

7.1访问限定符#

public：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

【说明】

protected主要是用在继承中，继承部分详细介绍

default权限指：什么都不写时的默认权限

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

7.2实现Java封装的步骤#

1.修改属性的可见性来限制对属性的访问（一般限制为private），例如：

1
public class Person {
2
    private String name;
3
    private int age;
4
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2.对每个值属性提供对外的公共方法访问，也就是创建一对赋取值的方法，用于对私有属性的访问，例如：

1
public class Person{
2
    private String name;
3
    private int age;
4
​
5
    public int getAge(){
6
      return age;
7
    }
8
​
9
    public String getName(){
10
      return name;
11
    }
12
​
13
    public void setAge(int age){
14
      this.age = age;
15
    }
16
​
17
    public void setName(String name){
18
      this.name = name;
19
    }
20
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

8.1 创建包#

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 io.github.sirens007 )

包名要和代码路径相匹配. 例如创建io.github.sirens007的包, 那么会存在一个对应的路径 io.github.sirens007来存储代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中.

即图中软件包，点击后输入 io.github.sirens007则会创建一个三级目录

8.2 import 关键字#

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。

在 Java 中，import 关键字用于导入其他类或包中定义的类型，以便在当前源文件中使用这些类型。

import 关键字用于引入其他包中的类、接口或静态成员，它允许你在代码中直接使用其他包中的类，而不需要完整地指定类的包名。

在 java 源文件中 import 语句必须位于 Java 源文件的头部，其语法格式为：

1
import package1[.package2…].(classname|*);

import 语句位于 package 语句之后：

1
// 第一行非注释行是 package 语句
2
package com.example;
3

4
// import 语句引入其他包中的类
5
import java.util.ArrayList;
6
import java.util.List;
7

8
// 类的定义
9
public class MyClass {
10
    // 类的成员和方法
11
}

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

可以使用 import语句来引入一个特定的类：

1
import  io.github.sirens007;

这样，你就可以在当前源文件中直接使用 sirens007 类的方法、变量或常量。

也可以使用通配符 * 来引入整个包或包的子包：

import io.sirens007.mypackage.*;

这样，你可以导入 io.sirens007.mypackage 包中的所有类，从而在当前源文件中使用该包中的任何类的方法、变量或常量。注意，使用通配符 * 导入整个包时，只会导入包中的类，而不会导入包中的子包。

在导入类或包时，你需要提供类的完全限定名或包的完全限定名。完全限定名包括包名和类名的组合，以点号 . 分隔

1
import java.util.ArrayList; // 引入 java.util 包中的 ArrayList 类
2
import java.util.*; // 引入 java.util 包中的所有类
3

4
import com.example.MyClass; // 引入 com.example 包中的 MyClass 类
5
import com.example.*; // 引入 com.example 包中的所有类

8.3 Package 的目录结构#

类放在包中会有两种主要的结果：

• 包名成为类名的一部分，正如我们前面讨论的一样。
• 包名必须与相应的字节码所在的目录结构相吻合。

下面是管理你自己 java 中文件的一种简单方式：

将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：

1
package vehicle;
2

3
public class Car {
4
   // 类实现
5
}

接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。

1
....\vehicle\Car.java

现在，正确的类名和路径将会是如下样子：

• 类名 -> vehicle.Car
• 路径名 -> vehicle\Car.java (在 windows 系统中)

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。

例如：有一个 io.github.test 的包，这个包包含一个叫做 Hello.java 的源文件，那么相应的，应该有如下面的一连串子目录：

1
....\io\github\test\Hello.java

编译的时候，编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件，输出文件的名字就是这个类型的名字，并加上 .class 作为扩展后缀。 例如：

1
package io.github.test;
2
public class Hello {
3

4
}
5
class Google {
6

7
}

现在，我们用-d选项来编译这个文件，如下：

$javac -d . Hello.java

这样会像下面这样放置编译了的文件：

1
.\io\github\test\Hello.class
2
.\io\github\test\Google.class

你可以像下面这样来导入所有 \io\github\test\ 中定义的类、接口等：

import io.github.test.*;

编译之后的 .class 文件应该和 .java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。

1
<path-one>\sources\io\github\test\Hello.java
2
<path-two>\classes\io\github\test\Google.class

这样，你可以将你的类目录分享给其他的编程人员，而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机（JVM）可以找到你程序中使用的所有类型。

9.1static 修饰成员变量#

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

它与类相关而不是与实例相关，即无论创建多少个类实例，静态变量在内存中只有一份拷贝，被所有实例共享。

重点：类的静态成员变量特性

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

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

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

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

类的加载和卸载

加载（Load）：当你第一次使用这个类（比如 new、访问静态变量/方法）时，JVM 的类加载器会把它加载到 方法区。

卸载（Unload）：当一个类不再被任何地方使用时，JVM 才有可能把它卸载。

9.2static 修饰成员方法#

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

重点：静态方法特性

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

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

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

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

5. 静态方法无法重写，不能用来实现多态(此处大家暂时不用管，后序多态位置详细讲解)。

补充第三点：

• 静态变量/方法（static）
  属于 类本身，不依赖某个对象，类一加载就存在。
  调用方式：类名.方法() 或者 对象.方法()（其实推荐用类名）。
• 非静态变量/方法（实例成员）
  属于 对象实例，必须通过 new 出来的对象才会存在。
  调用方式：对象.方法()。

**Q1:为什么静态方法不能访问非静态变量呢 **

因为静态方法执行的时候，对象可能还没有创建

eg:

1
class Demo {
2
    int age = 10;         // 非静态变量（实例变量）
3
    static int count = 0; // 静态变量
4

5
    static void printInfo() {
6
        System.out.println(age); // ❌ 报错！
7
    }
8
}

运行逻辑：

1. JVM 加载 Demo 类时，count 已经存在（方法区 / 元空间里）。
2. 但是 age 是实例变量，只有在执行 new Demo() 时，才会分配内存到堆里。
3. static void printInfo() 可能在没有任何对象的时候被调用，这时 JVM 不知道该取哪个对象的 age。

所以编译器直接禁止你在静态方法里访问 age。

Q2:. 静态方法中为什么不能调用任何非静态方法？

我们先复习一下静态和非静态方法

静态方法
属于类本身，类加载时就存在，不依赖对象。调用时 JVM 直接用「类信息」执行，不需要 new 对象。

非静态方法
属于对象实例，必须依赖对象才能调用。JVM 在调用时，默认会传入一个隐藏的 this 指针，告诉方法「我是谁」，这样方法才能访问对象里的实例变量。

他们的关键区别在于是否有this

调用非静态方法时，编译器会在字节码层面自动加上 this。
比如写：

1
obj.sayHello();

编译后相当于：

1
Demo.sayHello(obj);

调用静态方法时，不存在 this，因为它不依赖对象。

1
Demo.staticHello();

编译后就是单纯的 Demo.staticHello()，没有对象上下文

因此静态方法里没有this，所以编译器根本不知道你想让哪个对象去执行这个非静态方法。

解决办法：

方法一：在静态方法里创建对象

1
static void test() {
2
    Demo d = new Demo();
3
    d.sayHello(); // ✅ 通过对象调用非静态方法
4
}

方法二：把目标方法也改成静态

1
static void sayHello() {
2
    System.out.println("Hello from static method");
3
}
4

5
static void test() {
6
    sayHello(); // ✅ 直接调用
7
}

总结就是： **静态方法不能调用非静态方法，是因为静态方法没有 this，而非静态方法必须依赖 this 才能运行 **

9.3static 成员变量初始化#

初始化方法有以下：

1.就地初始化

2.通过get、set方法初始化

3.构造方法初始化（相对较少）

4.代码块初始化

10.1 代码块分类#

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

• 静态代码块（一般用于初始化静态成员变量）
• 非静态代码块/实例代码块/构造代码块
• 同步代码块…

代码块执行顺序#

静态代码块 -> 实例代码块 -> 构造方法

注意： 静态代码块只会执行一次（涉及知识点：双亲委派模型

补充：如果静态/实例代码块有平级，那么就和他们各自类型的先后顺序有关系

构造方法主要看调用了的哪个构造

注意事项

• 静态代码块不管生成多少个对象，其只会执行一次
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
• 实例代码块只有在创建对象时才会执行

1
public class Main{
2
    String number = "123";
3
    {
4
        number = "125";
5
        System.out.println("eg coder");
6
    }
7

8
    Main(String number){
9
        this.number = number;
10
        System.out.println("struction func");
11
    }
12

13
    static{
14
        String number = "124";
15
        System.out.println("static coder");
16
    }
17
}
18

19

20
//输出结果：
21
//static coder
22
//eg coder
23
//struction func