009Java基础之静态成员、代码块及final关键字

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

1、类变量

类变量也叫做静态变量或者静态属性，是该类所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样，任何一个该类的对象去修改它时，修改的也是同一个变量。
静态变量在JDK8之前，存放在方法区的静态域，JDK8以后，存放在堆的Class对象中（官方没有明确的说法）
定义语法
访问修饰符 static 数据类型 变量名 ;或者
static 访问修饰符 数据类型 变量名 ;
推荐第一种方式。
注意事项和细节
（1）什么时候使用静态变量？
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用静态变量
（2）类变量与实例变量的区别：
类变量是该类所用对象共享的，而实例变量是每个对象独享的
（3）加上static的变量称为类变量或静态变量，否则称为实例变量、普通变量或非静态变量等
（4）类变量可以通过类名.属性名或者变量名.属性名访问，推荐使用类名.属性名来访问
在这里插入图片描述

（5）实例变量不能通过类名.属性名方式访问
（6）类变量是在类加载的时候就初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用类变量了，所以构造器参数中不能有静态变量。
（7）类变量的生命周期是随类的加载开始，随着类的消亡而销毁

2、类方法

类方法的定义规则和使用与类属性一致，不再重复。类方法有一个重要的应用即是在工具类中的使用。
注意事项和细节
（1）类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：
类方法中无this的参数，普通方法中隐含着this的参数。
在这里插入图片描述
（2）与类属性一样，类方法可以通过类名调用，也可以通过对象名调用，但推荐使用类名调用。
在这里插入图片描述

（3）普通方法与对象有关，需要通过对象名调用，不能通过类名调用
（4）类方法中不允许使用和对象有关的关键字，比如this、super，普通方法可以
在这里插入图片描述

（5）类方法中，如果访问的是本类中的成员，只能访问静态变量或静态方法，如果非要访问非静态的成员，自己new自己，通过对象去访问。
在这里插入图片描述

（6）普通成员方法，既可以访问非静态成员，也可以访问静态成员
在这里插入图片描述

/**
 * @author Francis
 * @create 2021-07-01 10:39
 */
public class StaticMethod {

    public static void main(String[] args) {
//创建 2 个学生对象，叫学费
        Stu tom = new Stu("tom");
        tom.payFee(100);
//            tom.fee=100;
        Stu.payFee(100);//对不对?对
        Stu mary = new Stu("mary");
//mary.payFee(200);
        Stu.payFee(200);//对
//输出当前收到的总学费
        Stu.showFee();//300
//如果我们希望不创建实例，也可以调用某个方法(即当做工具来使用)
//这时，把方法做成静态方法时非常合适
        System.out.println("9 开平方的结果是=" + Math.sqrt(9));
        System.out.println(MyTools.calSum(10, 30));
    }
}

class MyTools {
    //求出两个数的和
    public static double calSum(double n1, double n2) {

        return n1 + n2;
    }
//可以写出很多这样的工具方法...
}

class Stu {
    private String name;//普通成员
    //定义一个静态变量，来累积学生的学费
    public static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }

    //说明
//1. 当方法使用了 static 修饰后，该方法就是静态方法
//2. 静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//累积到
//        this.fee+=fee;
    }

    public static void showFee() {
//        test();
        System.out.println("总学费有:" + Stu.fee);
    }

    public void test() {
        System.out.println(Stu.fee);
    }
    public void test2(){
        showFee();
        test();
    }
}

3、main方法

1、理解main方法

**public static void main(String[] args) {} **
（1）main方法是由虚拟机调用
（2）java虚拟机需要调用类的main方法，所以main方法必须是public的
（3）java虚拟机在执行main方法时不必创建对象，所以该方法必须是static的
（4）main方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数
在这里插入图片描述
（5）既然main方法是public的，static的，其遵循这两个属性的基本规则
在idea中给main方法传参
（1）编译源文件，（默认是没有MainTest01的）在这里插入图片描述
（2）编辑
在这里插入图片描述
在这里插入图片描述

（3）在此运行，参数顺利传给了main方法
在这里插入图片描述

4、代码块

1、基本介绍

代码块又称初始代码块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包裹起来，但和方法不同，没有方法名，没有返回值，没有参数，只有方法体， 而且不用通过对象或类显式调用，而是类加载时，或创建对象时隐式调用

2、基本语法
[修饰符] {
代码
};

说明
（1）修饰符，可选，如果要写的话，也只能是static
（2）代码块分为两类，使用static修饰的叫做静态代码块，没有static修饰的，叫做普通代码块
（3）逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
（4）;号可以写上，也可以省略
理解
（1）普通代码块相当于另一种形式的构造器（对构造器的补充机制），可以做初始化操作
（2）使用场景：如果多个构造器中都有重复语句，可以抽取到初始化块中，提高代码的重用性
例如：
在这里插入图片描述
在这里插入图片描述

/**
 * @author Francis
 * @create 2021-07-01 17:15
 */
public class CodeBlock01 {
        public static void main(String[] args) {
            Movie movie = new Movie("你好，李焕英");
            System.out.println("===============");
            Movie movie2 = new Movie("唐探 3", 100, "陈思诚");
        }
    }
    class Movie {
        private String name;
        private double price;
        private String director;
//3 个构造器-》重载
//老韩解读
//(1) 下面的三个构造器都有相同的语句
//(2) 这样代码看起来比较冗余
//(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
//(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
//(5) 代码块调用的顺序优先于构造器..
 {
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");
    }
    public Movie(String name) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }
    public Movie(String name, double price) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");

        this.name = name;
        this.price = price;
    }
    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}
3、注意事项和细节

（1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次，如果是普通代码块，每创建一个对象，就会执行一次
在这里插入图片描述
（2）类被加载的三种情况
①创建对象实例时（new）
在这里插入图片描述
②创建子类对象实例，父类也会被加载
在这里插入图片描述

③使用类的静态属性（成员变量和方法）（当然，也包括子类的静态方法）
在这里插入图片描述

/**
 * @author Francis
 * @create 2021-07-01 19:48
 */
public class CodeBlockDetail {

        public static void main(String[] args) {
//类被加载的情况举例
//1. 创建对象实例时(new)
// AA aa = new AA();
//2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
// AA aa2 = new AA();
//3. 使用类的静态成员时(静态属性，静态方法)
// System.out.println(Cat.n1);
//static 代码块，是在类加载时，执行的，而且只会执行一次. // DD dd = new DD();
// DD dd1 = new DD();
// DD dd2 = new DD();
//普通的代码块，在创建对象实例时，会被隐式的调用。
// 被创建一次，就会调用一次。
// 如果只是使用类的静态成员时，普通代码块并不会执行
            System.out.println(DD.n1);//8888, 静态模块块一定会执行
        }
    }
    class DD {
        public static int n1 = 8888;//静态属性
        //静态代码块
        static {
            System.out.println("DD 的静态代码 1 被执行...");//
        }
        //普通代码块, 在 new 对象时，被调用，而且是每创建一个对象，就调用一次

//可以这样简单的，理解 普通代码块是构造器的补充
        {
            System.out.println("DD 的普通代码块...");
        }
    }
    class Animal {
        //静态代码块
        static {
            System.out.println("Animal 的静态代码 1 被执行...");//
        }
    }
    class Cat extends Animal {
        public static int n1 = 999;//静态属性
        //静态代码块
        static {
            System.out.println("Cat 的静态代码 1 被执行...");//
        }
    }
    class BB {
        //静态代码块
        static {
            System.out.println("BB 的静态代码 1 被执行...");//1
        }
    }
    class AA extends BB{
        //静态代码块

         {
            System.out.println("AA 的静态代码 1 被执行...");//2
        }
    }

（3）普通打代码块，在创建对象时，会被隐式的调用，被创建一次，就会被调用一次，如果只是使用类的静态成员时，普通代码块并不会执行（这里可以理解为普通代码块是构造器的补充，类都没有实例化，所以构造器不会执行）
在这里插入图片描述
（4）创建一个对象时，在一个类中，成员的执行顺序是）：
①调用静态代码块、静态属性初始化（注意静态代码块与静态属性初始化优先级一样，如果有多个静态代码块和多个静态属性，则按其定义的顺序调用）
在这里插入图片描述
②调用普通代码块、普通属性初始化（注意普通代码块与普通属性初始化优先级一样，如果有多个普通代码块和多个普通态属性，则按其定义的顺序调用）
在这里插入图片描述
③调用构造器
在这里插入图片描述

/**
 * @author Francis
 * @create 2021-07-01 20:16
 */
public class CodeBlockDetail01 {

        public static void main(String[] args) {
            A a = new A();// (1) A 静态代码块 01 (2) getN1 被调用...(3)A 普通代码块 01(4)getN2 被调用...(5)A() 构造器被调

        }
    }
    class A {

        //无参构造器
        public A() {
            System.out.println("A() 构造器被调用");
        }
        { //普通代码块

            System.out.println("A 普通代码块 01");
        }
        static { //静态代码块
            System.out.println("A 静态代码块 01");
        }
        private int n2 = getN2();//普通属性的初始化
        //静态属性的初始化
        private static int n1 = getN1();
        public static int getN1() {
            System.out.println("getN1 被调用...");
            return 100;
        }
        public int getN2() { //普通方法/非静态方法
            System.out.println("getN2 被调用...");
            return 200;
        }
    }

（5）构造器的最前面其实隐藏了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时，就执行完毕因此是优于构造器和普通代码块执行的。
在这里插入图片描述

/**
 * @author Francis
 * @create 2021-07-01 20:38
 */
public class CodeBlockDetail02 {

        public static void main(String[] args) {
            new BBB();//(1)AAA 的普通代码块(2)AAA() 构造器被调用(3)BBB 的普通代码块(4)BBB() 构造器被调用
        }
    }
    class AAA { //父类 Object
        {
            System.out.println("AAA 的普通代码块");
        }
        public AAA() {
        //(1)super()
        //(2)调用本类的普通代码块
            System.out.println("AAA() 构造器被调用....");
        }
    }
    class BBB extends AAA {
        {
            System.out.println("BBB 的普通代码块...");
        }
        public BBB() {
    //(1)super()
    //(2)调用本类的普通代码块
            System.out.println("BBB() 构造器被调用....");
        }
    }

（6）当子类父类都存在静态属性、静态代码块、普通属性、普通代码块、构造器时，每个成分执行的先后顺序：
①父类的静态代码块和静态属性（优先级一样，按定义的顺序执行）
②子类的静态代码块和静态属性（优先级一样，按定义的顺序执行）
③父类的普通代码块和普通属性（优先级一样，按定义的顺序执行）
④父类的构造方法
⑤子类的普通代码块和普通属性（优先级一样，按定义的顺序执）
⑥子类的构造方法
（7）静态代码块只能直接调用本类的静态成员（属性和方法），普通代码块可以调用任意成员
在这里插入图片描述
对应代码如下：

/**
 * @author Francis
 * @create 2021-07-01 21:15
 */
public class CodeBlockDetail03 {

        public static void main(String[] args) {
//老师说明
//(1) 进行类的加载
//1.1 先加载 父类 A02 1.2 再加载 B02
//(2) 创建对象
//2.1 从子类的构造器开始
//new B02();//对象
            new C02();
        }
    }
    class A02 { //父类
        private static int n1 = getVal01();
        static {
            System.out.println("A02 的一个静态代码块..");//(2)
        }
        {
            System.out.println("A02 的第一个普通代码块..");//(5)
        }
        public int n3 = getVal02();//普通属性的初始化
        public static int getVal01() {
            System.out.println("getVal01");//(1)
            return 10;
        }

        public int getVal02() {
            System.out.println("getVal02");//(6)
            return 10;
        }
        public A02() {//构造器
//隐藏
//super()
//普通代码和普通属性的初始化...... System.out.println("A02 的构造器");//(7)
        }
    }
    class C02 {
        private int n1 = 100;
        private static int n2 = 200;
        private void m1() {
        }
        private static void m2() {
            System.out.println("m2");
        }

        static {
//静态代码块，只能调用静态成员
//System.out.println(n1);错误
            System.out.println(n2);//ok
//m1();//错误
            m2();
        }
        {
//普通代码块，可以使用任意成员
            System.out.println(n1);
            System.out.println(n2);//ok
            m1();
            m2();
        }
    }
    class B02 extends A02 { //
        private static int n3 = getVal03();
        static {
            System.out.println("B02 的一个静态代码块..");//(4)
        }
        public int n5 = getVal04();
        {
            System.out.println("B02 的第一个普通代码块..");//(9)

        }
        public static int getVal03() {
            System.out.println("getVal03");//(3)
            return 10;
        }
        public int getVal04() {
            System.out.println("getVal04");//(8)
            return 10;
        }
//一定要慢慢的去品.. public B02() {//构造器
//隐藏了
//super()
//普通代码块和普通属性的初始化... System.out.println("B02 的构造器");//(10)
// TODO Auto-generated constructor stub
    }

总结
（1）static代码块是类加载时执行，而且只会执行一次
（2）普通代码块是在创建对象时执行，创建一个对象，就会执行一次

5、final关键字

final可以修饰类、属性、方法、局部变量
（1）当不希望某个类被继承时，使用final来修饰该类
（2）当不希望父类的某个方法被子类覆盖（重写）时，可以用final关键字修饰
（3）当不希望类的某个属性的值被修改，可以使用final来修饰（常说的常量）
（4）当不希望某个局部变量被修改时，可以用final关键字修饰

/**
 * @author Francis
 * @create 2021-07-02 13:57
 */

public class Final01 {
    public static void main(String[] args) {

        E e = new E();
//e.TAX_RATE = 0.09;
    }
}
//如果我们要求 A 类不能被其他类继承
//可以使用 final 修饰 A 类
final class A { }
//class B extends A {}
class C {
    //如果我们要求 hi 不能被子类重写
//可以使用 final 修饰 hi 方法
    public final void hi() {}
}
class D extends C {
// @Override
// public void hi() {
// System.out.println("重写了 C 类的 hi 方法..");
// }
}
//当不希望类的的某个属性的值被修改,可以用 final 修饰
class E {
    public final double TAX_RATE = 0.08;//常量

}
//当不希望某个局部变量被修改，可以使用 final 修饰
class F {
    public void cry() {
//这时，NUM 也称为 局部常量
        final double NUM = 0.01;
//NUM = 0.9;
        System.out.println("NUM=" + NUM);
    }
}

注意事项和细节
（1）final修饰的属性又叫做常量，一般用XX_XX_XX来作为常量名
（2）final修饰的属性在定义时，必须赋初值，并且以后不能修改，赋值操作可在一下位置之一即可。
①定义时：如public final double TAX_RATE=0.05;
②在构造器中
③在代码块中
（3）如果final修饰的属性是static的，则初始化的位置只能是
①定义时
②静态代码块中
（4）final类不能被继承，但能被实例化
（5）如果类不是final的，但是含有final的方法，则该方法不能被重写，但能被继承
（6）一般来说，一个类如果是final的，就没必要把方法再用final来修饰
（7）final不能修饰构造器方法
（8）final往往和static搭配使用，效率更高，不会导致类加载，底层编译器做了优化
在这里插入图片描述
在这里插入图片描述

（9）包装类（Integer 、Double、Float等)是final的，String也是final的

曳空@竹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
静态成员
代码改变世界
04-04 926
由于内存的空间有限，我们常常关心已经使用掉了多少内存空间。显然，我们需要一个计数器。每生成一个对象，计数器就加一；每消除一个对象，计数器就减一。   静态成员数据：         将生成对象的个数记为count，它不是某一个对象所具有的属性，而应该是整个类所具有的属性，或者说它是所有对象的共有属性。         count要能被任何一个结点使用，但事实上无论有多少个结点，count只
Java面向对象之代码块和final关键字的使用
qq_41921196的博客
07-15 164
代码块（或初始化块） 代码块的作用：用来初始化类，对象 代码块如果有修饰的话：只能使用static 分类：静态代码块VS 非静态代码块 静态代码块 内部可以有输出语句 随着类的加载而执行，而且只执行一次 作用：初始化类的信息 如果一个类中定义了多个代码块，则按照声明的先后顺序执行 静态代码块的执行要优先于非静态代码块 静态代码块内，只能调用静态的属性或者静态的方法 非静态代码块 内部可以有输出语句 随着对象的创建而执行 每创建一个对象，就执行一次非静态代码块 作用：可以在创建对象时，对对象的属性等
Java学习-static关键字、final关键字和代码块
jQueryZK的博客
08-18 7131
一、static关键字 1、static关键字的基本概念 被static关键字修饰的不需要创建对象去调用，直接根据类名就可以去访问。也就是说，被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。 方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。...
java的static静态成员变量和static代码块，只有在类被调用或者实例化的时候，才会被赋值，或者调用
fangletian1981的专栏
06-22 1865
如题，如果该类，如A， 在入口程序或者整个执行栈过程中，都不出现，那么A中的static成员变量，或者static代码块，都不会执行。static的方法更是只有在调用的时候，才会执行。 一般顺序：静态块----> 静态变量——>成员变量——>构造方法——>静态方法 1、静态代码块（只加载一次） 2、构造方法（创建一个实例就加载一次）3、静态方法需要调用才会执行 ...
static静态代码块中给静态成员变量赋值坑
iCopper_的博客
08-24 7113
public class testdemo { private static final String name; static { name = "string"; try { // name="string"; } catch (Exception e) { e.printStack...
java final关键字 详解
Cyan_RA9的博客
02-20 2343
java final关键字 内容分享，本篇博文为java 面向对象三大特性——多态篇的补充。
java中静态变量与final关键字
JYKgo的博客
11-21 1230
java中静态变量与final关键字
Java基础(十)：关键字static、代码块、关键字final
从基础到源码解析的学习记录
03-29 532
对比静态变量与实例变量。
Java中的static与final关键字
m0_56602092的博客
03-09 849
1、final 关键字可以用于修饰类、类变量、成员变量以及方法。2、final 成员变量，必须在声明的时初始化或者在构造器中初始化，否则报编译错误。3、final 变量不能再次赋值（引用类型指向的对象中的数据还是可以修改的）；final 方法不能被重写；final 类不能被继承。4、在匿名类中声明的变量都必须是 final 变量。5、接口中声明的所有变量本身是 final 的。6、修饰类时final 和 abstract 这两个关键字是反相关的，final 类就不可能是 abstract 的。
JAVA基础面试题1，包含静态资源，final关键字，静态代码块等相关知识
05-14
包含静态资源，final关键字，静态代码块等相关知识
Java关键字final、static使用总结
08-30
final方法不能被子类的方法覆盖，但可以被...用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块，下面通过本文给大家分享Java关键字final、static使用总结，感兴趣的朋友一起看看吧
Java并发--final关键字.docx
06-26
类变量可以再声明变量的时候直接赋初始值或者在静态代码块中给类变量赋初始值；而实例变量可以在声明变量的时候给实例变量赋初始值，在非静态初始化块中以及构造器中赋初始值。 类变量有两个时机赋初始值，而实例...
Java中的静态变量静态方法静态块与静态类.docx
09-30
Java 中的静态变量、静态方法、静态块和静态类 Java 中的静态变量、静态方法、静态块和静态类是 Java 编程语言的四个重要概念，它们之间存在着紧密的关系。下面将对这四个概念进行详细的介绍。 一、静态变量...
Java面试基础知识.docx
11-16
本文总结了Java面试基础知识的重要概念和技术点，涵盖了异常处理机制、接口和虚类、垃圾回收机制、线程同步、析构函数和虚函数、Error和Exception的区别、final类型的类、编程风格、堆和栈的区别、超大整数的存储和...
java基础之正则表达式
qq_44835120的博客
06-06 7421
regular expression：正则表达式，简写为RegExp,擅长用在文本格式匹配领域 1、正则表达式的元字符 1、转义字符"\" 在java中，用\\来表示转义字符，需要用到转义字符的符号有如下几个：.*+()$/?[]^{} 2、字符匹配符 符号 含义 示例 解释 匹配输入 [] 可以接收的字符列表 [abcde] a、b、c、d、e中的任意一个字符 [^] 不接收的字符列表 [^abcde] 除a、b、c、d、e外的任意一个字符，包含特殊字符 - 连字符 A-Z 从
003Java基础之变量及数据类型
qq_44835120的博客
06-15 1258
变量是程序的基本组成单位。不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。 变量有三个基本要素：类型、名称、值 1变量概述 1、变量的概念 变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值） 2、变量使用的基本步骤 1、声明变量 int a 2、赋值a=60;//应该这么说:把60赋给a使用 也可以一步到位，声明的同时并赋值：int a = 60; 2、变量快速入门 变量使用入门案例 public cla
001Java基础之初识Java、JDK安装及Java开发应注意的细节
qq_44835120的博客
06-14 1157
1、创建数据库 SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; create database ssmbuild; USE ssmbuild; -- ---------------------------- -- Table structure for books -- ---------------------------- DROP TABLE IF EXISTS books; CREATE TABLE books (
017Java基础之集合（Collection-＞Set）
qq_44835120的博客
09-29 891
1、Set 接口和常用方法 1.1、Set 接口基本介绍 （1）Set接口的实现子类的元素是无序的，即添加和去除的顺序不同，但是一旦顺序确定了之后取出的顺序就不会改变，没有索引 （2）不允许元素重复，所以最多能包含一个null 1.2、Set 接口的常用方法 和 List 接口一样, Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样. 1.3、Set 接口的遍历方式 通Collection的遍历方式一样，因为Set是Collection的子接口 （1）迭代器
022Java基础之文件操作
qq_44835120的博客
11-18 587
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Java中被final关键字修饰的变量，不能被重新赋值。
最新发布
06-08
是的，Java中被`final`关键字修饰的变量被称为常量，一旦被赋值后，就不能被重新赋值。如果试图对`final`变量再次赋值，编译器会报错。被`final`修饰的变量可以是成员变量、局部变量或者静态变量。 需要注意的是，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值