面向对象基础06（访问权限修饰符）

访问权限修饰符

修饰符分类

• 根据修饰符修饰位置的不同，Java的访问权限控制符可以分成两类
  • 修饰类中成员，方法和变量。控制类中的成员，对其他类可见性（其他类是否可以直接使用到）
  • 修饰类。用来限定整个类，对于外部使用者的可见性（是否能使用该类型）

​

类中成员访问权限修饰符

对于类中成员的访问权限控制，访问权限控制符总位于定义的开头位置，可以使用的修饰符有4种：

​ 1，public：任意类均访问，实际就是没有限制访问权限

​ 2，protected：同包中的其他类，和不同包的(可见)子类均可见，一部分类可以访问到，一部分不行。

​ 3，default(默认权限，隐式定义，不写任何关键字)，同包中的其他类可见，不关心是不是子类

​ 4，private，仅对同类中的其他成员可见

cn.itcast.Fu

public class Fu {
    private void show1() {
        System.out.println("private");
    }

    void show2() {
        System.out.println("默认");
    }

    protected void show3() {
        System.out.println("protected");
    }

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

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }

}

cn.itcast.zi

public class Zi extends Fu {

    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();
    }

}

cn.itcast.Demo

public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

com.itheima.zi

import cn.itcast.Fu;
public class Zi extends Fu {

    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show3();
        z.show4();
    }
}

com.itheima.Demo

import cn.itcast.Fu;
public class Demo {
    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show4();
    }
}

类访问权限修饰符

​ 对于类的访问权限控制，就简单很多，只有两种：

​ 1，public：对其他任意类可见

​ 2，default：对同包中的其他类可见

​ 3，内部类可以有四种访问权限

为什么使用访问权限控制符？

• 告诉代码的使用者，哪些地方不要触碰，或者说告诉他们该用什么
  • 工具类，我们不希望别人创建对象，所有私有化构造器
  • 方法的中间方法，我们也不希望别人使用，私有化
  • 私有化构造器，然后提供public方法创建对象
• 对于代码的书写者而言，隐藏代码的具体实现细节，可以很方便的修改代码实现

那么我们现在是不是已经上了快十天课了吧，是吧？大家觉得累不累啊？其实肯定是很累的，996其实对于我们来说，好像更轻松。大家第一周的问卷，我虽然

​

补充protected

回顾一下protected关键字，四个等级的访问权限

​ protect修饰符：同包和其他包中的子类可以访问

​ protected四个等级访问：

​ 1，同类中，可以访问

​ 2，同包的子类或其他类中，始终都是可以访问该类的protected成员

​ a，在同包的子类或其他类中，创建该类对象，可以访问该类的protected成员

​ b，在同包的子类或其他类中，创建该类不同包的子类对象时，可以访问访问该类的protected成员

​ 3，不同包的子类中，分情况：

​ a，创建父类对象，无法访问，该类的protected成员

​ b，创建子类对象，可以访问，该类的protected成员

​ c，在该子类中创建另一个子类的对象，无法访问，该类的protected成员

​ 结论：不同包的子类中，只能访问这个子类对象本身，从父类继承过来的，protected成员

​ 而无法访问，父类本身的，protected成员

​ 更不能去访问，其他类，从父类继承过来的，protected成员

​

​ 4，不同包的其他类中，始终都不可以访问该类的protected成员

​ a，创建该类对象，不可以访问该类的protected成员

​ b，创建该类的子类对象，不可以访问该类的protected成员

​ 总结简单一点：

​ 1，同包中，都可以访问

​ 2，不同包中，只能访问自身，从父类继承过来的，protected成员

​

如果你还是不能理解，那么就要放大招了，比较形象的理解：

​ 1，在家庭中（同包），不管是不是儿子，protected的成员随便用

​ 2，一旦分家后（不同包），只有儿子（子类中）才能用他自己继承过来（子类对象）的protected的成员

题目实例：

定义一个Student类，并要求其他类在使用Student类的时候，最多只能创建10个Student类的对象，如何实现？
提示：
首先，要实现该功能，就不能让外部类直接使用new Student(…)的方式来创建对象，如何不能让其他类new Student(…)，只需将Student类的所有构造方法的，权限改为private即可。
接着，把创建对Student对象的工作，交给一个专门的方法去做(想想这个方法应该是怎样的方法)，活用static和访问权限修饰符。

public class Student {
    public static void main(String[] args) {
        for (int j = 0; j < 12; j++) {
            Student.newCreate();
        }
    }
    static int i = 1;
    public static Student newCreate() {
        if (i <= 10) {
            System.out.println("输出第" + i + "个对象");
            Student student = new Student();
            i++;
            return student;
        } else {
            System.out.println("对象已满无法创建");
            return null;
        }
    }
}

输出：

输出第1个对象
输出第2个对象
输出第3个对象
输出第4个对象
输出第5个对象
输出第6个对象
输出第7个对象
输出第8个对象
输出第9个对象
输出第10个对象
对象已满无法创建
对象已满无法创建