学习笔记01---Java中的访问权限修饰符

最新推荐文章于 2024-08-20 16:11:23 发布
最新推荐文章于 2024-08-20 16:11:23 发布
阅读量286 收藏 2
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43381217/article/details/109600824
版权

一、四种访问控制权限

Java面向对象中的封装性是通过对成员变量和成员方法进行访问控制所实现的，访问控制分为4个级别，级别从高到低依次为：（公有）public、（保护）protected、（默认）default、（私有）private。

  • public：公有型访问权限，访问级别最高，被该级别修饰的成员方法和成员变量可以在任何类中被访问到。
  • protected：保护型访问权限，所谓的保护型，其实就是为了保证某个类的子类无论是在同包还是不同包情况下，都能够自继承父类中的protected所修饰的成员变量和成员方法。
  • default：默认权限修饰符，一般省略不写。默认级别修饰的成员变量和成员方法，可以在当前类内部和同一个包下的类（即同包下的子类和无关类）都能被访问到。
  • private：私有权限修饰符，访问权限最低，被该权限修饰的成员变量和成员方法只能在当前类的内部被访问到，若外部类想要访问或修改它的private修饰的成员变量，那么它必须通过其所提供的setX/getX方法才行。

如下表格：
访问权限比较

二、代码实现

包结构图如下：
在这里插入图片描述

1、访问权限修饰符----同一个类中：

四种访问权限都能访问到。

package com.zhuenmin.extends03.aaa;

/**
 * @author pro_art
 * @date 2020/11/10 15:30
 * 访问权限修饰符----同一个类中
 **/
public class Student {
    public String name;
    protected String id;
    String tel;
    private String address;

    public void publicMethod(){
        System.out.println("当前类中公有方法");
    }
    protected void protectedMethod(){
        System.out.println("当前类中保护型方法");
    }
    void defaultMethod(){
        System.out.println("当前类中默认方法");
    }
    private void privateMethod(){
        System.out.println("当前类中私有方法");
    }

    public static void main(String[] args) {
        /*
        * 在当前类中，任何修饰符的成员变量和成员方法都能访问
        */
        Student student = new Student();
        //成员变量的访问
        String address = student.address;
        String id = student.id;
        String tel = student.tel;
        String name = student.name;
        //成员方法的访问
        student.publicMethod();
        student.protectedMethod();
        student.defaultMethod();
        student.privateMethod();
    }
}
2、访问修饰符----同包下的子类
  1. 在同包子类下创建父类对象，父类对象能访问自己的public、protected、default修饰符的成员变量或方法
  2. 在同包子类下创建子类对象，子类能继承父类的public、protected、default修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
  • 父类
package com.zhuenmin.extends03.aaa;

/**
 * @author pro_art
 * @date 2020/11/10 15:30
 * 访问修饰符----同包下的父类
 **/
public class Fu {
    public int id;
    protected int age;
    String name;
    private String sex;

    public void publicMethod(){
        System.out.println("父类公有方法");
    }
    protected void protectedMethod(){
        System.out.println("父类保护型方法");
    }
     void defaultMethod(){
        System.out.println("父类默认方法");
    }
    private void privateMethod(){
        System.out.println("父类私有方法");
    }
}
  • 子类
package com.zhuenmin.extends03.aaa;

/**
 * @author pro_art
 * @date 2020/11/10 15:30
 * 访问修饰符------同包下的子类
 **/
public class Zi extends Fu{
    public static void main(String[] args) {
        /*
            在同包子类下创建父类对象，父类对象能访问自己的public、protected、default
            修饰符的成员变量或方法
        */
        Fu fu = new Fu();
        //成员变量
        int id = fu.id;
        int age = fu.age;
        String name = fu.name;
        String sex = fu.sex;    //报错，在这里无法访问父类对象自己的private成员变量
                                //只能在父类本身java文件中才可以访问
        //成员方法
        fu.publicMethod();
        fu.protectedMethod();
        fu.defaultMethod();
        fu.privateMethod();     //报错，在这里无法访问父类对象自己的private方法，
                                //只能在父类本身java文件中才可以访问

        /*
            在同包子类下创建子类对象，子类能继承父类的public、protected、default
            修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
        */
        Zi zi = new Zi();
        //成员变量
        int id1 = zi.id;
        int age1 = zi.age;
        String name1 = zi.name;
        String sex1 = zi.sex;   //报错 在这里子类对象无法继承父类的private成员变量

        //成员方法
        zi.publicMethod();
        zi.protectedMethod();
        zi.defaultMethod();
        zi.privateMethod();     //报错，子类无法继承父类的的private成员方法
    }
}
3、访问修饰符----同包下的无关类
  1. 在同包无关类下创建父类对象，父类对象能访问自己的public、protected、default修饰符的成员变量或方法。
  2. 在同包无关类下创建子类对象，子类能继承父类的public、protected、default修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
package com.zhuenmin.extends03.aaa;

/**
 1. @author pro_art
 2. @date 2020/11/10 15:30
 3. 访问修饰符-----同包下的无关类
 **/
public class ABC {
    public static void main(String[] args) {
        /*
            在同包无关类下创建父类对象，父类对象能访问自己的public、protected、default
            修饰符的成员变量或方法
        */
        Fu fu = new Fu();
        int id = fu.id;
        int age = fu.age;
        String name = fu.name;
        String sex = fu.sex;    //报错，同包无关类下无法访问父类对象自己的private成员变量
                                //只能在父类本身java文件中才可以访问

        fu.publicMethod();
        fu.protectedMethod();
        fu.defaultMethod();
        fu.privateMethod();     //报错，同包无关类下无法访问父类对象自己的private方法，
                                //只能在父类本身java文件中才可以访问
        /*
            在同包无关类下创建子类对象，子类能继承父类的public、protected、default
            修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
        */
        Zi zi = new Zi();
        int id1 = zi.id;
        int age1 = zi.age;
        String name1 = zi.name;
        String sex1 = zi.sex;   //报错 同包无关类下子类对象无法继承父类的private成员变量

        zi.publicMethod();
        zi.protectedMethod();
        zi.defaultMethod();
        zi.privateMethod();     //报错，同包无关类下子类无法继承父类的的private成员方法
    }
}
4、访问权限修饰符----不同包下子类
  1. 不同包下子类创建当前子类对象时，该当前子类对象只能继承父类的public、protected修饰符的成员变量和方法，无法继承default、private修饰符的成员变量和方法。
  2. 不同包下子类创建父类对象时，该当前父类对象只能访问自己的public修饰符的成员变量和方法，无法访问protected、default、private修饰符的成员变量和方法。
package com.zhuenmin.extends03.bbb;
import com.zhuenmin.extends03.aaa.Fu;

/**
 1. @author pro_art
 2. @date 2020/11/10 15:30
 3. 访问权限修饰符----不同包下子类
 **/
public class Zi extends Fu{
    public static void main(String[] args) {
        /*
          不同包下子类创建当前子类对象时，该当前子类对象只能继承父类的public、protected修饰符的
          成员变量和方法，无法继承default、private修饰符的成员变量和方法。
        */
        Zi zi = new Zi();
        int id = zi.id;
        int age = zi.age;
        String name = zi.name; //不同包下子类创建的子类对象，无法访问父类的default修饰符成员变量
        String sex = zi.sex;   //不同包下子类创建的子类对象，无法方位父类的private修饰符成员变量

        zi.publicMethod();
        zi.protectedMethod();
        zi.defaultMethod();     //报错，不同包下子类创建的子类对象，无法继承父类的的private成员方法
        zi.privateMethod();     //报错，不同包下子类创建的子类对象，无法继承父类的的private成员方法

        /*
          不同包下子类创建父类对象时，该当前父类对象只能访问自己的public修饰符的成员变量和方法，
          无法访问protected、default、private修饰符的成员变量和方法。
        */
        Fu fu = new Fu();
        int id1 = fu.id;
        int age1 = fu.age;      //报错，不同包下子类创建的父类对象，无法访问自己的protected成员
        String name1 = fu.name; //报错，不同包下子类创建的父类对象，无法访问自己的default成员变量
        String sex1 = fu.sex;   //报错，不同包下子类创建的父类对象，无法访问自己的private成员变量

        fu.publicMethod();
        fu.protectedMethod();   //报错，不同包下子类创建的父类对象，无法访问自己的protected成员方法
        fu.defaultMethod();     //报错，不同包下子类创建的父类对象，无法访问自己的default成员方法
        fu.privateMethod();     //报错，不同包下子类创建的父类对象，无法访问自己的private成员方法

    }
}
4、访问权限修饰符----不同包下无关类
  1. 在不同包无关类下创建父类对象，父类对象只能访问自己的public修饰符的成员变量或方法，无法访问protected、default、private修饰符的成员变量和方法。
  2. 在不同包子类下创建子类对象，子类能继承父类的public、protected、default修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
package com.zhuenmin.extends03.bbb;
import com.zhuenmin.extends03.aaa.Fu;

/**
 * @author pro_art
 * @date 2020/11/10 15:30
 * 访问权限修饰符----不同包下无关类
 **/
public class BCA {
    public static void main(String[] args) {
        /*
            在不同包无关类下创建父类对象，父类对象只能访问自己的public修饰符的成员变量或方法，
            无法访问protected、default、private修饰符的成员变量和方法。
        */
        Fu fu = new Fu();
        int id = fu.id;
        int age = fu.age;       //报错，不同包下无关类下无法访问父类对象自己的protected成员变量
        String name = fu.name;  //报错，不同包下无关类下无法访问父类对象自己的default成员变量
        String sex = fu.sex;    //报错，不同包下无关类下无法访问父类对象自己的private成员变量


        fu.publicMethod();
        fu.protectedMethod();   //报错，不同包下无关类下无法访问父类对象自己的protected成员方法
        fu.defaultMethod();     //报错，不同包下无关类下无法访问父类对象自己的default成员方法
        fu.privateMethod();     //报错，不同包下无关类下无法访问父类对象自己的private成员方法

        /*
            在不同包子类下创建子类对象，子类能继承父类的public、protected、default
            修饰符的成员变量或方法，无法继承父类的private的成员变量或方法。
        */
        Zi zi = new Zi();
        int id1 = zi.id;
        int age1 = zi.age;      //报错 不同包无关类下子类对象无法继承父类的protected成员变量
        String name1 = zi.name; //报错 不同包无关类下子类对象无法继承父类的default成员变量
        String sex1 = zi.sex;   //报错 不同包无关类下子类对象无法继承父类的private成员变量

        zi.publicMethod();
        zi.protectedMethod();   //报错，不同包下无关类下无法访问父类对象自己的protected成员方法
        zi.defaultMethod();     //报错，不同包下无关类下无法访问父类对象自己的default成员方法
        zi.privateMethod();     //报错，不同包下无关类下无法访问父类对象自己的private成员zi
    }
}

总结

private修饰符常用于对类内部进行封装，对类内部成员和数据起到一个很好的保护作用。

说明

第一次写博客，当作学习笔记用，希望也能够带给有需要的小伙伴们一点小帮助，有错误之处烦请各位前辈大佬们批评指正，感谢。

Programming_artist
关注
Java-权限访问修饰符
whbing1471的博客
12-12 2287
Java 权限访问修饰符public、friendly、protected、private，记录下这几个权限的范围。 一、背景补充 访问权限是为了管理对象与外部使用者交互的范围，外部使用者能够根据不同的访问权限与所使用的对象进行通信，同时，访问权限能够很好的将内部的逻辑很好的封装控，使得使用者更容易理解使用，同时在重构的过程中也能减少对客户端的感知，重构的时候可以修改对客户端无感知的过程。 访问权限是基于包（package）概念上建立起来的，本包、外部包之间的类交互控制是通过访问权限进行控制的。 包是一.
Java学习笔记 --- 内部类
乌云的博客
10-19 656
一个类的内部又完整的嵌套了另外一个类的结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。就是我们类的第五大成员（属性、方法、构造器、代码块、内部类），内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间包含的关系。
Java权限访问修饰符
weixin_44016361的博客
08-12 197
Java中访问权限修饰符有public、private、default、protected，什么也不加就是default。
Java 的访问控制修饰符
最新发布
goTsHgo的博客
08-20 989
被访问，其他类（包括子类）不能访问它。字段: 被 private 修饰的字段只能在定义它的类内部被访问，其他类（包括子类）不能访问或修改它。
Java访问权限修饰符
m0_62729850的博客
07-16 839
Java 提供了四种访问权限修饰符，用于控制类、方法和变量的访问范围。它们是 public、protected、default（无修饰符）和 private。以下是对这四种修饰符的详细解释和用法
JAVA的权限修饰符
2301_80841939的博客
04-29 490
这些权限修饰符在Java编程中非常重要，它们帮助程序员控制代码的可见性和访问范围，从而提高代码的安全性和可维护性。根据具体的场景和需求，可以灵活地选择适当的权限修饰符来修饰类、方法或变量。Java中的权限修饰符是用来控制类、方法、变量等元素在程序中的访问权限的关键字。
JavaSE基础之（八）Java中的访问权限修饰符
qq_50994235的博客
08-29 218
八、Java 中的访问权限修饰符
[Java学习笔记doc]-javase基本知识
08-11
- **访问修饰符**：`public`, `private`, `protected`控制类、方法和变量的访问权限。 - **封装**：隐藏实现细节，提供公共接口与外界交互。 3. **继承与多态** - **继承**：一个类可以继承另一个类的属性和方法...
Java-封装--学习笔记.docx
07-05
1. **`static` 修饰符**：`static` 可以用于修饰成员变量和方法，使得它们成为类变量和类方法。这些静态元素在类加载时就存在，不需要创建对象就可以直接通过类名访问。 2. **静态代码块**：`static` 修饰的代码块会...
C++学习笔记14 -访问权限问题
qq_38958704的博客
08-11 1048
c++访问权限问题
java笔记--
04-16
- **封装**：通过访问修饰符控制数据的访问权限，实现信息隐藏。 - **继承**：一个类可以继承另一个类的属性和方法，实现代码复用。 - **多态**：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行...
java访问权限修饰符详解
weixin_52629592的博客
11-10 1676
访问权限修饰符: 由小到大—private –default—protected—public Private: java语言中访问权限限制最窄的修饰符,一般称之为”私有的”,被其修饰的类,属性,以及方法只能被该类的对象访问,其子类不能访问,更不允许跨包访问. Default: 即不加任何访问修饰符,通常称为”默认访问模式”,该模式下,只允许在同一个包中进行访问. Protected: 介于public和private之间的一种访修饰符,一般称之为”保护型”,被其修饰的类,属...
访问权限控制修饰符
lancehao的博客
09-06 270
访问权限控制修饰符
Java——访问控制权限修饰符
weixin_62838185的博客
02-17 514
/** * 访问控制权限修饰符： * * 1、访问控制权限修饰符来控制元素的访问范围。 * * 2、访问控制权限修饰符包括： * public 表示公开的，在任何位置都可以访问 * protected 同包、子类（继承）可以访问 * 缺省（不写） 同包可以访问 * private 表示私有的，只能在本类中访问 * * 3、...
java中4种访问权限修饰符
hanshzh的博客
10-12 145
在Java编程语言中有四种权限访问控制符，这四种访问权限的控制符能够控制类中成员的可见性。 一、public (1) 定义：public是公共的，被public所修饰的成员可以在任何类中都能被访问到。 (2) 修饰的成分： public能用来修饰类，在一个java源文件中只能有一个类被声明为public，而且一旦有一个类为public，那这个java源文件的文件名 就必须要和这个被public所...
Java四种访问权限修饰符
码农翻身的博客
04-20 247
ps：内容来自尚硅谷：http://www.gulixueyuan.com/my/course/309 Java权限修饰符public、protected、(缺省)、private置于类的成员定义前， 用来限定对象对该类成员的访问权限 对于class的权限修饰只可以用public和default(缺省)。 public类可以在任意地方被访问。 default类只可以被同一个包内部的类访问 ...
java中四种访问权限修饰符
故常无，欲以观其妙；常有，欲以观其徼；
04-17 628
(即默认，什么也不写）: 只有同包内的所有类可见，其他包不可见 ，不使用任何修饰符。使用对象：类、接口、变量、方法。Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。: 同包内的所有类和其他包子类可见。protected修饰的对象：变量、方法，类。四种访问权限修饰符public、default、protect、private。使用对象：类、接口、变量、方法。: 在同一类内可见。使用对象：变量、方法。
权限控制访问修饰符
zy_remarkable的博客
06-07 772
private: 修饰属性时，属性只能在本类中被调用，其他类中不可见 修饰方法时，方法也能在本类中被调用，对其他类型不可见 可以修饰内部类。 default： 修饰属性时，在本类中可以使用，在同一个包下，可以被使用 修饰方法， 在本类中可以使用，同一个包的类中可以使用 修饰类 （同包不同类中调用) protected： 修饰属性时，本类，同一个包，子类中可见 修饰方法时，本类，...
修饰符访问控制权限
a214704的博客
07-30 241
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值