Java学习教程，从入门到精通，Java修饰符语法知识点及案例代码（23）

news2024/11/13 3:34:47

1.Java修饰符语法知识点及案例代码

Java修饰符用于改变类、方法、变量、接口等元素的行为和可见性。主要分为两大类：访问修饰符和非访问修饰符。

访问修饰符（Access Modifiers）

  1. public

    • 提供最大的访问权限，任何类都可以访问。
    • 使用对象：类、方法、变量、接口、构造方法。

  2. protected

    • 对同一包内的类和所有子类可见。
    • 使用对象：变量、方法、构造方法（不能修饰类）。

  3. default（无修饰符）

    • 在同一包内可见。
    • 使用对象：类、接口、变量、方法、构造方法。

  4. private

    • 在同一类内可见。
    • 使用对象：变量、方法、构造方法（不能修饰类）。
非访问修饰符（Non-Access Modifiers）

  1. static

    • 修饰类变量和方法，表示属于类本身，而不是某个实例。
    • 类变量：在方法区存储，所有对象共享。
    • 静态方法：不能访问非静态成员。

  2. final

    • 修饰类、方法和变量，表示不可更改。
    • 类：不能被继承。
    • 方法：不能被重写。
    • 变量：常量，不可修改。

  3. abstract

    • 修饰类和方法，表示抽象，没有具体实现。
    • 抽象类：不能被实例化。
    • 抽象方法：必须由子类实现。

  4. synchronized

    • 修饰方法或代码块，用于处理多线程并发访问资源时的同步控制。

  5. volatile

    • 修饰变量，确保线程间的可见性和防止指令重排序。

  6. transient

    • 修饰变量，表示该变量不会被序列化机制处理。

  7. native

    • 修饰方法，表示该方法由非Java代码实现，通过JNI调用。

  8. strictfp

    • 修饰类或方法，表示浮点数运算遵循严格的IEEE 754标准。
案例代码
// 访问修饰符示例
public class AccessModifiersDemo {
    // 默认访问修饰符（包访问权限）
    int defaultVar = 10;

    // 私有访问修饰符
    private int privateVar = 20;

    // 受保护访问修饰符
    protected int protectedVar = 30;

    // 公共访问修饰符
    public int publicVar = 40;

    // 公共方法
    public void printVars() {
        System.out.println("Default Var: " + defaultVar);
        System.out.println("Private Var: " + privateVar);
        System.out.println("Protected Var: " + protectedVar);
        System.out.println("Public Var: " + publicVar);
    }

    // 私有方法（外部类不能直接访问）
    private void privateMethod() {
        System.out.println("This is a private method.");
    }

    // 公共静态方法
    public static void staticMethod() {
        System.out.println("This is a static method.");
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象
        AccessModifiersDemo demo = new AccessModifiersDemo();
        
        // 访问公共和默认变量
        System.out.println("Accessing publicVar: " + demo.publicVar);
        // System.out.println("Accessing defaultVar: " + demo.defaultVar); // 错误：不能在外部类中直接访问默认访问修饰符的变量

        // 调用公共方法
        demo.printVars();

        // 调用静态方法
        staticMethod();

        // 由于privateMethod是私有的，因此不能直接调用
        // demo.privateMethod(); // 错误：privateMethod() 不能被访问
    }
}

// 非访问修饰符示例
abstract class Shape {
    // 抽象方法
    abstract void draw();
}

class Circle extends Shape {
    // 实现抽象方法
    @Override
    void draw() {
        System.out.println("Drawing a Circle.");
    }
}

class Rectangle extends Shape {
    // 实现抽象方法
    @Override
    void draw() {
        System.out.println("Drawing a Rectangle.");
    }
}

class FinalDemo {
    // final变量
    final int CONSTANT = 100;

    // final方法
    final void finalMethod() {
        System.out.println("This is a final method.");
    }
}

class StaticDemo {
    // 静态变量
    static int staticVar = 5;

    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method. Static Var: " + staticVar);
    }
}

public class NonAccessModifiersDemo {
    public static void main(String[] args) {
        // 创建Circle和Rectangle对象
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        // 调用draw方法
        circle.draw();
        rectangle.draw();

        // FinalDemo示例
        FinalDemo finalDemo = new FinalDemo();
        System.out.println("Final Constant: " + finalDemo.CONSTANT);
        finalDemo.finalMethod();

        // StaticDemo示例
        System.out.println("Accessing static variable: " + StaticDemo.staticVar);
        StaticDemo.staticMethod();
    }
}

在以上代码中，AccessModifiersDemo 类展示了不同访问修饰符的用法，NonAccessModifiersDemo 类展示了非访问修饰符的用法。

以下是一些具体的Java修饰符使用案例，包括访问修饰符和非访问修饰符的示例。

访问修饰符案例

1. 公共类与公共方法
// 公共类
public class PublicClassDemo {
    // 公共变量
    public int publicVar = 10;

    // 公共方法
    public void publicMethod() {
        System.out.println("This is a public method. Public Var: " + publicVar);
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象并访问公共成员
        PublicClassDemo demo = new PublicClassDemo();
        demo.publicMethod();
        System.out.println("Accessing publicVar: " + demo.publicVar);
    }
}
2. 私有成员与公共方法访问
// 公共类
public class PrivateMemberDemo {
    // 私有变量
    private int privateVar = 20;

    // 公共方法访问私有变量
    public void accessPrivateVar() {
        System.out.println("Private Var: " + privateVar);
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象并调用公共方法访问私有变量
        PrivateMemberDemo demo = new PrivateMemberDemo();
        demo.accessPrivateVar();
        // demo.privateVar; // 错误：无法从外部访问私有变量
    }
}
3. 受保护成员与继承
// 基类
public class ProtectedMemberBase {
    // 受保护变量
    protected int protectedVar = 30;

    // 受保护方法
    protected void protectedMethod() {
        System.out.println("Protected Var: " + protectedVar);
    }
}

// 子类
public class ProtectedMemberDerived extends ProtectedMemberBase {
    // 主方法
    public static void main(String[] args) {
        // 创建子类对象并访问受保护成员
        ProtectedMemberDerived derived = new ProtectedMemberDerived();
        derived.protectedMethod();
        System.out.println("Accessing protectedVar: " + derived.protectedVar);
    }
}

非访问修饰符案例

1. 静态成员与静态方法
// 公共类
public class StaticMemberDemo {
    // 静态变量
    static int staticVar = 40;

    // 静态方法
    static void staticMethod() {
        System.out.println("Static Var: " + staticVar);
    }

    // 主方法
    public static void main(String[] args) {
        // 直接访问静态成员，无需创建对象
       System.out.println("Accessing static variable: " + StaticMemberDemo.staticVar);
       StaticMemberDemo.staticMethod();

        // 也可以通过对象访问静态成员（不推荐）
    StaticMemberDemo demo = new StaticMemberDemo();
    System.out.println("Accessing static variable through object: " + demo.staticVar);
    demo.staticMethod();
    }
}
2. 最终变量与方法
// 公共类
public class FinalMemberDemo {
    // 最终变量（常量）
    final int FINAL_CONSTANT = 50;

    // 最终方法（不能被重写）
    public final void finalMethod() {
     System.out.println("This is a final method. Final Constant: " + FINAL_CONSTANT);
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象并访问最终成员
        FinalMemberDemo demo = new FinalMemberDemo();
        demo.finalMethod();
        // demo.FINAL_CONSTANT = 100; // 错误：不能修改最终变量
    }
}
3. 抽象类与抽象方法
// 抽象基类
public abstract class AbstractClassDemo {
    // 抽象方法（无实现）
    public abstract void abstractMethod();

    // 具体方法（有实现）
    public void concreteMethod() {
        System.out.println("This is a concrete method.");
    }
}

// 具体子类
public class AbstractClassDerived extends AbstractClassDemo {
    // 实现抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("Implementing abstract method.");
    }

    // 主方法
    public static void main(String[] args) {
        // 创建子类对象并调用方法
        AbstractClassDerived derived = new AbstractClassDerived();
        derived.abstractMethod();
        derived.concreteMethod();
    }
}

这些案例涵盖了Java中常见的修饰符使用场景，包括访问修饰符（public、private、protected、默认）和非访问修饰符（static、final、abstract）的示例。通过运行这些代码，你可以更好地理解修饰符在Java中的作用和用法。
在Java中，私有成员（使用private修饰符）和非访问修饰符（如static、final、abstract等）是两种不同的概念，但它们可以组合使用。以下是一些示例，展示了私有成员与非访问修饰符的结合使用。

私有成员与static修饰符

public class PrivateStaticExample {
    // 私有静态变量
    private static int privateStaticVar = 100;

    // 私有静态方法
    private static void privateStaticMethod() {
        System.out.println("Private static method called. Private static variable: " + privateStaticVar);
    }

    // 公共静态方法，用于访问私有静态成员
    public static void accessPrivateStatic() {
        privateStaticMethod();
        System.out.println("Accessing private static variable: " + privateStaticVar);
    }

    // 主方法
    public static void main(String[] args) {
        // 通过公共静态方法访问私有静态成员
        PrivateStaticExample.accessPrivateStatic();

        // 不能直接从类外部访问私有静态成员
        // System.out.println(PrivateStaticExample.privateStaticVar); // 错误：无法从外部访问私有静态变量
        // PrivateStaticExample.privateStaticMethod(); // 错误：无法从外部访问私有静态方法
    }
}

私有成员与final修饰符

public class PrivateFinalExample {
    // 私有最终变量（常量）
    private final int PRIVATE_FINAL_CONSTANT = 200;

    // 构造函数
    public PrivateFinalExample() {
        // 注意：不能在构造函数中重新赋值给final变量（除非是在初始化块中，但这里已经初始化了）
        // this.PRIVATE_FINAL_CONSTANT = 300; // 错误：不能重新赋值给final变量
    }

    // 公共方法，用于展示私有最终变量的值
    public void showPrivateFinalConstant() {
        System.out.println("Private final constant: " + PRIVATE_FINAL_CONSTANT);
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象并调用方法
        PrivateFinalExample example = new PrivateFinalExample();
        example.showPrivateFinalConstant();

        // 不能从类外部直接访问私有最终变量
        // System.out.println(example.PRIVATE_FINAL_CONSTANT); // 错误：无法从外部访问私有最终变量
    }
}

注意：abstract修饰符不能用于成员变量

abstract修饰符只能用于类和方法，不能用于成员变量。因此，你不能有一个“私有抽象成员变量”。但是，你可以有一个抽象类，其中包含私有成员变量和抽象方法。

抽象类中的私有成员

public abstract class AbstractClassWithPrivateMembers {
    // 私有成员变量
    private int privateMemberVar = 300;

    // 抽象方法（无实现）
    public abstract void abstractMethod();

    // 具体方法，可以访问私有成员变量
    public void showPrivateMemberVar() {
        System.out.println("Private member variable: " + privateMemberVar);
    }
}

// 具体子类
public class ConcreteClassDerivedFromAbstract extends AbstractClassWithPrivateMembers {
    // 实现抽象方法
    @Override
    public void abstractMethod() {
        System.out.println("Abstract method implemented.");
    }

    // 主方法
    public static void main(String[] args) {
        // 创建子类对象
        ConcreteClassDerivedFromAbstract concrete = new ConcreteClassDerivedFromAbstract();
        
        // 调用具体方法访问私有成员变量（通过继承关系）
        concrete.showPrivateMemberVar();
        
        // 调用实现的抽象方法
        concrete.abstractMethod();
        
        // 不能从子类外部直接访问父类的私有成员变量
        // System.out.println(concrete.privateMemberVar); // 错误：无法从外部访问私有成员变量（即使是通过子类对象）
    }
}

这些示例展示了如何在Java中结合使用私有成员和非访问修饰符。私有成员保证了封装性，而非访问修饰符则提供了额外的功能或限制。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2236421.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

爬虫策略规避：Python爬虫的浏览器自动化

爬虫策略规避：Python爬虫的浏览器自动化

网络爬虫作为一种自动化获取网页数据的技术，被广泛应用于数据挖掘、市场分析、竞争情报等领域。然而，随着反爬虫技术的不断进步，简单的爬虫程序往往难以突破网站的反爬虫策略。因此，采用更高级的爬虫策略，如浏览器自动…
阅读更多...
信号-3-信号处理、可重入函数与`volatile`关键字总结

信号-3-信号处理、可重入函数与`volatile`关键字总结

信号处理是操作系统中的一个重要机制，它允许进程在运行期间响应外部事件，并作出相应的处理。为了处理信号，程序员需要理解如何设置信号处理器，如何管理信号的屏蔽与阻塞，以及信号的递送机制。本文将结合操作系统中的信…
阅读更多...
深度学习-图像评分实验（TensorFlow框架运用、读取处理图片、模型建构）

深度学习-图像评分实验（TensorFlow框架运用、读取处理图片、模型建构）

目录 0、实验准备 ①实验环境 ②需要下载的安装包 ③注意事项（很关键，否则后面内容看不懂） ④容易出现的问题 1、查看数据并读取数据。 2、PIL库里的Image包进行读取（.resize更改图片尺寸，并将原始数据归一化处…
阅读更多...
【Linux系统】—— 基本指令（二）

【Linux系统】—— 基本指令（二）

【Linux系统】—— 基本指令（二） 1 「alias」命令1.1 「ll」命令1.2 「alias」命令 2 「rmdir」指令与「rm」指令2.1 「rmdir」2.2 「rm」2.2.1 「rm」 删除普通文件2.2.2 「rm」 删除目录2.2.3 『 * 』 通配符 3 「man」 指令4 「cp」 指令4.1 拷贝普通…
阅读更多...
面向对象技术简述(含设计模式)

面向对象技术简述(含设计模式)

6.9.2 面向对象技术 面向对象 对象 分类 继承 通过消息的通信 面向对象 对象 分类 继承 通过消息的通信 面向对象对象分类继承通过消息的通信其中包括： 对象 运行的实体；既包含属性/数据，又包含方法/行为/操作数据的函数；…
阅读更多...
【信号处理】基于联合图像表示的深度学习卷积神经网络

【信号处理】基于联合图像表示的深度学习卷积神经网络

Combined Signal Representations for Modulation Classification Using Deep Learning: Ambiguity Function, Constellation Diagram, and Eye Diagram 信号表示 Ambiguity Function（AF） 模糊函数描述了信号的两个维度（dimensions）：延迟（delay）和多普勒（Doppler）。 …
阅读更多...
【C++练习】两个实型数的加法运算

【C++练习】两个实型数的加法运算

题目： 编写一个C程序，实现两个实型数的加法运算并输出结果。 要求： 定义一个函数 dadd，该函数接收两个 double 类型的参数，并返回它们的和。在 main 函数中，提示用户输入两个实型数（double 类…
阅读更多...
【开源免费】基于SpringBoot+Vue.JS周边产品销售网站（JAVA毕业设计）

【开源免费】基于SpringBoot+Vue.JS周边产品销售网站（JAVA毕业设计）

博主说明：本文项目编号 T 061 ，文末自助获取源码 \color{red}{T061，文末自助获取源码} T061，文末自助获取源码 目录 一、系统介绍二、演示录屏三、启动教程四、功能截图五、文案资料5.1 选题背景5.2 国内外研究现状5.3 可行性分析…
阅读更多...
Sql面试题二：请查询出用户连续三天登录的所有数据记录

Sql面试题二：请查询出用户连续三天登录的所有数据记录

问题： 现有用户登录记录表，请查询出用户连续三天登录的所有数据记录 id dt 1 2024-04-25 1 2024-04-26 1 2024-04-27 1 2024-04-28 1 2024-04-30 1 2024-05-01 1 2024-05-02 1 2024-05-04 1 2024-05-05 2 2…
阅读更多...
科研绘图系列：R语言分组堆积图（grouped stacked barplot）

科研绘图系列：R语言分组堆积图（grouped stacked barplot）

禁止商业或二改转载，仅供自学使用，侵权必究，如需截取部分内容请后台联系作者! 文章目录 介绍加载R包准备画图主题数据链接导入数据画图数据准备图例图1图2合并图系统信息介绍 分组堆积图（Grouped Stacked Bar Chart）是一种数据可视化图表，它结合了分组柱状图和堆积柱状图…
阅读更多...
世界技能竞赛大数据应用开发环境1:1还原

世界技能竞赛大数据应用开发环境1:1还原

集群情况 模块A搭建环境，在容器中搭建大数据平台 Pc机，安装安装比赛需要软件 模块B中使用idea快速开发完成数据处理 模块E包含了接口数据，使用vs code快速搭建vue数据可视化
阅读更多...
【网络协议大花园】应用层 http协议的使用小技巧，用好了都不用加班，效率翻两倍（下篇）

【网络协议大花园】应用层 http协议的使用小技巧，用好了都不用加班，效率翻两倍（下篇）

本篇会加入个人的所谓鱼式疯言 ❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言 而是理解过并总结出来通俗易懂的大白话, 小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的. 🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人…
阅读更多...
SpringBoot源码解析（一）

SpringBoot源码解析（一）

SpringBoot自动装配原理 SpringBootApplication注解 我们在使用SpringBoot时，通常使用的是SpringBootApplication这个注解，比如： 而这个注解的定义为下图，可以发现这个注解上有另外三个注解：SpringBootConfiguration…
阅读更多...
流类库与输入输出

流类库与输入输出

来源：《C语言程序设计》 像C语言一样，C语言也没有输入输出语句。 但C标准库中有一个面向对象的输入输出软件包，即I/O流类库。 流是I/O流类的中心概念。 ------ I/O流类库是C语言中I/O函数在面向对象的程序设计方法中的一个替换产品。 -…
阅读更多...
k8s图形化显示（KRM）

k8s图形化显示（KRM）

在master节点 kubectl get po -n kube-system 这个命令会列出 kube-system 命名空间中的所有 Pod 的状态和相关信息，比如名称、状态、重启次数等。 systemctl status kubelet #查看kubelet状态 yum install git #下载git命令 git clone https://gitee.com/duk…
阅读更多...
理解鸿蒙app 开发中的 context

理解鸿蒙app 开发中的 context

是什么 Context是应用中对象的上下文，其提供了应用的一些基础信息，例如resourceManager（资源管理）、applicationInfo（当前应用信息）、dir（应用文件路径）、area（文件分区…
阅读更多...
ML1：sklearn env

ML1：sklearn env

sklearn： 中文参考： https://scikit-learn.cn/stable/modules/linear_model.html#ordinary-least-squares https://scikit-learn.org.cn/view/4.html ——》为主，不懂地方参考上面中文以及下面英文 英文参考： https://scikit…
阅读更多...
五分钟入门双拼！

五分钟入门双拼！

‍这是从零开始学双拼的第一篇：概述 双拼的原理 如果你使用全拼，想要完整敲出一个字的读音，需要敲出这个字拼音的每个字母。 虽然简拼能简化一点步骤，但除非是很常见的成语、俗语，否则重码率很高，选词很…
阅读更多...
基于STM32的智能充电桩：集成RTOS、MQTT与SQLite的先进管理系统设计思路

基于STM32的智能充电桩：集成RTOS、MQTT与SQLite的先进管理系统设计思路

一、项目概述 随着电动车的普及，充电桩作为关键基础设施，其智能化、网络化管理显得尤为重要。本项目旨在基于STM32微控制器开发一款智能充电桩，能够实现高效的充电监控与管理。项目通过物联网技术，提供实时数据监测、远程管理、用…
阅读更多...
毕业后如何查找获取文献

毕业后如何查找获取文献

当我们毕业后就无法再使用自己学校的数据库资源了，如果需要查找文献该从哪里获取资源呢？下面这个方法很简单而且有效： 一、首先选对科研工具 文献党下载器，把大量数据库资源整合在一起，直接去文献来源数据库查找获取…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023