Java修饰符

Java提供了四种访问修饰符:private、protected、default(默认)和public,分别用于控制类、变量、方法和构造器的访问权限。private限制在同一类内访问,protected允许同包和子类访问,default仅限同包访问,而public则全局可访问。这些修饰符是控制代码封装性和安全性的重要工具。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

分类

  • Java语言提供了很多修饰符,主要分为以下两类:

  • 访问修饰符
  • 非访问修饰符

修饰符用来定义类、方法或者变量,通常放在语句的最前端。

public class student{
   // ...
}
private boolean myFlag;

protected static final int AGE= 22;

static final double weeks = 9.5;

public static void main(String[] arguments) {
   // 方法体
}

访问控制修饰符

Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

  • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

  • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

  • default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

  • public : 对所有类可见。使用对象:类、接口、变量、方法

我们可以通过以下表来说明访问权限:

访问控制
修饰符当前类同一包内子类其他包
privateYNNN
protectedYYYN
defaultYYY(同包)N
public YYYY

一、默认访问修饰符-不使用任何关键字

如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符,那么它们就默认具有默认访问修饰符。

class MyClass {  // 默认访问修饰符
 
    int x = 10;  // 默认访问修饰符
 
    void display() {  // 默认访问修饰符
        System.out.println("x:"+x);
    }
}

二、私有访问修饰符-private

私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

下面的类使用了私有访问修饰符:

public class Student {
    private String name;

    public String getName() {//拿值
        return name;
    }

    public void setName(String name) {//改值
        this.name = name;
    }
}

实例中,Student 类中的 name 变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两个 public 方法:getName() (返回 name 的值)和 setName(String)(设置 name 的值)

三、受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明:

  • 子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;

  • 子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

protected 可以修饰数据成员,构造方法,方法成员,不能修饰类(内部类除外)

private和protected的区别

首先这两个都是访问类中成员权限的限制符。
private是完全私有的,只有自己可以访问,派生类(子类)和外部都不可以访问
protected是受保护的,只有派生类可以访问,外部不能访问
在类外如果想使用类中的成员,只能直接使用public类型的,proteced和private都是不能访问的,对于类外而言,这两个是完全相同的。

不能把私有数据的地址或引用泄露出去,外部可以改变私有数据的值。

四、公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

以下函数使用了公有访问控制:

public class Test {
    public static void main(String[] args) {
        System.out.println("我最大!");
    }
} 

Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。

非访问修饰符
 下一篇再说——

### Java 修饰符详解及使用场景 Java 中的修饰符是用来控制类、方法、变量和构造器的访问级别和行为的关键字。它们分为两类:**访问控制修饰符**和**非访问控制修饰符**。 #### 1. 访问控制修饰符 访问控制修饰符用于限制类、方法和变量的可访问性,从而提高代码的封装性和安全性。Java 提供了四种访问控制修饰符:`private`、`default`(无修饰符)、`protected` 和 `public`。 - **`private`(私有)** 当一个类、方法或变量被声明为 `private` 时,它只能在声明它的同一类中访问。其他类无法直接访问该成员[^2]。 示例代码如下: ```java public class Example { private String secret = "This is a secret"; public void displaySecret() { System.out.println(secret); // 可以访问 } } ``` - **`default`(默认)** 如果没有显式地指定访问修饰符,则该成员具有默认访问权限。这种情况下,只有同一个包中的类可以访问该成员[^2]。 示例代码如下: ```java class DefaultExample { String message = "Default access"; } package com.example; class AnotherClass { DefaultExample example = new DefaultExample(); System.out.println(example.message); // 同一包内可以访问 } ``` - **`protected`(受保护)** 声明为 `protected` 的成员可以被同一个包中的任何类访问,也可以被不同包中的子类访问[^2]。 示例代码如下: ```java public class Parent { protected String info = "Protected data"; } public class Child extends Parent { public void displayInfo() { System.out.println(info); // 子类可以访问 } } ``` - **`public`(公共)** 声明为 `public` 的成员可以被任何类访问,无论它们是否在同一个包中[^2]。 示例代码如下: ```java public class PublicExample { public String message = "Public access"; } class AnyClass { PublicExample example = new PublicExample(); System.out.println(example.message); // 可以访问 } ``` #### 2. 非访问控制修饰符 非访问控制修饰符用于定义类、方法或变量的行为,而不是访问权限。 - **`final`** `final` 修饰符可以应用于类、方法或变量。当应用于类时,表示该类不能被继承;当应用于方法时,表示该方法不能被重写;当应用于变量时,表示该变量的值一旦赋值后不能更改[^4]。 示例代码如下: ```java public class FinalExample { final int number = 10; // 不能重新赋值 public FinalExample() { // number = 20; // 错误:不能重新赋值 } } ``` - **`static`** `static` 修饰符用于创建类级别的成员。静态成员属于类本身,而不是类的实例。因此,可以通过类名直接访问静态成员[^1]。 示例代码如下: ```java public class StaticExample { static int count = 0; public static void incrementCount() { count++; } } StaticExample.incrementCount(); // 类名调用静态方法 System.out.println(StaticExample.count); // 类名访问静态变量 ``` - **`abstract`** `abstract` 修饰符用于定义抽象类或方法。抽象类不能被实例化,必须由子类继承并实现其抽象方法[^1]。 示例代码如下: ```java public abstract class AbstractExample { public abstract void performAction(); // 抽象方法 } public class ConcreteExample extends AbstractExample { @Override public void performAction() { System.out.println("Concrete implementation"); } } ``` - **`synchronized`** `synchronized` 修饰符用于控制多线程环境下的访问。它确保在同一时刻只有一个线程可以访问被修饰的方法或代码块。 示例代码如下: ```java public class SynchronizedExample { public synchronized void doSomething() { // 线程安全的代码 } } ``` - **`transient`** `transient` 修饰符用于指示某个变量不应被序列化。当对象被序列化时,标记为 `transient` 的变量将不会被保存到文件中[^1]。 示例代码如下: ```java public class TransientExample implements Serializable { transient int tempValue = 10; // 不会被序列化 } ``` - **`volatile`** `volatile` 修饰符用于确保多个线程能够正确处理共享变量。它强制每次读取都从主内存中获取最新值,而不是从线程本地缓存中读取[^1]。 示例代码如下: ```java public class VolatileExample { volatile boolean flag = false; public void changeFlag() { flag = true; } } ``` --- ### 总结 Java 中的修饰符包括访问控制修饰符和非访问控制修饰符,每种修饰符都有其特定的用途和使用场景。合理使用这些修饰符可以增强代码的封装性、安全性和可维护性。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值