static

static：静态

public class Person {
    String name;
    String country;
    String address;
    public Person(String name, String country, String address){
        this.name = name;
        this.country = country;
        this.address = address;
    }
    public static void main(String[] args) {
        Person p1 = new Person(name:"赵铁柱", country:"大清", address:"八大胡同");
        Person p2 = new Person(name:"李小花", country:"大清", address:"朝阳门");
        
        //大清亡了
        p1.country = "民国";
        p2.country = "民国";

        System.out.println(p1.country);
        System.out.println(p2.country);
    }
}
//输出：
//民国 
//民国

这个改法要改两次的原因是

这个改法的问题就是有多少人就要改多少次？

但是赵铁柱和李小花拥有的国家都是同一个国家，可以把国家的属性公共出来，这就可以用到static

静态变量

静态的内容在内存中是保留一份的，并且各个对象之间进行共享

public class Person {
    String name;
    static String country = "大清";//它是共享的
    String address;
    public Person(String name, String address){
        this.name = name;
        this.address = address;
    }
    public static void main(String[] args) {
        Person p1 = new Person(name:"赵铁柱", address:"八大胡同");
        Person p2 = new Person(name:"李小花", address:"朝阳门");
        
        //大清亡了
        p1.country = "民国";

        System.out.println(p1.country);
        System.out.println(p2.country);
    }
}
//输出：
//民国
//民国

原理：

使用p1.country = “民国"，不推荐这样使用静态变量（会产生p1中有country这样的误导）

推荐使用类名去访问静态的内容

public class Person {
    String name;
    static String country = "大清";//它是共享的
    String address;
    public Person(String name, String address){
        this.name = name;
        this.address = address;
    }
    public static void main(String[] args) {
        Person p1 = new Person(name:"赵铁柱", address:"八大胡同");
        Person p2 = new Person(name:"李小花", address:"朝阳门");
        
        //大清亡了
        Person.country = "民国";//推荐改法

        System.out.println(p1.country);
        System.out.println(p2.country);
    }
}
//输出：
//民国
//民国

特点：

1.数据共享

2.属于类的，并不属于对象

3.优先于对象产生

静态方法

静态方法属于类，可以直接通过 类名.方法名() 调用

静态方法中不能直接访问实例变量或实例方法（因为还没有对象），但可以访问静态变量/静态方法

常见使用场景：工具类的方法（如 Math.sqrt()）、工厂方法、main 方法

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

// 调用
int sum = MathUtils.add(3, 5);

main方法是静态的

public static void main(String[] args) {
    // 程序入口，无需创建对象即可由 JVM 调用
}

通用构造器vs静态构造器

用 static {} 定义，在类第一次加载时执行一次（优先于构造方法）。

用于静态变量的初始化或加载配置文件等。

public class Test {
    {
        System.out.println("这里是通用构造器");
    }
    static {
        System.out.println("这里是静态构造器");
    }
    public Test() {
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        new Test();//new这个对象就会自动执行构造方法
    }
}
//输出：
//这里是静态构造器
//这里是通用构造器
//构造方法

创建对象的过程（简单）：

1.静态构造器

2.通用构造器

3.构造方法 -> 创建对象

由于创建对象的过程是在静态内容加载完成之后，在静态方法和静态块里时不能使用this的（因为没有当前对象）

在后面的对象里可以正常访问静态内容，但是在静态内容中不可以访问对象里的内容

public class Test {
    public static void pen() {
        System.out.println("还我钱");
    }
    public static void main(String[] args) {
        pen();
        Test pen();//使用类名访问静态方法
    }
}

但是在静态方法里调用静态的东西是可以的

静态的内容使用类名访问

类型	归属	访问方式	内存位置	生命周期
实例变量/方法	对象	对象引用	堆中每个对象一份	随对象的创建和销毁
静态变量/方法	类	类名直接访问	方法区（一份）	类加载到类卸载

包和导包

包：本质上就是文件夹

作用：

1.避免类名冲突（不同包下可以有同名的类）

2.控制访问权限（protected、默认权限与包相关）

3.便于管理项目中的类

使用 package 语句，必须是 Java 源文件的第一条有效语句（注释除外）

在代码中需要写package 包名;

package com.xyq.dao;
//把entity包下的Person类导入到当前文件
import com.xyq.entity.Person;
//package表示声明，import表示导入
//必须先写package，再写import或者说package必须写在有效代码的第一行
public class TestPerson {
    public static void main(String[] args) {
        Person P = new Person();
    }
}

包命名规范

1.全部小写

2.顶级包名通常是公司/组织域名的倒写（如 com.alibaba、org.apache）

3.后续根据功能划分（如 com.example.controller、com.example.service）

导包：import 包+类;

不需要导包：

1.在自己包里

2.java.lang包下的所有内容都不需要导包

访问权限

1.public 公共的，所有人都可以访问

2.default 包访问权限，在自己包内可以随意访问

3.private 私有的

我们用的最多的是private和public

Java 提供了四种访问级别（按权限从大到小排列）：

修饰符	同一个类	同一个包（子类+非子类）	不同包的子类	不同包的非子类（任意类）
public	✅	✅	✅	✅
default（无修饰符）	✅	✅	❌	❌
private	✅	❌	❌	❌

1.public — 公共的

作用范围：所有地方（当前类、同包、不同包子类、不同包非子类）都可以访问。

修饰：类、成员变量、构造方法、成员方法。

注意：一个 .java 文件中最多只能有一个 public 类，且类名必须与文件名相同。

public class Car {                // public 类
    public String brand;          // public 属性
    public void run() {           // public 方法
        System.out.println("跑");
    }
}

2. default（包访问权限） — 无修饰符

作用范围：仅限同一个包内的任何类。

特征：不写任何修饰符就是 default。

不能修饰：接口中的方法（接口中方法默认 public abstract）。

package com.demo;
class Tool {              // default 类（外部类不能用 private/protected，只能是 public 或 default）
    void print() {        // default 方法
        System.out.println("只能在 com.demo 包内访问");
    }
}

3. private — 私有的

作用范围：仅限当前类内部。

修饰：成员变量、成员方法、内部类、构造方法。

最严格的封装：外部完全不能直接访问，通常通过 public 的 getter/setter 间接访问。