Java编程思想学习笔记(6)

引入访问控制权限

当你有更好的方式去实现系统中的一个部分时，可能会遇到一些问题。因为客户端程序员希望你的代码在某些方面保持不变，所以这个时候就会有冲突了。“如何把变动的事物与保持不变的事物区分开”。

为了解决这个问题，Java提供了访问控制权限。

从最大权限到最小权限依次为：public，protected，包访问权限（无关键词），private

public

使用关键字public，意味着public之后的成员声明自己对每个人都是可用的。

在d1包下定义类A:

public class A {

    public A(){
        System.out.println("A构造器");
    }

    void f1(){
        System.out.println("f1");
    }

    public void f2(){
        System.out.println("f2");
    }


}

在同一个包下使用:

public class Use_A {

    public static void main(String[] args) {

        A a = new A();

        a.f1();

        a.f2();
        
    }

}

完美运行

在不同包下，d2包中使用:

public class Use_A {

    public static void main(String[] args) {

        A a = new A();

//        无法访问
//        a.f1();

        a.f2();
    }
    
}

因为A中方法f1()没用使用public修饰符，所以其它包中的类无法访问。

包访问权限

在d1包新建类B，使用包访问权限：

class B {

    B(){
        System.out.println("B 构造器");
    }

    void f1(){
        System.out.println("f1");
    }


}

在同一个包下使用：

class Use_B {

    public static void main(String[] args) {

        B b = new B();

        b.f1();

    }
}

完美运行。

不同包下使用：


public class Use_B {

    public static void main(String[] args) {
//        无法访问
//        B b = new B();
    }

private

使用private关键字，除了包含该成员的类之外，其它任何类都无法访问这个成员。

public class C {


    private String s1 = "S1";

    String s2 = "S2";

//    C() {
//
//        System.out.println("C构造器");
//
//    }


//如果将用private修饰类构造函数，则其它类无法进行访问
//    private C(){
//        System.out.println("C构造器");
//    }



    public static void main(String[] args) {

        C c = new C();

        System.out.println(c.s1);

        System.out.println(c.s2);

    }


}

public class Use_C {

    public static void main(String[] args) {

        C c = new C();

//        无法访问
//        System.out.println(c.s1);

        System.out.println(c.s2);
    }
}

protected

首先d1下建类D：

public class D {

    private String s1 = "S1";

    String s2 = "S2";

    protected String s3 = "S3";


}

然后同一包下：

public class From_D extends D{


    public static void main(String[] args) {

        From_D from_d = new From_D();

//        无法访问
//        System.out.println(from_d.s1);

        System.out.println(from_d.s2);

        System.out.println(from_d.s3);

    }

}

可以看到用private修饰的字段是无法访问，即便是继承于D类。

然后试下不同包下继承进行访问：


public class From_D extends D {

    public static void main(String[] args) {

        From_D from_d = new From_D();

//        此时s1  s2 都无法访问

        System.out.println(from_d.s3);

    }


}

此时只能访问protected修饰的字段。当然如果不是继承的类的话，protected字段也是无法访问的

最后总结下

	private	default	protected	public
同一类	YES	YES	YES	YES
同一包中的类		YES	YES	YES
子类			YES	YES
其他包中的类				YES

来源：CSDN

作者：Coder_py

链接：https://blog.csdn.net/Coder_py/article/details/103721846

标签

string

编程思想