JAVA基础 访问控制

今天我们来聊一聊访问控制

什么是访问控制呢？

访问控制就是JAVA中控制类外的程序，能够访问类中的那些的成员。

有些人可能会问了，类的成员变量不是都能在外部访问吗？ 其实不是的。

这和现实中一样。我们有很多属性也是不能对外公开的，比如说你的银行卡的卡号和密码，或者说银行存折的余额，女孩的体重，女孩的年龄这些都是不能被访问的。

JAVA中也是一样的，我们的类中的成员不应该被随便就被外界轻易的访问到，甚至被外界破坏掉。
JAVA中使用类封装成员，并不是仅仅为了，把成员集中在一起保存这么简单，它更重要的目的是保护这些成员。

JAVA的4个保护级别

第一种是 pubulic ， public级别是最公开的，也就是完全没有限制可以随便的访问
第二种是 private ，它和public相反，它是私有的，也就是完全的私密，外界完全不能访问
第三种是 protected，它是专门用于继承当中的父子类之间
第四种就是默认的控制级别

访问控制

在讲访问控制之前，我们先讲一下包，那么什么是包呢?

包(package)

・在硬盘.上，包是存储多类(.class)的文件夹
・在程序中,组织多类名,避免类名冲突的名称空间
・包的作用,就是分组管理类定义,并避免类名冲突
・Java源代码中,第一行, 一般都要指定当前类所属的包名,
・语法:
・package 包名; 其中 ,包名建议所有字母小写。
・其实, Java中一个类的全名,应该是:包名.类名。
-例如:

・Java规定:
-任何类的.class文件,必须保存在类中指定的包名文件夹下。
-同一个包中不能保存两个同名的类

package语句

包名也可以有层次结构。定义多层包名,语法:

• package 顶级包名.子级包名…n级包名;
  -说明，每一级包名使用 “.” 连接。
  -包名层次结构和文件夹层次结构完全对应
  多层包名的一般规范: package 公司或组织的域名.项目名.功能模块名
  例如:
  org.apache.commons.lang
  org.apache 公司域名
  commons 项目名称
  lang 功能模块

再比如:腾讯公司要做一套学生管理系统。 其中包含一个课程管理功能模块:
com.tencent .studentmgt .coursemgt

import语句

・访问类时都需要使用类的全称。如果不写全称,仅用类名,默认只在当前包中寻找。
例如: Scanner类,其实全称: java.util.Scanner

java.util.Scanner sc=new java.util.Scanner(System.in);
//编译正确。但是太繁琐

可以通过import语句先引入类的全称,语法:

• import类的完全限定名;
  -完全限定名:就是包名.类名

通过import语句引入了类的全称后,在当前源文件中就可以仅使用类名访问了
例如:

import java util. Scanner;
Scanner sc=new Scanner(System.in);
//编译正确。因为已经导入了完全限定的类名

接下来我们直入主题 学习访问控制修饰符

访问控制修饰符

封装的意义

水果店的功能，无非就是上货，打包，称重，收款等等

现在水果店有2种经营模式：

A：老板当甩手掌柜，客户自己随便取水果、随便称重，随便找零钱。
B：老板帮客户取水果，打包，找零。

第一种经营模式肯定行不通，可能上午开门，下午就倒闭了。

封装的意义

对外提供可调用的、 稳定的功能;
封装内部具体的实现细节, 外界不可访问,这样的好处在于:
-降低出错的可能性,便于维护;
-内部变化,不会影响外部使用;

---

public和private

●private修饰的成员只能在本类的成员方法中使用
●通常类的成员变量都应该使用private严格控制。只能通过类提供的方法访问。
●private修饰的成员仅是对内使用,如果“公开”会大幅增加维护成本。
●public修饰的成员可以在任何地方使用。
●凡是对外的成员方法要非常的健壮和稳定

封装水果店属性和功能的类

package day07;

/**
 * 封装水果店属性和功能的类
 */
public class Shop {
    
    
        double buying=5.5; //水果的进价5块5一斤
        double price=8; //销量8块一斤
        double total; //销售量(斤数)

        /**
         * 卖水果的方法
         * money 多少钱
         * count 多少斤
         */
         void sale(double money,double count){
    
    
            //累加销量量
            total+=count;
            //输出本次购买的结果
            System.out.println("您购买的水果"+count
                    +"斤水果，收您"+money
                    +"元，找零"+(money-price*count));
      }
}

我们先来测试：如果一个顾客进到店里买水果，他先看了看进价，又看了看售价，感觉卖的太贵了，一气之下把你的售价改成了0.01元，然后给了一百元。

package day07;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Shop s=new Shop();
        //加入一个顾客来买水果，先看了进价5.5元
        System.out.println(s.buying);
        //又看了看售价8元
        System.out.println(s.price);
        //他愤怒的把售价price改成为0.01
        s.price=0.01;
        //再调用sale方法
        s.sale(100,10);
    }
}

以上案例可以知道，我们的进价是不能让人轻易的看见或修改，那么怎么解决这个问题呢？
我们来对代码进行修改，让进价不可见，让售价不能修改，也要加上private！

package day07;

/**
 * 封装水果店属性和功能的类
 */
public class Shop {
    
    
       private double buying=5.5; //水果的进价5块5一斤
       private double price=8; //销量8块一斤
        double total; //销售量(斤数)

    /**
     *专门读取price属性的方法
     * 相当于老板可以告诉客人，这水果多少钱，但是客人不知道
     * @return
     */
    public double getBuying() {
    
    
        return buying;
    }
    public double getPrice() {
    
    
        return price;
    }

    /**
         * 卖水果的方法
         * money 多少钱
         * count 多少斤
         */
         void sale(double money,double count){
    
    
            //累加销量量
            total+=count;
            //输出本次购买的结果
            System.out.println("您购买的水果"+count
                    +"斤水果，收您"+money
                    +"元，找零"+(money-price*count));
      }
}

经过修改private 加密，我们可以发现无法进行读取和修改了
只能通过get方法调用

package day07;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Shop s=new Shop();
        //加入一个顾客来买水果，先看了进价5.5元
        //System.out.println(s.buying);
        System.out.println(s.getBuying());

        //又看了看售价8元
        //System.out.println(s.price);
        System.out.println(s.getPrice());

        //他愤怒的把售价price改成为0.01
       // s.price=0.01; 已经无法修改
        //再调用sale方法
        s.sale(100,10);
    }
}

---

但是上面的代码还是不够完善，比如用户输入购买金额小于0怎么办，在比如用户金额小于应付金额怎么办？

接下来我们就继续修改，完善此代码：

package day07;

/**
 * 封装水果店属性和功能的类
 */
public class Shop {
    
    
       private double buying=5.5; //水果的进价5块5一斤
       private double price=8; //销量8块一斤
        double total; //销售量(斤数)

    /**
     *专门读取price属性的方法
     * 相当于老板可以告诉客人，这水果多少钱，但是客人不知道
     * @return
     */
    public double getBuying() {
    
    
        return buying;
    }

    public double getPrice() {
    
    
        return price;
    }

    /**
         * 卖水果的方法
         * money 多少钱
         * count 多少斤
         */
         void sale(double money,double count){
    
    
             /*公开的方法，要放出错*/
             if (money< 0 || count <=0){
    
      //数量<=0
                 System.out.println("购买的数量和钱必须>0");
             }else if (money<price*count){
    
     //钱给的不够
                 System.out.println("你的钱不够");
             }else{
    
    //正常执行逻辑
            //累加销量量
            total+=count;
            //输出本次购买的结果
            System.out.println("您购买的水果"+count
                    +"斤水果，收您"+money
                    +"元，找零"+(money-price*count));
               }
         }
}

根据修改，我们可以发现，现在代码逻辑执行正常了

package day07;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Shop s=new Shop();
        //加入一个顾客来买水果，先看了进价5.5元
        //System.out.println(s.buying);
        System.out.println(s.getBuying());

        //又看了看售价8元
        //System.out.println(s.price);
        System.out.println(s.getPrice());

        //他愤怒的把售价price改成为0.01
       // s.price=0.01; 已经无法修改
        //再调用sale方法
        s.sale(50,10); //付款50元,应付款80元，钱不够
        s.sale(-10,10);//付款-10元，购买的数量和钱必须>0
    }
}

protected和默认访问控制

●默认访问控制(不写任何修饰符)的成员,仅在同一个包中可用
●protected修饰的成员可以被同一个包中的类以及子类使用。

生活案例:包就好像我们现实中，我们家的小区，Shop类就好像我们小区内的一个水果店，默认只有本小区的人才知道，其他小区的人是不知道的。

public void sale(double money,double count){

如果我们想其他小区的人，也知道本小区有水果店呢？ 现实中一般老板会在小区门口放一个大大的广告牌，public就正好相当于这个广告牌，路过的人，都能看见，都能调用。

如果我们想其他小区的人，也知道本小区有水果店呢？ 现实中一般老板会在小区门口放一个大大的广告牌，public就正好相当于这个广告牌，路过的人，都能看见，都能调用。

package day07;

/**
 * 封装水果店属性和功能的类
 */
public class Shop {
    
    
       private double buying=5.5; //水果的进价5块5一斤
       private double price=8; //销量8块一斤
        double total; //销售量(斤数)

    /**
     *专门读取price属性的方法
     * 相当于老板可以告诉客人，这水果多少钱，但是客人不知道
     * @return
     */
    public double getBuying() {
    
    
        return buying;
    }

    public double getPrice() {
    
    
        return price;
    }

    /**
         * 卖水果的方法
         * money 多少钱
         * count 多少斤
         */
        public void sale(double money,double count){
    
    
             /*公开的方法，要放出错*/
             if (money< 0 || count <=0){
    
      //数量<=0
                 System.out.println("购买的数量和钱必须>0");
             }else if (money<price*count){
    
     //钱给的不够
                 System.out.println("你的钱不够");
             }else{
    
    //正常执行逻辑
            //累加销量量
            total+=count;
            //输出本次购买的结果
            System.out.println("您购买的水果"+count
                    +"斤水果，收您"+money
                    +"元，找零"+(money-price*count));
               }
         }
}

新建一个包，创建一个新的Test

package day08;

import day07.Shop;//导入day7中的Shop类

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Shop s = new Shop();
        s.sale(100,10);
    }
}

我们可以发现，给方法加上public过后，隔壁小区的也能购买了

---

这时，我们在隔壁小区开一家分店，属性和方法，都和总店一样。

package day07;

/**
 * 封装水果店属性和功能的类
 */
public class Shop {
    
    
       private double buying=5.5; //水果的进价5块5一斤
       private double price=8; //销量8块一斤
        double total; //销售量(斤数)

    /**
     *专门读取price属性的方法
     * 相当于老板可以告诉客人，这水果多少钱，但是客人不知道
     * @return
     */
    public double getBuying() {
    
    
        return buying;
    }

    public double getPrice() {
    
    
        return price;
    }

    /**
         * 卖水果的方法
         * money 多少钱
         * count 多少斤
         */
       protected void sale(double money,double count){
    
    
             /*公开的方法，要放出错*/
             if (money< 0 || count <=0){
    
      //数量<=0
                 System.out.println("购买的数量和钱必须>0");
             }else if (money<price*count){
    
     //钱给的不够
                 System.out.println("你的钱不够");
             }else{
    
    //正常执行逻辑
            //累加销量量
            total+=count;
            //输出本次购买的结果
            System.out.println("您购买的水果"+count
                    +"斤水果，收您"+money
                    +"元，找零"+(money-price*count));
               }
         }
}

开一家分店

package day08;

import day07.Shop;

/**
 * 开了一个分店
 */
public class SubShop extends Shop {
    
    
    /**
     * 重写父类的sale方法，使用super调用父类的sale方法
     * JAVA中规定，子类重写父类的方法，子类中的方法访问控制范围不能小于父类方法的控制范围
     */
    protected void sale(double money,double count){
    
    
        super.sale(money,count);
    }
}

测试：

package day08;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        SubShop ss= new SubShop();
        ss.sale(100,10);//100块，10斤
    }
}

---

访问控制符修饰成员

访问控制符修饰成员时的访问权限如下表所示:

●对于类的修饰可以使用public和默认方式。public修饰的类可以被任何一 个类使用;默认访问控制的类只可以被同一个包中的类使用。