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

🕗 发布于 2024-11-09 03:58 java 学习 python 1024程序员节 大数据

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

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

访问修饰符（Access Modifiers）

public
- 提供最大的访问权限，任何类都可以访问。
- 使用对象：类、方法、变量、接口、构造方法。
protected
- 对同一包内的类和所有子类可见。
- 使用对象：变量、方法、构造方法（不能修饰类）。
default（无修饰符）
- 在同一包内可见。
- 使用对象：类、接口、变量、方法、构造方法。
private
- 在同一类内可见。
- 使用对象：变量、方法、构造方法（不能修饰类）。

非访问修饰符（Non-Access Modifiers）

static
- 修饰类变量和方法，表示属于类本身，而不是某个实例。
- 类变量：在方法区存储，所有对象共享。
- 静态方法：不能访问非静态成员。
final
- 修饰类、方法和变量，表示不可更改。
- 类：不能被继承。
- 方法：不能被重写。
- 变量：常量，不可修改。
abstract
- 修饰类和方法，表示抽象，没有具体实现。
- 抽象类：不能被实例化。
- 抽象方法：必须由子类实现。
synchronized
- 修饰方法或代码块，用于处理多线程并发访问资源时的同步控制。
volatile
- 修饰变量，确保线程间的可见性和防止指令重排序。
transient
- 修饰变量，表示该变量不会被序列化机制处理。
native
- 修饰方法，表示该方法由非Java代码实现，通过JNI调用。
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中结合使用私有成员和非访问修饰符。私有成员保证了封装性，而非访问修饰符则提供了额外的功能或限制。

原文地址：https://blog.csdn.net/qq_45746668/article/details/143636364

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：楼梯区域分割系统：Web效果惊艳
下一篇：Ubuntu 安装 redis

vue 版本升级
这个警告是说eslint-plugin-vue package支持 node 12.22或者 14.17 或者 16.0.0以上版本，但是当前你的版本是 12.19.0，版本太低了需要更新 node版
阅读更多2024-11-09
理解虚拟 DOM：Vue 的灵魂之处
虚拟 DOM（Virtual DOM）是一个轻量级的 JavaScript 对象，它是实际 DOM 的一个抽象表示。在 Vue 中，当我们对数据进行修改时，框架不会立即更新真实的 DOM，而是首先对虚
阅读更多2024-11-09
vue3 动态路由+动态组件+缓存应用
vue3 动态路由+动态组件+缓存应用
阅读更多2024-11-09
机器学习—训练细节
然后张量流会试图最小化均方误差，在这个表达式中，用大写的J(W,B)来表示成本函数，成本函数是神经网络中所有参数的函数，所以你可以把W，B看作包括整个神经网络中的所有的W，B参数，所以如果你优化关于w
阅读更多2024-11-09
解释Python中的装饰器的作用
装饰器接收两个参数：一个是要装饰的函数，另一个是可选的额外参数列表。装饰器可以返回一个新的函数，这个新函数是原始函数的增强版，或者保持和原始函数相同的行为。装饰器在Python中是一种特殊类型的函数，
阅读更多2024-11-09
我自己nodejs练手时常用的一些库基础用法
我自己使用node练手时常用的一些库的基本使用记录：有bcrypt,express,pg,config,jwt和pm2
阅读更多2024-11-09
EasyPlayer.js无插件H5播放器支持哪些浏览器？
为了确保用户无论在何种设备或浏览器上都能享受到最佳的观看体验，EasyPlayer.js流媒体播放器应运而生，它以其卓越的跨浏览器兼容性和功能丰富性，成为了视频播放解决方案的佼佼者。这种广泛的兼容性使
阅读更多2024-11-09
Java-I/O框架13：文件夹的递归遍历和递归删除
16.29 递归遍历和递归删除_哔哩哔哩_bilibili。1.文件夹的递归遍历。2.文件夹的递归删除。
阅读更多2024-11-09
github和Visual Studio
使用很简单，自己稍微琢磨下就明白了。
阅读更多2024-11-09
Python毕业设计选题：基于django+vue的网上购物系统的设计与实现
网上购物系统是在实际应用和软件工程的开发原理之上，运用Python语言以及Django框架进行开发。首先要进行需求分析，分析出网上购物系统的主要功能，然后设计了系统结构。整体设计包括系统的功能、系统总
阅读更多2024-11-09