类和其中的成员变量、属性、方法等，就如同一个人的所有财产一样，车只能让关系好的同事坐，房子只邀请关系很铁的朋友，而卧室这种私人的地方更不能随便让人进。同时，对于各种物品，在心中也会有不同的地位，车是可以卖的，但是房子是不能动的。所以在Java中有一系列修饰词，用来保护对类、成员变量和方法等等的访问。
修饰词分为两类，分别是访问修饰词和非访问修饰词。

文章目录

访问修饰词
非访问修饰符

访问修饰词

（1）公有访问的修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

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

main()方法就是非常典型的公有方法，并且main()方法必须用 public 修饰,否则Java编译器无法运行该类。

（2）默认的修饰符-什么都不写

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。默认修饰符可以修饰类。注意：是什么都不写，不是default。（修饰类时）
接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为public。和类是不一样的。

（3）受保护的修饰符-protected

protected可以修饰数据成员，构造方法，方法成员，不能修饰类。（内部类除外）
protected修饰比其他修饰符更复杂一点，“被 protected 修饰的成员对于本包和其子类可见”这句话不够全面，需分两种情况：

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

子类与父类不在同一包中：那么在子类中，子类实例可以访问其从父类继承而来的 protected 方法，而不能访问父类实例的protected方法。
代码示例：
同一个包内：

package Test;

public class dad {
    
    //父类
    protected void run(){
    
    //protected修饰的方法
        System.out.println("run");
    }
}

package Test;

public class son extends dad{
    
    //同一包下子类
    public static void main(String[] args) {
    
    
        dad d =new dad();
        d.run();
    }
}

public class son {
    
    //同一包下非继承关系的类
    public static void main(String[] args) {
    
    
        dad d =new dad();
        d.run();
    }
}

结果如下：
在这里插入图片描述
同一个包下，无论继承与否，其他类都能访问到dad类中使用protected修饰的方法。

package anothertest;

import Test.dad;
public class son extends dad {
    
    //不同包下子类
    public static void main(String[] args) {
    
    
        dad d =new dad();
        d.run();
    }
}


package anothertest;

import Test.dad;
public class son {
    
    //不同包下非继承关系的类
    public static void main(String[] args) {
    
    
        dad d =new dad();
        d.run();
    }
}

结果如下：
在这里插入图片描述
不同包下，不论是否继承关系，都不能访问到dad类中protected修饰的方法。但是：

package anothertest;

import Test.dad;

public class son extends dad{
    
    //不同包下子类
    public static void main(String[] args) {
    
    
        son s=new son();
        s.run();
    }
}

结果如下：
在这里插入图片描述
不同包下，子类对象可以访问从父类继承过来的protected方法，但是，不能访问父类对象的protected方法。

所以我认为“被 protected 修饰的成员对于本包和其子类可见”这句话的范围该再严格一点：同一包内所有类可见，当然包括子类；不同包下，子类也只能调用其实例继承的的protected方法，而不能调用父类对象的protected方法。

（4）私有访问的修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中public的 getter() 方法被外部类访问。通过setter()方法进行修改。private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
代码示例：

public class javaexample {
    
    
    private int age;
    private double height;
    private double weight;
    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public double getHeight() {
    
    
        return height;
    }

    public void setHeight(double height) {
    
    
        this.height = height;
    }

    public double getWeight() {
    
    
        return weight;
    }

    public void setWeight(double weight) {
    
    
        this.weight = weight;
    }
}

访问权限

修饰符	当前类	同一包内	同一包下子类	不同包下子类	不同包下其他类
public	YES	YES	YES	YES	YES
protected	YES	YES	YES	YES/NO	NO
默认	YES	YES	YES	NO	NO
private	YES	NO	NO	NO	NO

修饰范围
public : 对所有类可见。使用对象：类、接口、变量、方法。

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

默认（什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

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

非访问修饰符

（1）static修饰符

static 修饰符，用来修饰类方法和类变量。static修饰的变量称为静态变量，static修饰的方法称为静态方法。

静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。简单来说，静态变量不再是一个对象的变量，而是属于多个对象共享的类的变量，所以静态变量也被称为类变量。局部变量不能被声明为 static 变量。
代码示例：

public class family {
    
    
    static int money=1000;
    int allowances=100;
    public void speedmoney(){
    
    
        money=money-200;
    }
    public int getmoney(){
    
    
        return money;
    }
}

public class bank {
    
    
    public static void main(String[] args) {
    
    
        family dad =new family();
        dad.speedmoney();
        family son=new family();
        son.speedmoney();
        System.out.println(dad.getmoney());
    }
}

结果如下：
在这里插入图片描述
虽然父子俩都是花了200元，但是家里的钱是两人共享的，所以最后只剩下600元。可见：静态变量在不同于普遍的成员变量变量，成员变量在实例化新对象时会初始化，是属于对象的变量，但是静态变量是类变量，是所有对象共用的。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法从参数列表得到数据，然后计算这些数据。

注意！静态方法不能使用类的非静态变量。否则会出现以下错误。
代码示例：

public class family {
    
    
    static int money=1000;
    int allowances=100;
    public void speedmoney(){
    
    
        money=money-200;
    }
    public int getmoney(){
    
    
        return money;
    }
    public static void earnmoney(){
    
    
        allowances=allowances+200;
    }
}
public class bank {
    
    
    public static void main(String[] args) {
    
    
        family dad =new family();
        dad.speedmoney();
        family son=new family();
        son.speedmoney();
        System.out.println(dad.getmoney());
        dad.earnmoney();
    }
}

结果如下：
在这里插入图片描述

（2）final修饰符

final变量：
final变量一旦赋值后，不能被重新赋值。被 final修饰的实例变量必须显式指定初始值。如：

public final int num=10;

final修饰符通常和 static 修饰符一起使用来创建类常量。

final方法：
父类中的 final 方法可以被子类继承，但是不能被子类重写。声明 final方法的主要目的是防止该方法的内容被修改。

（3）abstract修饰符

【Java基础学习笔记】6、类和接口（继承和抽象类）

【Java基础学习笔记】7、修饰词整理