[8] Java中的访问控制权限

Java中的访问控制权限

所谓的访问控制权限都有哪些？

Java中共有4个访问权限：

• public （公有的）
• protected （被保护的）
• default（默认的）
• private （私有的）

也叫限定词。

为什么要有访问控制权限？

主要的作用就是用来封装类的，允许哪些东西给用户看到，哪些东西不让用户看到。就像是封装一个手表一样。制作手表的人可以看到手表的内部结构，然后组装好手表，一切工作做好了之后拿给使用手表的人。使用手表的人只想看到手表显示的时间即可，不用关心手表的内部结构，因为没这个必要。我们封装类的时候也是这样的，我们作为程序员，主要工作是将类的内部结构构造好，属性和行为怎么放，哪些东西要放给用户看，哪些东西不给用户看，自己掂量。这个时候访问控制权限的概念就出来了，它定义好了哪个限定词能控制的范围（可见性是多少）。一般在Java开发的时候，private用来修饰属性（数据类型），public修饰行为（方法）。

四个访问控制权限的可见性表

范围	private	default	protected	public
同包同类	✓	✓	✓	✓
同包不同类		✓	✓	✓
不同包的子类			✓	✓
不同包的非子类				✓

private

private表示的是私有的，使用private修饰的只能在当前类中访问，其他地方访问不到。private是Java四个访问控制权限里面范围最小的。

在同一个包中

现在两个类都在com.zhong.www下。

源代码：

Private类中：

package com.zhong.www;

public class Private {
        private String priStr="Test String";
        private void print(){
                System.out.println(priStr);
        }
}

Test类中：

package com.zhong.www;

public class Test {
        public static void main(String[] args){
                Private testPri=new Private();
                testPri.print();
        }
}

运行的时候报错：‘print()’ has private access in ‘com.zhong.www.Private’

原因是print方法是一个私有的private在同包下的不同类是访问不到的。

不在同一个包中

Private类还是上面那个，现在在另一包中新建测试类Test

测试代码：

package com.cukor.www;

import com.zhong.www.Private;

public class Test {
        public static void main(String[] args) {
                Private testPri=new Private();
                testPri.print();
        }
}

报错：java: print()可以在com.zhong.www.Private中访问private

在同包下都访问不到，不在同一个包下就更加访问不到了。

在当前类中

private修饰的属性或者行为在当前类中是可以访问的

Private类中：

package com.zhong.www;

public class Private {
        private String priStr="Test String";
        private void print(){
                System.out.println(priStr);
        }
        public void fun(){	//公有接口让外界能访问得到fun方法
                print();	//fun方法调用private修饰的print方法
        }
}

测试代码：

package com.zhong.www;

public class Test {
        public static void main(String[] args){
                Private testPri=new Private();
                testPri.fun();
        }
}

输出结果：

Test String

说明private的范围是在同包的同类中可以访问得到，出了当前类之后就访问不到使用private修饰的属性或者行为了。

default

默认的修饰词就是在属性或者行为前面不加任何限定词，这个时候的属性或者行为就是有一个默认的限定词。在C++的中，如果不加以限定词修饰，这默认是private，在Java中就有一个default。这个也是C++和Java的区别。

在同一个包中

源代码：

Default类：

package com.zhong.www;

public class Default {
        String defStr="This is a default string";
        void print(){
                System.out.println(defStr);
        }
        void fun(){
                print();
        }
}

Test类中：

package com.zhong.www;

public class Test {
        public static void main(String[] args){
                Default testDef=new Default();
                testDef.print();        //可以正常访问
                testDef.defStr="modify the string";       //默认修饰的属性也可以访问得到
                testDef.fun();          //调用另一个方法
        }
}

输出结果：

This is a default string
modify the string

说明类在同包中定义，然后一个类使用了默认的限定方式，这在当前类中是可以直接访问得到的，在一个包下的另一个类也是可以访问得到的。

不在同一个包中

源代码：

Test类：

package com.cukor.www;

import com.zhong.www.Default;

public class Test {
        public static void main(String[] args) {
                Default testDef=new Default();
                testDef.print();
        }
}

报错：java: print()在com.zhong.www.Default中不是公共的; 无法从外部程序包中对其进行访问

在不同包子类中访问default属性或行为：

在不同的包下新建一个子类继承Default类：然后访问Default里面使用默认限定的方法

package com.cukor.www;

import com.zhong.www.Default;

public class SonDefault extends Default {
        public void testFun(){
                print();
        }
}

程序报错：‘print()’ is not public in ‘com.zhong.www.Default’. Cannot be accessed from outside package

说明默认限定不同包是访问不到的。

protected

protected翻译过来就是被保护的。在类中使用protected修饰的属性或行为，则这样的属性或行为就是被保护的。它的可见性比（范围）比default大一点。可以在不同包中的子类访问的得到。

在同一个包下

源代码：

Protected类：

package com.zhong.www;

public class Protected {
        protected String proStr="This is a protected string";
        protected void print(){
                System.out.println(proStr);
        }
        protected void getPrint(){
                print();
        }
}

Test类：

package com.zhong.www;

public class Test {
        public static void main(String[] args){
                Protected testPro=new Protected();
                testPro.print();
                testPro.proStr="modify the information of the string";
                testPro.getPrint();
        }
}

输出结果：

This is a protected string
modify the information of the string

说明使用protected方式限定，在同包不同类和同包不同类访问都没有任何问题。

不在同一个包下

源代码：

package com.cukor.www;

import com.zhong.www.Protected;

public class Test {
        public static void main(String[] args) {
                Protected testPro=new Protected();
                testPro.print();
        }
}

报错：‘print()’ has protected access in ‘com.zhong.www.Protected’

如果是不同包的子类会怎样？直接看代码：

package com.cukor.www;

import com.zhong.www.Protected;

public class SonProtected extends Protected {
        public void testFun(){
                print();
                this.proStr="modify the information of the string";
                getPrint();
        }
}

Test类：

package com.cukor.www;

import com.zhong.www.Protected;

public class Test {
        public static void main(String[] args) {
                SonProtected testSon=new SonProtected();
                testSon.testFun();
        }
}

输出结果：

This is a protected string
modify the information of the string

说明：protected方式限定，是在default限定的基础上加了一个子类继承可访问到的性质，在不同包的子类default访问不到。

public

使用public限定词修饰属性或行为，则表示该属性或行为可以被外界访问得到，在四个权限中，public是范围最大的，同包同类、同包不同类、同包的子类、同包的非子类都可以访问。

一般开发的时候使用public修饰方法，让外界访问到方法，一般使用范围较小的权限修饰属性或行为，然后又想得到当前的属性或行为，那就可以采用公有接口的方式实现（再写一个方法，这个方法使用public修饰，这样就可以访问得到了。）

源代码：

Public类：

package com.zhong.www;

public class Public {
        public String pubStr="This is a public string";
        public void print(){
                System.out.println(pubStr);
        }
        public void testFun(){
                print();
        }
}

Test类：

package com.zhong.www;

public class Test {
        public static void main(String[] args){
                Public testPub=new Public();
                testPub.print();
                testPub.pubStr="modify the string";
                testPub.testFun();
                System.out.println(testPub.pubStr);
        }
}

输出结果：

This is a public string
modify the string
modify the string

从上面的使用public修饰子类中的方法，然后再测试的时候可以访问得到，就已经说明了public的可见性（访问范围），所以这里就不再重新写了，自己到自己的电脑上去试。

简单的使用这些权限限定词来封装一个美女类

封装之前先考虑好要封装什么。类名就叫MM吧。

属性：

MM有姓名，这个可以是公开的，让别人知道你的名字

MM有年龄，这个你要跟我关系好点再告诉你，那就使用protected修饰吧

MM有金钱，你和这个美女关系再好那么一点点那你就可以向她借钱了，不是很好的朋友啥的就不借钱，那就使用default修饰（实际写的时候什么都不加就是采用default）

MM有男朋友，这个的话你要和这个美女是闺蜜之类的关系才能知道的吧，那这个属性就是属于MM自己私有的，那就使用private修饰吧。

行为：

MM会跑步，那就封装一个run方法让她跑起来

MM会唱歌，那就放在一个sing方法让她能唱歌

就简单点就好。

开始封装：

package com.base;

public class MM {
        //属性
        public String name;
        protected int age;
        int money;
        private String boyfriend;
        //构造方法
        public MM(String name,int age,int money,String boyfriend){
                this.name=name;
                this.age=age;
                this.money=money;
                this.boyfriend=boyfriend;
                System.out.println("成功创建一个美女");
        }
        //行为
        public void run(){
                System.out.println(this.name+"在跑步");
        }
        public void sing(){
                System.out.println(this.name+"在唱歌");
        }
}

这里没有写get、set方法。同时也封装得比较简单，主要是理解。

Cukor丘克简单说Java