【java】：访问修饰符

定义：java支持四种不同的访问权限，使用访问修饰符可以保护对类、变量、方法和构造方法的访问。

访问权限是指类创建的对象是否可以通过“.”运算符访问分配给自己的变量、是否可以通过“.”运算符调用类中的实例方法和类方法。

                                           

访问修饰符	同一包中的的同一类	同一包中的不同类	不同包中的子类	不同包中的非子类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

                                                 图1-1  修饰符的访问范围

public：对所有类均可见，不同包时，使用时要先导入包。常见的使用对象有：类、接口、变量、方法。

protected：对于类的子类和同一包内的其他类可见；对于类的调用者来说，protected修饰的字段和方法不可访问。常见的使用对象有：变量、方法。注意：不能修饰外部类。

default（默认）：类内部可访问，同一个包中的类可以访问，其他类不可访问。常见是的使用对象有：类、接口、变量、方法。使用时什么也不写，不用加上default关键字。

private：类内部可访问，即同一类内可访问。常见的使用对象有：变量、方法。注意：不能修饰类（外部类）

下面举例说明：

private：关键字private修饰的成员变量和方法被称为私有变量和私有方法

package java_01_25;

public class A {
    private float weight;                  //weight被修饰为私有的float类型变量
    private float f(float a,float b){      //方法f是私有方法
        return a*b;
    }
  public static void main(String[] args) {
        A a=new A();
        a.weight=23f;     //合法
        a.f(3f,4f);   //合法
    }
}
class B{
    void g(){
        A a=new A();
        a.weight=23f;      //非法
        a.f(3f,4f);   //非法
    }
}

对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法，当在另外一个类中用类A创建了一个对象后，该对象不能访问自己的私有变量和私有方法。

default： 不用private、public 、protected修饰符的成员变量和方法被称为友好变量和友好方法（即什么都不加）

package java_01_25;
class A {
    float weight;               //weight是友好的float型变量。
    float f(float a,float b){       //方法 f是友好方法。
        return a*b;
    }
}
//假如B与A是同一个包中的类，那么，下述B类中的a.weight、a.f(3,4)都是合法的。
class B {
    void g() {
        A a=new A();
        a.weight=23f;   //合法。
        a.f(3,4);       //合法。
    }
}

 B与A是同一个包中的类，那么，下述B类中的a.weight、a.f(3,4)都是合法的。

package java_01_25;

class A {
    float weight;               //weight是友好的float型变量。
    float f(float a,float b){       //方法 f是友好方法。
        return a*b;
    }
}

import java_01_25.A;

public class B {
        void g() {
            A a=new A();
            a.weight=23f;   //非法。
            a.f(3,4);       //非法。
        }
}

 此时：

在源文件中编写命名的类总是在同一包中的，如果源文件使用import语句引入了另外一个包中的类，并用该类创建了一个对象，那么该类的这个对象将不能访问自己的友好变量和友好方法。

protected：用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法

package java_01_25;

class A{
    protected  float weight;        //weight被修饰为protected的float型变量。
    protected float f(float a,float b) { //方法 f是protected方法。
        return a*b;
    }
}
class B{
    void g(){
        A a=new A();
        a.weight=23f;   //合法
        a.f(3,4);       //合法
    }
}

当在另外一个类中用类A创建了一个对象后，如果这个类与类A在同一个包中，那么该对象能访问自己的protected变量和protected方法。在任何一个与A同一包中的类中，也可以通过类A的类名访问类A的protected类变量和protected类方法。 

package java_01_25;

class A{
    protected  float weight;        //weight被修饰为protected的float型变量。
    protected float f(float a,float b) { //方法 f是protected方法。
        return a*b;
    }
}

package java_01_24;
import java_01_25.A;

public class B {
        void g() {
            A a=new A();
            a.weight=23f;   //非法。
            a.f(3,4);       //非法。
        }
}

 此时A与B 不在同一包内：

在任何一个与A不在同一包中的类中，不可以通过类A的类名访问类A的protected类变量和protected类方法。

public：public修饰的成员变量和方法被称为共有变量和共有方法

package java_01_25;
class A {
    public float weight;                  //weight被修饰为私有的float类型变量
   public float f(float a,float b){      //方法f是私有方法
        return a*b;
    }

    public static void main(String[] args) {
        A a=new A();
        a.weight=23f;     //合法
        a.f(3f,4f);   //合法
    }
}
class B{
    void g(){
        A a=new A();
        a.weight=23f;      //合法
        a.f(3f,4f);   //合法
    }
}

当我们在任何一个类中用类A 创建了一个对象后，该对象能访问自己的public变量和类中的public方法。（注意：A，B是同一包中的类）