private 关键字

private ，私有的，一种访问权限修饰符，用来修饰类的成员（包括成员变量和成员方法）

被修饰的成员只能在本类中访问

用法：

private 数据类型 变量名;
private 返回值类型 方法名(参数列表){}

public：公共的，访问权限修饰符，用来修饰类、成员变量、成员方法等，被修饰的内容可以在 任意类 中访问
default （包访问级别）： 类的成员变量和方法什么修饰符都没有，又叫包修饰符，只有类本身成员和当前包下类的成员可以访问
protected （子类访问级别）： 用 protected 修饰的成员变量和方法能被该类的成员以及其子类成员访问，还可以被同一个包中的其他类的成员访问

案例：

A：给成员变量添加 private 修饰后，测试类中将不能直接访问

B：由于 private 的特性，需要在 Student 类中添加访问该属性的方法，供其它类调用

C：属性的操作一般都是取值和赋值，所以添加对应的公共方法： getXxx() 、setXxx(参数)

D：在测试类中通过 getXxx() 和 setXxx(参数) 方法来实现属性的访问

    public static void main(String[] args) {
        Student2 stu = new Student2();
        stu.setAge(20);
        stu.setName("twe");

        System.out.println(stu.getAge());
        System.out.println(stu.getName());
        stu.study();
}

this 关键字

this，表示本类对象的引用，本质是一个对象

每一个普通方法都有一个 this，谁调用该方法，this 就指向谁

用法：

this.属性名;
this.方法名(参数);

案例：

package cn.itcast.demo;
public class Student2 {
    private String name = "one";
    private int age = 1;
    
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
    public void study() {
        System.out.println(this.name + " is studying ");
    }
}

final 关键字

final 用于修饰类、方法和变量

• 修饰类：

  表示该类不能被继承
  例如，String、System

• 修饰方法：

  表示该方法不能被重写，不能与 abstract 共存

• 修饰变量：

  表示最终变量，即 常量，只能赋值一次；

  不建议修饰引用类型数据，因为，对于引用数据类型，即使加了 final，仍然可以通过引用修改对象的内部数据，意义不大

static 关键字

修饰类的成员：

• 成员变量：类变量
• 成员方法：类方法

被修饰成员的调用方式：

类名.成员变量名;
类名.成员方法名(参数);

static 修饰成员变量

被本类所有对象共享

随意修改静态变量的值是有风险的，为了降低风险，可以同时用 final 关键字修饰，即公有静态常量（注意命名的变化）：

public final static 变量类型 变量名 = 变量值;

static 修饰成员方法

静态方法：

静态方法中没有对象 this，所以不能访问非静态成员

使用场景：

只需要访问静态成员，不需要访问对象状态，所需参数都由参数列表显式提供

volatile 关键字

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。

而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null

public class MyRunnable implements Runnable {
    private volatile boolean active;
    public void run() {
        active = true;
        while (active) { // 第一行
            // 代码
        }
    }
    public void stop() {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果第一行中缓冲区的 active 值被使用，那么在第二行的 active 值为 false 时循环不会停止。

但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止；
volatile 修饰后，active 一旦发生变化，会被所有线程知道

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问，用于保证线程安全

synchronized 修饰符可以应用于四个访问修饰符

public synchronized void showDetails(){
	.......
}