权限修饰符
1. 使用来一个成员能够被访问的范围的。
2.可以修饰成员变量、方法、构造方法、内部类。
public class Student{
private String name; //这里的private就是权限修饰符的其中一个
private int age;
}
权限修饰符的分类
有四种作用的范围由小到大(private < 空着不写 [默认]< protected < public)
public(公共的)
1. 访问权限:被 public
修饰的类、方法、变量可以在任何地方被访问,不管是同一个包内还是不同包中。
2.使用场景:常用于需要被广泛访问的类、方法或者变量,比如一些工具类的方法。
// 定义一个公共类
public class PublicClass {
// 定义一个公共变量
public int publicVariable = 10;
// 定义一个公共方法
public void publicMethod() {
System.out.println("This is a public method.");
}
}
//在其他类中,无论是否在同一个包内,都能访问 PublicClass 的 publicVariable 和 publicMethod。
protected(受保护的)
1. 访问权限:
a. 在同一个包内,protected
修饰的类、方法、变量可以被任意类访问。
b. 在不同包中,只有该类的子类才能访问 protected
成员。
2. 使用场景:当你希望某个成员在同一个包内可以自由访问,同时允许不同包的子类使用时,就可以使用 protected
修饰符。
// 定义一个父类
class ParentClass {
// 定义一个受保护的变量
protected int protectedVariable = 20;
// 定义一个受保护的方法
protected void protectedMethod() {
System.out.println("This is a protected method.");
}
}
// 定义一个子类,位于不同包中
class ChildClass extends ParentClass {
public void accessProtectedMembers() {
// 可以访问父类的 protected 变量和方法
System.out.println("Protected variable: " + protectedVariable);
protectedMethod();
}
}
默认(没有显示修饰符)
1. 访问权限:默认修饰符也被称作包访问权限,被其修饰的类、方法、变量只能在同一个包内被访问,不同包中的类无法访问。
2. 使用场景:当你只希望某个成员在同一个包内可见时,就可以不使用任何修饰符。
// 定义一个没有修饰符的类
class DefaultClass {
// 定义一个没有修饰符的变量
int defaultVariable = 30;
// 定义一个没有修饰符的方法
void defaultMethod() {
System.out.println("This is a default method.");
}
}
private(私有的)
1. 访问权限:被 private
修饰的类、方法、变量只能在定义它们的类内部被访问,其他类无法访问。
2. 使用场景:常用于封装类的内部实现细节,防止外部类直接访问和修改,保证数据的安全性。
class PrivateClass {
// 定义一个私有变量
private int privateVariable = 40;
// 定义一个私有方法
private void privateMethod() {
System.out.println("This is a private method.");
}
// 提供一个公共方法来间接访问私有变量和方法
public void accessPrivateMembers() {
System.out.println("Private variable: " + privateVariable);
privateMethod();
}
}
}
//在 PrivateClass 外部,不能直接访问 privateVariable 和 privateMethod,只能通过 accessPrivateMembers 方法间接访问。
实际开发中,我们一般只用public 、 private
1.成员变量私有
2.方法公开
特例:如果方法中的代码是抽取其他方法中的共性代码,这个方法一般也私有
代码块
分类:局部代码块、构造代码块、静态代码块
局部代码块(普通代码块)
1. 定义在方法内部的代码块。
2.作用:主要用于限制变量的作用域,当代码块执行完毕后,其中定义的变量就会被销毁,从而节省内存空间。
public class NormalBlockExample {
public static void main(String[] args) {
// 普通代码块
{
int num = 10;
System.out.println("Inside normal block: " + num);
}
// 以下代码会报错,因为 num 的作用域仅限于上面的代码块
// System.out.println(num);
}
}
在上述代码中,num
变量的作用域仅在普通代码块内部,出了代码块就无法访问。
构造代码块
1.构造代码块定义在类中,但不在任何方法内,每次创建对象时都会执行,并且会在构造方法之前执行。
2.作用:可以将多个构造方法中重复的代码提取到构造代码块中,减少代码冗余。
public class ConstructorBlockExample {
// 构造代码块
{
System.out.println("Constructor block is executed.");
}
// 构造方法
public ConstructorBlockExample() {
System.out.println("Constructor is executed.");
}
public static void main(String[] args) {
new ConstructorBlockExample();
}
}
构造代码块写在成员位置的代码块;
运行上述代码,会先输出构造代码块中的内容,再输出构造方法中的内容。
静态代码块
1.静态代码块使用 static
关键字修饰,同样定义在类中但不在任何方法内,它会在类加载时执行,并且只执行一次。
2.作用:常用于对静态变量进行初始化,或者执行一些只需要执行一次的操作,比如加载驱动程序等。
3.格式:static{}
public class StaticBlockExample {
static int staticVariable;
// 静态代码块
static {
System.out.println("Static block is executed.");
staticVariable = 20;
}
public static void main(String[] args) {
System.out.println("Static variable: " + staticVariable);
}
}
当类 StaticBlockExample
被加载时,静态代码块会先执行,对 staticVariable
进行初始化,然后再执行 main
方法。
还有一个同步代码块,目前我么基础美学
同步代码块
1.同步代码块使用 synchronized
关键字修饰,用于实现线程同步,确保同一时间只有一个线程可以执行该代码块中的代码。
2.作用:在多线程环境下,防止多个线程同时访问共享资源而引发数据不一致等问题。
public class SynchronizedBlockExample {
private static int counter = 0;
public static void main(String[] args) {
// 创建两个线程
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
// 同步代码块
synchronized (SynchronizedBlockExample.class) {
counter++;
}
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
// 同步代码块
synchronized (SynchronizedBlockExample.class) {
counter++;
}
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Counter: " + counter);
}
}
在上述代码中,使用同步代码块确保了 counter
变量在多线程环境下的安全更新。