private 关键字
概述
private 关键字是最严格的访问修饰符，被修饰的成员只能在当前类内部访问。
语法格式
private int variable; // 私有变量
private void method() { } // 私有方法
private ClassName() { } // 私有构造器
基本用法
public class Person {
// 私有成员变量
private String name;
private int age;
private String socialSecurityNumber;
// 公共构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
this.socialSecurityNumber = generateSSN();
}
// 公共getter方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
// 私有辅助方法
private String generateSSN() {
return "SSN-" + System.currentTimeMillis();
}
// 私有验证方法
private boolean isValidAge(int age) {
return age >= 0 && age <= 150;
}
// 公共setter方法，内部使用私有验证
public void setAge(int age) {
if (isValidAge(age)) {
this.age = age;
} else {
throw new IllegalArgumentException("年龄无效");
}
}
// 私有方法不能从外部访问
private void secretMethod() {
System.out.println("这是私有方法，只能在类内部调用");
}
public void publicMethod() {
secretMethod(); // 类内部可以调用私有方法
System.out.println("公共方法调用了私有方法");
}
}
public class PrivateExample {
public static void main(String[] args) {
Person person = new Person("张三", 25);
// 可以访问公共方法
System.out.println("姓名: " + person.getName());
System.out.println("年龄: " + person.getAge());
// 调用公共方法（内部会调用私有方法）
person.publicMethod();
// 以下访问会编译错误
// System.out.println(person.name); // 错误：私有变量不能访问
// person.secretMethod(); // 错误：私有方法不能访问
// String ssn = person.generateSSN(); // 错误：私有方法不能访问
}
}
封装和数据保护
public class BankAccount {
// 私有字段保护敏感数据
private String accountNumber;
private double balance;
private String pin;
public BankAccount(String accountNumber, String pin, double initialBalance) {
this.accountNumber = accountNumber;
this.pin = hashPin(pin);
this.balance = initialBalance;
}
// 私有方法用于内部处理
private String hashPin(String pin) {
// 简单的哈希示例（实际应用中应使用更安全的方式）
return "HASHED_" + pin;
}
private boolean validatePin(String inputPin) {
return this.pin.equals(hashPin(inputPin));
}
private void logTransaction(String operation, double amount) {
System.out.println("账户 " + accountNumber + " " + operation + " " + amount);
}
// 公共接口方法
public boolean deposit(String pin, double amount) {
if (!validatePin(pin)) {
System.out.println("PIN码错误");
return false;
}
if (amount > 0) {
balance += amount;
logTransaction("存款", amount);
return true;
}
return false;
}
public boolean withdraw(String pin, double amount) {
if (!validatePin(pin)) {
System.out.println("PIN码错误");
return false;
}
if (amount > 0 && amount <= balance) {
balance -= amount;
logTransaction("取款", amount);
return true;
}
return false;
}
public double getBalance(String pin) {
if (validatePin(pin)) {
return balance;
} else {
System.out.println("PIN码错误，无法查询余额");
return -1;
}
}
}
public class BankAccountExample {
public static void main(String[] args) {
BankAccount account = new BankAccount("12345", "1234", 1000.0);
// 正确的PIN码操作
account.deposit("1234", 500.0);
System.out.println("余额: " + account.getBalance("1234"));
account.withdraw("1234", 200.0);
// 错误的PIN码操作
account.deposit("0000", 100.0);
System.out.println("余额: " + account.getBalance("0000"));
// 无法直接访问私有成员
// System.out.println(account.balance); // 编译错误
// account.logTransaction("test", 100); // 编译错误
}
}
私有构造器
// 工具类 - 防止实例化
public class MathUtils {
// 私有构造器防止实例化
private MathUtils() {
throw new UnsupportedOperationException("工具类不能实例化");
}
public static double add(double a, double b) {
return a + b;
}
public static double multiply(double a, double b) {
return a * b;
}
}
// 单例模式
public class Singleton {
private static Singleton instance;
// 私有构造器防止外部实例化
private Singleton() {
System.out.println("创建单例实例");
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
public void doSomething() {
System.out.println("执行单例操作");
}
}
public class PrivateConstructorExample {
public static void main(String[] args) {
// 使用工具类的静态方法
double result = MathUtils.add(5.0, 3.0);
System.out.println("加法结果: " + result);
// 无法实例化工具类
// MathUtils utils = new MathUtils(); // 编译错误
// 使用单例
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println("是否为同一实例: " + (singleton1 == singleton2));
singleton1.doSomething();
// 无法直接实例化单例
// Singleton singleton = new Singleton(); // 编译错误
}
}
内部类访问
public class OuterClass {
private String outerPrivateField = "外部类私有字段";
// 内部类可以访问外部类的私有成员
private class InnerClass {
public void accessOuterPrivate() {
System.out.println("内部类访问: " + outerPrivateField);
}
}
public void createInner() {
InnerClass inner = new InnerClass();
inner.accessOuterPrivate();
}
// 私有静态内部类
private static class PrivateStaticInner {
public void display() {
System.out.println("私有静态内部类");
}
}
public static void createPrivateStatic() {
PrivateStaticInner inner = new PrivateStaticInner();
inner.display();
}
}
public class InnerClassExample {
public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.createInner();
OuterClass.createPrivateStatic();
// 无法从外部访问私有内部类
// OuterClass.InnerClass inner = outer.new InnerClass(); // 编译错误
}
}
最佳实践
字段默认私有：
public class Example { private String name; // 好的做法 // public String name; // 避免公共字段 public String getName() { return name; } }私有辅助方法：
public class Calculator { public double calculateTotal(double[] values) { double sum = sum(values); // 使用私有方法 double tax = calculateTax(sum); // 使用私有方法 return sum + tax; } private double sum(double[] values) { double total = 0; for (double value : values) { total += value; } return total; } private double calculateTax(double amount) { return amount * 0.1; } }
private关键字是Java封装性的核心，通过隐藏实现细节来保护数据和维护代码安全性。