Java----修饰符

一.访问修饰符

1.public

定义

全局可见，任意类都可以访问修饰，同一包或不同包

适用对象

类、方法、变量、接口、构造器

使用场景

所有代码使用的类、常量、方法

实例

// 类全局可见
public class Animal 
{    
     // 变量全局可见
     public String name;
     public void eat() 
     { 
        // 方法全局可见
        System.out.println("Eating...");      
     }  
 }

注意

①public类的类名必须和文件名一致
②public类的类名不能滥用

2.protected

定义

同一包内可以使用 + 不同包只有子类可用（通过继承）（子类为继承protected修饰的类的子类）

适用对象

方法、变量（不能修饰外部类）

使用场景

在基类中定义允许子类重写或访问的成员

实例

// Parent.java（包 example）
  public class Parent 
  {      
      // 同包内均可访问
      protected void show()
      {
          System.out.println("父亲、母亲");
      }
  }
//Child.java（不同的包）

//先声明引用的包 import 包名.类名
import example.Parent
  //在不同包 只有继承了父类的类可以使用
  public class Child extends Parent
  {
      void nameshow()
      {
          //不同包只能子类使用
          super.show();
          /
      }
  }

注意事项

①不同包的非子类无法访问 protected 成员

②在子类中访问父类的 protected 成员时，必须通过继承关系（如 super.show()）

3.缺省（default）

定义

仅一个包内可以使用

适用对象

类、变量、方法、接口

使用场景

包内共享的类或方法

实例

class Logger 
{    // 默认修饰符类，仅同一包内可访问
      String logLevel; // 默认修饰符变量      
      void log(String message) 
      { 
      // 默认修饰符方法          
      System.out.println("Log: " + message);      
      }  
}

注意

在不同包中无法使用

4.private修饰符

定义

仅当前类内部可见

适用对象

方法、变量、内部类

使用场景

封装类的内部状态或工具方法

实例（摘抄）

public class BankAccount {
    private double balance; // 私有变量，外部无法直接访问
    // 通过公共方法访问私有变量
    public double getBalance() {
        return balance;
    }
    private void validateTransaction() { // 私有方法，仅在类内使用
        // 校验逻辑
    }
}

注意事项

外部类不能使用 private 修饰符（内部类可以）
私有成员无法被子类继承

二.存储修饰符

1.static修饰符

适用对象

方法、变量等

1.修饰变量（静态变量）

• 含义
  被static修饰后为属于类，叫类变量，所有实例共享一份内存，可以被任何实例修改
• 用途
  计数、全局常量、共享资源
• 实例

class Animals
{
    //任意实例都可使用 且为 永久修改
    static int num = 0;
    int catNum()
    {
        return num++;
        //此时为 1
    }
    int dogNum()
    {
        return num++;
        //此时为 2
    }
}

2.修饰方法（静态方法）

• 含义
  属于类，叫作类方法，可以通过类名.类方法名直接调用
• 限制
  内容仅可使用静态成员（类变量、类方法）
  内容不可使用this或super
• 实例

class Animal
{
    static string aname;
    static void animalName(string name)
    {
        //使用类变量
        aname = name;
    }
}
//调用  Animal animal = new Animal();
//     animal animalName("小猫");

//或 直接调用 Animal.animalName("小猫");

⭐⭐注意

• 类变量可以以多种形式调用
  例如
  ①类方法内
  ②普通成员方法内
  ③对象内
• 类方法内只能声明类变量

2.final修饰符

核心作用
不可变，（不可修改、不可覆盖、不可继承）

** 作用范围**
类、方法、变量、参数

1.修饰类

• 含义
  不可被继承（没有子类）
• 作用
  工具包、安全设计
• 实例

// 不可被继承
final class ImmutableClass
{
      // 类内容  
}

2.修饰方法

• 含义
  方法不能被子类重写，可以被子类使用
• 用途
  防止模板方法被修改，保护方法
• 实例

class Parent
{
      public final void finalMethod()
       { // 子类无法重写此方法          
       System.out.println("Final method"); 
       }  
}

3.修饰变量

• 含义
  被修饰变量，一旦赋值后，不可再修改
• 分类
  基本类型变量
  被赋值过后，值不可变
  引用类型变量
  引用不可变，但对象的内部状态可以变
• 实例

4.修饰参数

• 含义
  方法参数在方法内不可修改

void printMessage(final String message) 
{
      // message = "New"; ❌ 禁止修改      
      System.out.println(message);  
}

注意事项

1. final注意事项：

   • final 修饰的引用类型变量不可变的是引用，而非对象内容
   • final 方法可以被重载（但不可被重写）

2. static注意事项：

   • 不可滥用静态变量
   • 静态方法不能直接访问实例成员（需通过创建对象引用）

三.关键字

1.this关键字

说明

this关键字，用于指代当前对象的实例

一.访问当前对象的成员

当类的成员变量与方法参数或局部变量同名时，使用this显式访问当前对象的成员变量，避免歧义

• 例如

public class Parent
{
    //当前类的age
    private int age;
    //参数名 为 新的age
    void people(int age)
    {
        this.age=age;
        //前者的this.age为 当前类的age
        //后者的age为 参数age
    }
}

2.super关键字

一.调用父类构造方法

每个类中都有构造方法，但一般是系统默认隐藏创建的，但当人为创建时，子类的构造方法必须调用父类构造方法

语法

super(参数列表);

⭐⭐规则

• ①必须作为第一行
• ②父类构造方法有参数时，只可以显示调用，及子类的构造方法内必须添加super（参数列表），这个参数列表名为子类创建的参数名
• ③父类构造方法无参数时，可以隐式或显式调用，隐式调用为人为不去书写，编译器默认书写super( );
• ④若父类既有有参数的构造方法，又有无参数的构造方法，此时根据使用的情况选择调用方式以及内容

代码

class Parent 
{    
     //父类构造方法，无参数的
     Parent(){}
     //父类构造方法，有参数的
     Parent(int x) 
     {      
      System.out.println("Parent构造方法: "+x);
     }
}
class Child extends Parent 
{    
    Child(int a)
    {        
    super(a); 
    // 显式调用父类有参构造方法
    // 并且以 参数名调用
    // 或者 super(与父类构造方法同类型的值)
    // 如 super(7);
    
    System.out.println("Child构造方法");
    }
}

二.访问父类方法

等（还没有学习到）
子类重写父类方法后，可通过
super.方法名()调用父类被覆盖的方法

class Parent 
{    
    void show() 
    {        
    System.out.println("Parent的法");    
    }
}
class Child extends Parent
{        
    void show() 
    {        
    super.show(); // 调用父类方法
    System.out.println("Child的方法");    
    }
}

三.访问父类属性（变量）

当子类与父类有同名属性时
使用super.属性名访问父类属性（通常会避免属性同名，优先用private封装）
代码

class Parent 
{
    protected int num = 5;
}
class Child extends Parent 
{
    int num = 10;    
    void show() 
    {     
    System.out.println(super.num); 
    // 输出5（父类属性） 
    System.out.println(num);       
    // 输出10（子类属性）    
    }
}

注意事项

多层继承：super仅指向直接父类，无法直接访问祖父类成员
静态上下文：super不能在静态方法或静态块中使用
设计原则：优先通过方法覆盖而非属性隐藏实现多态，属性会设为private