权限修饰符和代码块

权限修饰符

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 变量在多线程环境下的安全更新。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值