访问权限修饰符（public、protected、private）、封装（私有化类属性、私有化类的某些方法）

最新推荐文章于 2025-03-30 09:49:36 发布

Watermelon_Mr

最新推荐文章于 2025-03-30 09:49:36 发布

阅读量4k

点赞数 12

分类专栏： javaSE 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/Watermelon_Mr/article/details/140500758

版权

javaSE 专栏收录该内容

32 篇文章

订阅专栏

一、访问权限修饰符

（一）Java语言中有四个访问权限修饰符

1、public：公共权限

（1）修饰对象：类（包括正常类和内部类）、成员变量、方法（包括构造方法和成员方法）

（2）权限范围：被修饰对象可以在系统中的任意类中都可以被访问

2、protected:受保护权限

（1）修饰对象：内部类、成员变量、方法（包括构造方法和成员方法）

（2）权限范围：被修饰对象只能在本类、同包类、不同包子类中被访问

3、：默认权限

（1）修饰对象：类（包括正常类和内部类）、成员变量、方法（包括构造方法和成员方法）

（2）权限范围：被修饰对象只能在本类、同包类中被访问

4、private：私有权限

（1）修饰对象：内部类、成员变量、方法（构造方法、成员方法）

（2）权限范围：被修饰对象只能在本类中被访问

（二）验证

1、正常类，可以使用公共权限（被public修饰后）和默认权限

（1）拥有公共权限的类-Car类

package com.ffyc.bcms.service;

public class Car {

}

在同包类Test中进行访问

package com.ffyc.bcms.service;

public class Test {
    public static void main(String[] args) {
        new Car();
    }
}

在不同包类Test中进行访问

package com.ffyc.bcms.web;

import com.ffyc.bcms.service.Car;
public class Test {
    public static void main(String[] args) {
        new Car();
    }
}

（2）拥有默认权限的类-Car类

package com.ffyc.bcms.service;

 class Car {

}

修改Car类的权限后，会发现

可以证明拥有默认权限的类可以在同包类中被访问但不能在不同包类中被访问

2、成员变量（可以使用公共权限（被public修饰后）、受保护权限（被protected修饰后）、默认权限和私有权限（被private修饰后））

在Car类中定义四个拥有不同访问权限的成员变量

public class Car {
      public int pubNum=1;// 拥有公共权限
      protected int proNum=2;// 拥有被保护权限
      int defNum=3;// 拥有默认权限
      private int priNum=4;// 拥有私有权限
}

（1）在同类中访问这四个变量

public class Car {
      public int pubNum=1;// 拥有公共权限
      protected int proNum=2;// 拥有被保护权限
      int defNum=3;// 拥有默认权限
      private int priNum=4;// 拥有私有权限

    public static void main(String[] args) {
        Car car=new Car();
        System.out.println(car.pubNum);
        System.out.println(car.proNum);
        System.out.println(car.defNum);
        System.out.println(car.priNum);
    }
}

结论：四个变量均可被正确访问

（2）在同包不同类中访问这四个变量

package com.ffyc.bcms.service;

public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        System.out.println(car.pubNum);
        System.out.println(car.proNum);
        System.out.println(car.defNum);
    }
}

结论：拥有私有权限的变量不可在同包其他类中被访问

（3）在不同包子类中访问这四个变量

package com.ffyc.bcms.web;


import com.ffyc.bcms.service.Car;

public class CarSon extends Car {
    public static void main(String[] args) {
        Car car=new Car();
        System.out.println(car.pubNum);
        System.out.println(new CarSon().proNum);
    }
}

结论：拥有私有权限和默认权限的变量不可在不同包子类中被访问

（4）在不同包其他类中访问这四个变量

package com.ffyc.bcms.web;

import com.ffyc.bcms.service.Car;
public class Test {
    public static void main(String[] args) {
        Car car=new Car();
        System.out.println(car.pubNum);
    }
}

结论：拥有私有权限、默认权限和受保护权限的变量不可在不同其他类中被访问

3、成员方法（可以使用公共权限（被public修饰后）、受保护权限（被protected修饰后）、默认权限和私有权限（被private修饰后））

验证过程与成员变量访问权限的验证过程类似

二、封装

1、封装的含义：

（1）包装：例如我们将一些常用的功能定义为一个方法

（2）面向对象语言的特征中的封装：将类的某些信息（通常指成员变量和某些成员方法）隐藏在类内部，不允许外部程序直接进行访问，必须通过类中提供的方法来实现对隐藏信息的操作（赋值）和访问（取值）

2、封装（面向对象语言中的特征）的好处

（1）隐藏了类的某些信息，保护了类中属性的数据值

（2）类的隐藏信息必须通过特定方法才能进行操作和访问

（3）便于在特定方法中加入控制语句，对外界程序赋予的值进行安全性和合法性控制

3、具体实现

（1）封装案例一：将类中属性私有化

第一级别：成员变量具有默认权限时，在本包中的其他类均可对其进行赋值，且值只要符合对应的数据类型即可，对所赋予值的安全性和和合法性控制难度大

如：

package com.ffyc.bcms.dao;

public class Person {
    String name;
    int age;
}
package com.ffyc.bcms.dao;

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        person.name="子鼠丑牛寅虎";
        person.age=999;
    }
}

第二级别：可在具有公共权限的构造方法中添加控制语句，完成对成员变量所赋予值的合法性和安全性控制，但在对成员变量进行赋值后无法在外界程序中使用成员变量的值

如：

package com.ffyc.bcms.dao;

public class Person {
    String name;
    int age;
    public Person(String name,int age){
        if(name.length()>0&&name.length()<=3){
            this.name=name;
        }
        if(age>0&&age<=150){
            this.age=age;
        }
    }
}
package com.ffyc.bcms.dao;

public class Test {
    public static void main(String[] args) {
        Person person=new Person("子鼠丑牛寅虎",999);
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

第三级别：在类中提供两个具有公共权限的方法以供外界程序对具有私有权限的成员变量进行赋值和取值操作（具体体现了面向对象语言特征之一——封装）

如：

package com.ffyc.bcms.dao;

public class Person {
    String name;
    int age;
    public Person(){

    }
    public Person(String name,int age){
        if(name.length()>0&&name.length()<=3){
            this.name=name;
        }
        if(age>0&&age<=150){
            this.age=age;
        }
    }
    public void setName(String name){
        if(name.length()>0&&name.length()<=3){
            this.name=name;
        }
    }
    public void setAge(int age){
        if(age>0&&age<=150){
            this.age=age;
        }
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}
package com.ffyc.bcms.dao;

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        person.setName("诸葛亮");
        person.setAge(99);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }

}

（2）封装案例2：将类中某些方法私有化-将构造方法私有化

Java设计模式（Java程序的模版/固定讨论）：解决一类问题的固定方式

如：单例模式：单个实例，在系统中，想让某个类只能创建一个对象（如计算机电脑上的任务管理器在Windows系统下只能创建一个）

第一步：私有化构造方法

第二步：对外提供获取类对象的静态方法，并使用控制语句控制该类只能创建一个对象

代码实现：

package com.ffyc.bcms.dao;


public class MyWindow {
    private static MyWindow myWindow=null;
    private MyWindow(){

    }
    public static MyWindow getMyWindow(){
        if(myWindow==null){
            myWindow=new MyWindow();
        }
        return myWindow;
    }
}
package com.ffyc.bcms.dao;

public class Test {
    public static void main(String[] args) {
        System.out.println(MyWindow.getMyWindow());
        System.out.println(MyWindow.getMyWindow());
        System.out.println(MyWindow.getMyWindow());
        System.out.println(MyWindow.getMyWindow());
    }

}