目录
[1、default 就是啥都不写的那种](#1、default 就是啥都不写的那种)
[2、private 私有](#2、private 私有)
[3、public 公开](#3、public 公开)
[4、protected 受保护的](#4、protected 受保护的)
[1、static 静态](#1、static 静态)
[2、final 最终](#2、final 最终)
[3、abstract 抽象](#3、abstract 抽象)
[4、synchronized 锁](#4、synchronized 锁)
[5、transient 瞬态](#5、transient 瞬态)
[6、volatile 易变](#6、volatile 易变)
一、访问控制修饰符
1、default 就是啥都不写的那种
如果你不写任何特殊的标记，那就是默认权限。同一个包里的东西都能看到它
适用于：各种类、接口、变量和方法
java
// Test1.java
package com.jkt;
// 默认访问修饰符
class Test1{
// 默认访问修饰符
int x = 10;
// 默认访问修饰符
void showInfo() {
System.out.println("x的值为: " + x);
}
}
-------------------------------------------------------
// Test2.java
package com.jkt;
// 默认访问修饰符
class Test2{
public static void main(String[] args) {
Test1 test1= new Test1 ();
// 访问 Test1 中的默认访问修饰符变量和方法
test1.showInfo();
}
}2、private 私有
只有这个类自己能看见它里面的私有东西。
适用于：变量和方法。提醒一下，这个标记不能用在类外面
（注意：不能用在创建类的时候）
java
//Test1.java
public class Test1{
//定义私有属性：姓名
private String name="假客套";
//名字的getter方法，可以间接通过getter获取私有属性name的值
public String getName() {
return this.name;
}
//名字的setter方法，可以间接通过setter修改私有属性name的值
public void setName(String name) {
this.name= name;
}
//定义私有方法：打印123
private void showInfo() {
system.out.println(123);
}
}
-----------------------------------
//Test2.java
public class Test2{
public static void main(String[] args) {
// 构造Test1的类对象
Test1 test1= new Test1();
// 访问 Test1 中的私有属性name，会报错
// System.out.println(test1.name);
// 访问 Test1 中的私有方法，会报错
//System.out.println(test1.showInfo());
// 可以间接通过getter获取私有属性name的值，这里结果运行会是假客套
System.out.println(test1.getName());
// setter进行修改私有属性name的值
System.out.println(test1.setName("李四"));
//这里结果运行会是李四
System.out.println(test1.getName());
}
}3、public 公开
这个是大家都能看到的，不管在哪个包中
适用于：类、接口、变量和方法。
java
// Test1.java
public class Test1{
//定义一个名字的属性
public String name="假客套";
//打印名字属性值的方法
public void showInfo() {
System.out.println(this.name);
}
}
-------------------------------------------------------
// Test2.java
public class Test2{
public static void main(String[] args) {
//构造 Test1的对象
Test1 test1= new Test1();
// 访问 Test1 中的公共访问修饰符变量和方法
// 这里的结果为假客套
Sytem.out.println(test1.name());
// 这里的结果为假客套
Sytem.out.println(test1.showInfo());
}
}4、protected 受保护的
这个有点像家庭群，同一个包里的类和所有继承了这个类的孩子（子类）都能看到。
适用于：变量和方法。
（注意：不能用在创建类的时候）
java
//father.java
class father {
int x=10
//创建一个计算num+10结果的方法
protected int showInfo(int num) {
// 父类业务代码
return num+10;
}
}
---------------------------------------------
//children.java，继承父类，private的父类无法继承
class children extends father {
//修改父类的业务代码为num+200
//因为父类修饰符无法修改，故子类的修饰符要么protected ，要么public
protected int showInfo(int num) {
// 子类修改父类的业务代码
return num+100
}
}二、非访问控制修饰符
1、static 静态
这个是用来给类里的方法和变量加个标记，让它们属于整个类，而不是属于某个具体的对象。
java
// Test.java
// 定义一个名为Test的类
public class Test {
// 定义一个静态变量，用于记录实例的数量
private static int num = 0;
// 定义一个受保护的静态方法，用于获取当前实例的数量
protected static int getCount() {
// 返回静态变量num的值
return num;
}
// 定义一个私有的静态方法，用于增加实例的数量
private static void addNum() {
// 将静态变量num的值加1
num++;
}
// 构造方法：每次创建Test类的实例时，都会调用这个方法
Test() {
// 调用addNum方法，增加实例计数
addNum();
}
// 主方法：程序的入口点
public static void main(String[] arguments) {
// 打印初始的实例数量，Starting with 0 instances
System.out.println("Starting with " + Test.getCount() + " instances");
// 循环创建500个Test类的实例
for (int i = 0; i < 500; ++i) {
new Test();
}
// 打印创建后的实例数量，Created 500 instances
System.out.println("Created " + Test.getCount() + " instances");
}
}2、final 最终
这个关键字有三板斧的功能。
首先，如果你用它来修饰一个类，那就相当于给这个类穿了防弹衣，不能被其他类继承。
其次，用它来修饰方法，就是告诉别人这个方法是定稿了，不能被继承后的类修改。
最后，用它来修饰变量，这个变量就变成了一个固定值，一旦设定就不能再改了，就像刻在石头上的字一样。
（注意：final 修饰符通常和 static 修饰符一起使用来创建类常量）
java
//final类
public final class Test {
// 类体
}
-----------------------------------------------
//final方法
public class Test{
public final void showInfo(){
// 方法体
}
}
-----------------------------------------------
//final变量
public class Test{
// 定义一个final变量
final int value = 10;
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
public static final String TITLE = "Manager";
public void showInfo(){
//将输出一个错误，因为不可以更改final定义的变量
value = 12;
}
}3、abstract 抽象
这个是用来创造一些"半成品"的类和方法。这些类和方法只有个大概的框架，具体细节要等别人来填充。
java
//抽象类
//Test.java
abstract class Test{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}
----------------------------------------------------------
//抽象方法
//Test1.java
public abstract class Test1{
//父类的抽象方法
abstract void m();
}
--------------------------
//Test2.java，继承父类Test1.java
class Test2 extends Test1{
//子类实现父类的抽象方法，具体的业务代码
void m(){
.........
}
}4、synchronized 锁
给那些喜欢同时做很多事情的程序（线程）用的
synchronized 就像是给共享资源上个锁，保证一次只能有一个线程去用,可以应用于四个访问修饰符
java
public synchronized void showInfo(){
.......
}5、transient 瞬态
当你要把一个对象保存起来（序列化）的时候，如果这个对象里有一些用 `transient` 关键字标记的变量，Java 的虚拟机（也就是 JVM）在保存的时候会忽略这些变量。
这就好比你打包行李的时候，有些东西你不想带走，就标记一下，打包的时候就不会把它们装进去了。
这个 `transient` 关键字，你是在定义变量的时候加上去的，它的作用就是告诉 JVM，这个变量在保存对象的时候不用管它。这样做可以用来预先处理类和变量的数据类型，决定哪些数据需要保存，哪些不需要。
java
// 不会持久化
public transient int limit = 55;
// 持久化
public int b; 6、volatile 易变
给那些喜欢同时做很多事情的程序（线程）用的
volatile 则像是提醒所有线程，这个变量可能会被别人改，要注意点
示例：
这个类实现了`Runnable`接口，可以创建一个线程来执行。
`active`变量是一个布尔标志，用于控制线程的运行状态。
`run`方法中的无限循环会持续执行，直到`active`被设置为`false`。
`stop`方法就是用来设置`active`为`false`，从而停止线程的执行。
使用`volatile`关键字确保`active`变量的修改对其他线程立即可见，这对于正确地停止线程是必要的。
java
// MyRunnable.java
// 定义一个名为MyRunnable的类，实现Runnable接口
public class MyRunnable implements Runnable {
// 定义一个volatile关键字修饰的布尔变量，用于控制线程的运行状态
private volatile boolean active;
// 实现Runnable接口的run方法，这是线程的入口点
public void run() {
// 设置active为true，表示线程是活跃的
active = true;
// 第一行：进入一个无限循环，只要active为true，循环就会继续
while (active) {
// 业务代码：这里可以放置线程需要执行的任务
// 由于没有具体实现，这里只是保持循环状态
// 注意：实际的业务代码应该在这里编写，例如：
// processWork();
}
}
// 定义一个stop方法，用于停止线程的运行
public void stop() {
// 第二行：将active设置为false，这将导致run方法中的循环退出
active = false;
}
}