测试Java的访问修饰符

最新推荐文章于 2023-07-03 15:45:31 发布
最新推荐文章于 2023-07-03 15:45:31 发布
阅读量66 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46601365/article/details/115561447
版权

测试Java的访问修饰符

访问修饰符

public protected default(即不写也不能写) private

父类

package com.keke.myself.test01;

/**
 * @ClassName: Person
 * @Description:
 * @Author: keke
 * @Date: 2021/4/9
 */
public class Person {

    //成员变量 ：new一个本类对象才能调用
    public int a = 1;
    protected int b = 2;
    int c = 3;
    private int d = 4;



    //类变量 ：通过类名直接调用
    public static int e = 5;
    protected static int f = 6;
    static int g = 7;
    private static int h = 8;



    //构造方法
    public Person() {
    }

    protected Person(int a) {
        this.a = a;
    }

    Person(int a, int b) {
        this.a = a;
        this.b = b;
    }

    private Person(int a, int b, int c, int d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }



    //成员方法 / 非静态方法 ：new一个本类对象才能调用
    public void a() {
        System.out.println("aaa");
    }

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

    void c() {
        System.out.println("ccc");
    }

    private void d() {
        System.out.println("ddd");
    }



    //静态方法 ：通过类名直接调用
    public static void e() {
        System.out.println("eee");
    }

    protected static void f() {
        System.out.println("fff");
    }

    static void g() {
        System.out.println("ggg");
    }

    private static void h() {
        System.out.println("hhh");
    }

}

同一个包下的子类

package com.keke.myself.test01;

import com.keke.myself.test02.Student;

/**
 * @ClassName: Teacher
 * @Description:
 * @Author: keke
 * @Date: 2021/4/9
 */
public class Teacher extends Person {

    public Teacher() {
//        super(1,2,3,4); //报错
//        super(1,2);
//        super(1); //覆盖默认的无参构造方法，不能写多个父类的构造方法
//        super(); //不写默认也调用父类的无参构造方法
    }

    public static void main(String[] args) {
        Person p = new Person();

        int a = p.a;
        int b = p.b;
        int c = p.c;
//        int d = p.d; //报错

        int e = Person.e;
        int f = Person.f;
        int g = Person.g;
//        int h = Person.h; //报错

        p.a();
        p.b();
        p.c();
//        p.d(); //报错

        Person.e();
        Person.f();
        Person.g();
//        Person.h(); //报错

        Person p1 = new Person(1);
        Person p2 = new Person(1, 2);
//        Person p2 = new Person(1, 2, 3, 4); //报错

        Teacher teacher = new Teacher();

        int ta = teacher.a;
        int tb = teacher.b;
        int tc = teacher.c;
//        int td = teacher.d; //报错

        teacher.a();
        teacher.b();
        teacher.c();
//        teacher.d(); //报错

//        super(); //Call to 'super()' must be first statement in constructor body：构造方法只能写在子类构造方法的第一行

        Student student = new Student();
        //满足同包非子类，故protected修饰的可以访问
        //不满足同包子类（子类指new出来的对象所代表的类与创建对象的类相同且都是子类），故default修饰的不能访问

        int sa = student.a;
        int sb = student.b;
//        int sc = student.c; //报错
//        int sd = student.d; //报错

        student.a();
        student.b();
//        student.c(); //报错
//        student.d(); //报错

    }

}

同一个包下非子类

package com.keke.myself.test01;


import com.keke.myself.test02.Student;

/**
 * @ClassName: Animal
 * @Description:
 * @Author: keke
 * @Date: 2021/4/9
 */
public class Animal {

    public Animal() {
//        super(); //不是子类不能使用super关键字调用父类的构造方法，此super调用的是Object类的构造方法
    }

    public static void main(String[] args) {

        Person p = new Person();

        int a = p.a;
        int b = p.b;
        int c = p.c;
//        int d = p.d; //报错

        int e = Person.e;
        int f = Person.f;
        int g = Person.g;
//        int h = Person.h; //报错

        p.a();
        p.b();
        p.c();
//        p.d(); //报错

        Person.e();
        Person.f();
        Person.g();
//        Person.h(); //报错

        Person p1 = new Person(1);
        Person p2 = new Person(1, 2);
//        Person p2 = new Person(1, 2, 3, 4); //报错

        Teacher teacher = new Teacher();

        int ta = teacher.a;
        int tb = teacher.b;
        int tc = teacher.c;
//        int td = teacher.d; //报错

        teacher.a();
        teacher.b();
        teacher.c();
//        teacher.d(); //报错

//        super(); //Call to 'super()' must be first statement in constructor body：构造方法只能写在子类构造方法的第一行

        Student student = new Student();
        //满足同包非子类（相对于创建对象与父类）故protected修饰的可以访问
        //不满足同包子类（创建对象的类是子类），故default修饰的不能访问

        int sa = student.a;
        int sb = student.b;
//        int sc = student.c; //报错
//        int sd = student.d; //报错

        student.a();
        student.b();
//        student.c(); //报错
//        student.d(); //报错

    }

}

不同一个包下的子类

package com.keke.myself.test02;

import com.keke.myself.test01.Person;
import com.keke.myself.test01.Teacher;

/**
 * @ClassName: Student
 * @Description:
 * @Author: keke
 * @Date: 2021/4/9
 */
public class Student extends Person {

    public Student() {
//        super(1,2,3,4); //报错
//        super(1,2); //报错
//        super(1); //覆盖默认的无参构造方法，不能写多个父类的构造方法
//        super(); //不写默认也调用父类的无参构造方法
    }

    public static void main(String[] args) {
        Person p = new Person();

        int a = p.a;
//        int b = p.b; //报错
//        int c = p.c; //报错
//        int d = p.d; //报错

        int e = Person.e;
        int f = Person.f;
//        int g = Person.g; //报错
//        int h = Person.h; //报错

        p.a();
//        p.b(); //报错
//        p.c(); //报错
//        p.d(); //报错

        Person.e();
        Person.f();
//        Person.g(); //报错
//        Person.h(); //报错

//        Person p1 = new Person(1);
//        Person p2 = new Person(1, 2);
//        Person p2 = new Person(1, 2, 3, 4); //报错

        Student student = new Student();

        int sa = student.a;
        int sb = student.b;
//        int sc = student.c; //报错
//        int sd = student.d; //报错

        student.a();
        student.b();
//        student.c(); //报错
//        student.d(); //报错

        Teacher teacher = new Teacher();
        //不满足不同包子类（子类指new出来的对象所代表的类与创建对象的类相同且都是子类）

        int ta = teacher.a;
//        int tb = teacher.b; //报错
//        int tc = teacher.c; //报错
//        int td = teacher.d; //报错

        teacher.a();
//        teacher.b(); //报错
//        teacher.c(); //报错
//        teacher.d(); //报错

    }

}

不同一个包下不是子类

package com.keke.myself.test02;

import com.keke.myself.test01.Person;

/**
 * @ClassName: Plant
 * @Description:
 * @Author: keke
 * @Date: 2021/4/9
 */
public class Plant {

    public Plant() {
//        super(); //不是子类不能使用super关键字调用父类的构造方法，此super调用的是Object类的构造方法
    }

    public static void main(String[] args) {
        Person p = new Person();

        int a = p.a;
//        int b = p.b; //报错
//        int c = p.c; //报错
//        int d = p.d; //报错

        int e = Person.e;
//        int f = Person.f; //报错
//        int g = Person.g; //报错
//        int h = Person.h; //报错

        p.a();
//        p.b(); //报错
//        p.c(); //报错
//        p.d(); //报错

        Person.e();
//        Person.f(); //报错
//        Person.g(); //报错
//        Person.h(); //报错

//        Person p1 = new Person(1);
//        Person p2 = new Person(1, 2);
//        Person p2 = new Person(1, 2, 3, 4); //报错

        Student student = new Student();
        //不满足不同包子类（子类指new出来的对象所代表的类与创建对象的类相同且都是子类）

        int sa = student.a;
//        int sb = student.b; //报错
//        int sc = student.c; //报错
//        int sd = student.d; //报错

        student.a();
//        student.b(); //报错
//        student.c(); //报错
//        student.d(); //报错

    }

}

结论

1、public修饰符修饰成员变量、类变量、构造方法、成员方法(即非静态方法)、静态方法在不同包及同包的子类或者其他类都能访问

2、private修饰符修饰成员变量、类变量、构造方法、成员方法(即非静态方法)、静态方法在不同包及同包的子类或者其他类都不能访问

3、protected修饰符修饰成员变量、类变量、构造方法、成员方法(即非静态方法)、静态方法在同包的子类或者其他类都能访问，不同包的子类，类变量和静态方法没问题，可以通过类名直接访问，但成员变量和成员方法new一个父类不能访问，只能通过new一个子类才能访问，构造方法不能在子类的成员方法和静态方法中访问(即子类的成员方法和静态方法不能new一个父类对象)，但可以在子类的构造方法中通过super关键字访问；不同包的非子类均不能访问

4、default(即不写也不能写)修饰符修饰成员变量、类变量、构造方法、成员方法(即非静态方法)、静态方法在同包的子类或者其他类都能访问，不同包的子类和非子类均不能访问

需要注意的是：无论在不同包，还是相同包下，在子类中new一个父类对象，就相当于是在用非子类去访问，protected修饰符指的不同包下的子类和同一包下的子类及非子类的可以访问的意思：其中不同包下的子类和同一包下的子类指的是在不同包下的子类和同一包下的子类下new一个自身对象（即子类对象）可以访问，这一定义明白在相同包下无所谓，但若在不同包下的子类new一个父类不能访问，只能通过new一个子类才能访问。

记住：不同包子类：不同包指创建对象的类与父类在不同包，子类指new出来的对象所代表的类与创建对象的类相同且都是子类

​ 同包子类：同包指创建对象的类与父类在相同包，子类指new出来的对象所代表的类与创建对象的类相同且都是子类

柯柯不会Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala进阶_成员访问修饰符
01-07
和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被访问。 定义 Java中的访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，没有...
Java四种访问修饰符_测试&详解
Phosphophyllite的博客
12-19 849
Android中的访问权限修饰符有public,protected,default,private四种, 之前一直处于似懂非懂的状态,这次就彻底理解下.Step1: Test类中,定义四个静态方法,并在一个test()方法中测试调用.public class Test { public void test() { methodPublic(); method
Java访问修饰符 -- 看一遍就会
weixin_60446551的博客
06-09 432
Java中的访问修饰符--看一遍就会系列
Java中的四种访问修饰符（附代码测试）
qq_250161537
11-10 1595
在写Java代码的时候，总会使用到访问修饰符，那么，四种访问修饰符之间有什么区别？又是什么时候去使用相对应的修饰符呢？今天就了解一下这四个修饰符的不同吧。 Java四个修饰符:public、protected、default、private。按照顺序，修饰符能作用的范围依次减小。用一个表格来表示就是： 为了验证表格的正确与否以及更好地理解，下面我们用代码来测试一下。 首先我们来验证四种修饰符能否...
java修饰符详解
weixin_42689765的博客
09-15 544
基础不牢，地动山摇！！！ 一些相关的名词 关键字，修饰符，标识符 关键字： Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。 关键字汇总和解释详见下表： abstract assert boolean break byte case catch c...
JAVA中的权限修饰符
最新发布
星空的博客
07-03 298
JAVA中权限修饰符有四类：private，默认，protected，public。
DiceRoller:一个简单的命令行 Java 应用程序，用于对任意数量的一种类型的骰子（包括修饰符）执行简单的骰子滚动计算。 可用作大型项目的库
06-22
当前使用 Java 1.8 JDK 构建、运行和测试建造此应用程序是使用 Maven 构建的，并将二进制内容打包在一个具有可执行依赖项的标准 jar 中。跑步只需使用java -jar DiceRoller.jar（骰子数）（骰子类型）在命令行中...
connect-four-tester:面向Java Connect Four项目入门的Connect Four测试器
05-16
（将GraderRunner.java和GamesStatistics.java添加到项目中，并在Connect4Game中更改了某些访问修饰符。） 使用说明 将学生的MyAgent.java文件复制到src/main/java目录。 在命令行上运行./gradlew 。 （Windows...
JAVA面向对象详细资料
03-19
19 访问修饰符 20 20 面向对象的特性-继承 21 20.1 继承的关键字：extends 21 20.2 继承的语法格式： 21 20.3 继承的好处 21 20.4 Object类 21 20.5 继承是以什么方法实现的？ 22 20.6 两个子类的实例，super会指向...
基于Java继承关系改进学生选课模拟系统【100011985】
04-25
掌握权限访问控制修饰符的使用 掌握继承的使用 业务要求 保持实验二报告 测试实体类分别放在不同的 package 中，验证权限访问控制、继承后属性及方法的可见性 实验过程 1、Faculty 类编写： （1）设定课程属性 2、...
spingboot默认日志系统LogBack、Log4j和slf4j使用详解
qq_46601365的博客
04-02 9426
spingboot默认日志系统LogBack、Log4j和slf4j使用详解 spingboot默认日志系统LogBack 依赖引入 Spring Boot默认使用LogBack日志系统，如果不需要更改为其他日志系统如Log4j2等，则无需多余的配置，LogBack默认将日志打印到控制台上。 如果要使用LogBack，原则上是需要添加dependency依赖的 <groupId>org.springframework.boot</groupId> <artifactId>
MybatisPlus的UpdateWrapper和QueryWrapper的区别
qq_46601365的博客
03-21 6732
MybatisPlus的UpdateWrapper和QueryWrapper的区别 查询 测试代码 @Test public void testWrapper(){ LambdaQueryWrapper<Picture> lambdaQueryWrapper = new LambdaQueryWrapper<>(); lambdaQueryWrapper.eq(Picture::getEnterpriseCode, "FASTECH_DEV"); lambda
从prometheus生态系统组件到集成Java开发
qq_46601365的博客
08-15 2425
Prometheus是最初在SoundCloud上构建的开源系统监视和警报工具包。于2016年加入了 Cloud Native Computing Foundation，这是继Kubernetes之后的第二个托管项目。Prometheus 其实就是一个数据监控解决方案，它能帮你简单快速地搭建起一套可视化的监控系统。...
Vmware vSphere最实用的入门级教程
qq_46601365的博客
09-29 2294
vSphere 是在数据中心产品下的一套软件，vSphere 类似微软的 Office 办公套件，Office 办公套件包含了许多软件如 Word, Excel, Access 等，和Office 一样，vSphere 也是一个软件的集合，他包括了 vCenter, ESXi 和vSphere client 等。ESXi 是 vSphere 中最重要的一个组件。ESXi 是虚拟化服务，所有的虚拟机都是运行在 ESXi 服务上面。
neo4j整合springboot实现基础的增删改查
qq_46601365的博客
06-15 1368
neo4j整合springboot实现基础的增删改查 项目搭建 pom.xml 注意：这里使用的springboot2.3.2.RELEASE，jdk1.8，Neo4j Server version：3.5.28 (community)，不同版本可能存在冲突问题，需要注意。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://w
neo4j数据库与mysql对比以及增删改查
qq_46601365的博客
06-23 1107
neo4j 引入neo4j 案例 假设郭富城希望找向华强拍电影，应该怎么找到他。 使用mysql数据库 创建数据库和表 -- 创建数据库 CREATE DATABASE IF NOT EXISTS neo4j DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_0900_ai_ci; -- 创建明星表 CREATE TABLE star ( id INT ( 11 ) NOT NULL AUTO_INCREMENT, homepage VARC
Java将字符串追加换行输出到本地txt文件
qq_46601365的博客
06-09 882
/** * @Author keke * @Description 持久化字符串 * @Date 2021/6/9 * @Param [path, content] * @Return void **/ public static void FileWrite(String path, String content) { FileOutputStream writer = null; OutputStrea
elasticsearch从入门到精通
qq_46601365的博客
09-24 626
es从入门到深入 ElasticSearch概述 Elaticsearch，简称为es ,es是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检索数据;本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。es也使用ava开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。 据国际权威的数据库产品评测机构DB Engines的统计，在2016年1月，ElasticSearch已超过S
lambda表达式最全总结
qq_46601365的博客
04-14 512
lambda表达式 一、lambda表达式的引入 为什么引入lambda表达式 需求环境：线程类的创建 解决方案：匿名内部类实现 解决方案PLUS：lambda表达式实现 代码： package com.imooc.test; /** * @ClassName: Demo01 * @Description: * @Author: keke * @Date: 2021/4/12 */ public class Demo01 { public static void mai
用JAVA（1）定义一个圆类Circle，该圆类的数据成员包括：圆心点位置及圆的半径；方法成员有：设置圆心位置和半径的方法，获取圆心位置和半径的方法，无参的构造方法初始化圆心位置为(0,0)，半径为1。另外定义一个构造方法可以接收圆心位置与半径的参数。编写测试类创建Circle类的对象，并且分别调用各种方法，对比这些方法的执行结果。（2）定义一个矩形类MyRectangle，类中有4个私有的整型变量，分别是矩形的左上角坐标(xUp,yUp)和右下角坐标(xDown,yDown)；类中定义没有参数的构造方法和有4个int参数的构造方法，用来初始化类对象。类中还有以下方法：getw()—一计算矩形的宽度;getH()——计算矩形的高度；area()—计算矩形的面积；toString()—把矩形的宽、高和面积等信息作为为宇符串返回。编写代码创建MyRectangle类的对象并输出矩形对象的信息。（3）设计一个长方体类MyCube，该类包含第2题中的MyRectangle类对象作为类的成员变量，表示长方体的底面；此外还包含一个整型变量d，表示长方体的高。类中定义构造方法初始化类对象、定义求体积和表面积的方法。编写代码测试MyCube类。（4）对于第2、3题的类分别用类的访问修饰符public与无修饰符定义，同时把它们声明在同一个包中、不同的包中，分析程序的编译情况，理解类及其成员的访问控制符的作用。
06-08
- 如果公共成员的访问修饰符为无修饰符（即 default ），那么它们只能在同一个包中被访问，不能在不同的包中访问。 针对以上情况，可以通过以下代码进行测试： 在同一个包中： ```java package com.example; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值