精华内容
下载资源
问答
  • 常量定义的修饰符
    2021-02-03 17:53:27

    常量

    概念

    1. 定义:初始化(initialize)后不能再改变值。是不会变动的值。
      可以理解为特殊的变量
    2. 常量名一般使用大写字符
    3. 关键字:final
    4. 命名和规范
      所有变量 方法 类名: 见名知意
    名称原则例子
    类成员变量首字母小写和驼峰原则lastName
    局部变量首字母小写和驼峰原则lastName
    常量大写字母和下划线MAX_VALUE
    类名首字母大写和驼峰原则Man , AllEat
    方法名首字母小写和驼峰原则run() ,appleApple()

    实际例子

    demo8
    修饰符
    变量的命名

    变量类型前的都是修饰符
    不存在先后顺序。
    两个都可以

            static final double PI =3.14;
            final  static double PII = 3.14;
    
    更多相关内容
  • JAVA 常量修饰符 final

    千次阅读 2020-10-22 10:13:49
    final 常量修饰符(final 最终的) 1.被 final 修饰的称之为常量,被修饰的变量或对象或方法不能被改变,比如被 final 修饰的变量就不允许改变 2.final 修饰的对象的命名规则要求大写 比如 NAME 当使用多个单词拼接...

    final 常量修饰符(final 最终的)

    1.被 final 修饰的称之为常量,被修饰的变量或对象或方法不能被改变,比如被 final 修饰的变量就不允许改变
    
    2.final 修饰的对象的命名规则要求大写
    	比如 NAME
    	当使用多个单词拼接时,使用下划线“_”拼接
    	比如 MY_NAME
    
    3.类的构造方法无法被修饰,也无法被重写
    
    4.用final修饰类,类无法被继承,但是类中的内容并不被final修饰
    

    1.修饰变量或对象

    public class Demo01 {
    
        public static void main(String[] args) {
    
            final int I = 100;
            
    
        }
    
    }
    
    1.使用 final 修饰了 i 之后,在下面的代码中,无法再对 i 进行修改,如果对 i 进行修改,编译器直接报错
    
    2.如果对 i 进行定义的的时候没有对 i 进行赋值,那么之后也无法再对 i 进行赋值和修改
    

    2.final修饰方法

    使用 final 修饰方法时,可以被重载,不能够被重写,因为重写相当于用子类的方法覆盖父类的方法,而final
    关键字无法被修改,所以无法重写父类方法
    

    例如

    public class Demo01 {
    
        public static void main(String[] args) {
    
            a();
            a(1);
    
        }
        public static final void a(){
            System.out.println("静态方法");
        }
    
        public static void a(int i){
            System.out.println("重写静态方法");
        }
    
    }
    

    输出结果

    静态方法
    重写静态方法

    3.final修饰类

    创建 Demo02

    public final class Demo02 {
    
        int num = 0;
    
        public void setNum(){
            num=10;
            System.out.println(num);
        }
    
    }
    

    使用Demo02

    public class Demo01 {
    
        public static void main(String[] args) {
            Demo02 d = new Demo02();
            d.setNum();
        }
    }
    

    输出结果

    10

    所以,使用final修饰类,类可以正常使用,但是注意,final修饰的类不能被继承
    
    展开全文
  • b).final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。 c).abstract 修饰符,用来创建抽象类和抽象方法。 d).synchronized 和...

    一、标识符

    Java 所有的组成部分都需要名字。标识符适用于包名、类名、变量名、方法名、对象名、数组名、集合名等的命名。

    关于 Java 标识符,有以下几点需要注意:

    1).所有的标识符都应该以字母(a-z或者A-Z),美元符号($),阿拉伯数字(1-9)或者下划线的任意字符组成

    2).不能以数字开头

    3).关键字不能做标识符

    4).java标识符中对字母大小写要求敏感

    实例:

    合法标识符举例:age、$salary、_value、__1_value

    不合法标识符举例:123abc、-salary

    二、修饰符

    像其他语言一样,Java可以使用修饰符用来定义类、方法或者变量,来修饰类中方法和属性,通常放在语句的最前端。

    修饰符可分为以下两类:

    1).访问控制修饰符

    a).default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

    b).private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    c).public : 对所有类可见。使用对象:类、接口、变量、方法

    d).protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。

    我们可以通过以下表来说明访问权限:

    e1bc90af96d675a66dbfcd9d642c673e.png

    默认访问修饰符-不使用任何关键字

    使用默认访问修饰符声明的变量和方法,对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。

    如下例所示,变量和方法的声明可以不使用任何修饰符。

    682867a7c2d0a0efc079262ae2916fab.png

    私有访问修饰符-private

    私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。

    声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

    Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

    下面的类使用了私有访问修饰符:

    7661bbd30103b2ea3e9578408570b954.png

    实例中,Logger 类中的 format 变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两个 public 方法:getFormat() (返回 format的值)和 setFormat(String)(设置 format 的值)

    公有访问修饰符-public

    被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

    如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

    以下函数使用了公有访问控制:

    c6843abef51c29c65494a8b26df3f48a.png

    Java 程序的 main() 方法必须设置成公有的,否则,Java 解释器将不能运行该类。

    受保护的访问修饰符-protected

    protected 需要从以下两个点来分析说明:

    子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;

    子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

    protected 可以修饰数据成员,构造方法,方法成员,不能修饰类(内部类除外)。

    接口及接口的成员变量和成员方法不能声明为 protected。 可以看看下图演示:

    f37d6ce02111b36c7725340fa33d5bf3.gif

    子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。

    下面的父类使用了 protected 访问修饰符,子类重写了父类的 openSpeaker() 方法。

    13c1e3dcf400002e3e1483259e7c689d.png

    如果把 openSpeaker() 方法声明为 private,那么除了 AudioPlayer 之外的类将不能访问该方法。

    如果把 openSpeaker() 声明为 public,那么所有的类都能够访问该方法。

    如果我们只想让该方法对其所在类的子类可见,则将该方法声明为 protected。

    访问控制和继承

    请注意以下方法继承的规则:

    父类中声明为 public 的方法在子类中也必须为 public。

    父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

    父类中声明为 private 的方法,不能够被继承。

    2).非访问控制修饰符

    a).static 修饰符,用来修饰类方法和类变量。

    b).final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。

    c).abstract 修饰符,用来创建抽象类和抽象方法。

    d).synchronized 和 volatile 修饰符,主要用于线程的编程。

    static 修饰符

    静态变量:

    static 关键字用来声明独立于对象的静态变量,无论一个类实例化多少对象,它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

    静态方法:

    static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据,然后计算这些数据。

    对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

    如下例所示,static修饰符用来创建类方法和类变量

    e292d082bd70697d18c2680f8a99dab2.png

    以上实例运行编辑结果如下:

    242d7af8128a7c8286fa82bcdb758919.png

    final 修饰符

    ~final 变量:

    final 表示"最后的、最终的"含义,变量一旦赋值后,不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

    final 修饰符通常和 static 修饰符一起使用来创建类常量。

    02e15eb64707e46897b9a21f30a43027.png

    ~final 方法

    类中的 final 方法可以被子类继承,但是不能被子类修改。

    声明 final 方法的主要目的是防止该方法的内容被修改。

    如下所示,使用 final 修饰符声明方法。

    2934ff0b2f7f1cc511c8df40465a8517.png

    ~final 类

    final 类不能被继承,没有类能够继承 final 类的任何特性。

    481d9ee61c7d0022b9b81f6a97d437a4.png

    abstract 修饰符

    ~抽象类:

    抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充。

    一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法,那么该类一定要声明为抽象类,否则将出现编译错误。

    抽象类可以包含抽象方法和非抽象方法。

    d339c94dd5d068e38bb9c061489471de.png

    ~抽象方法

    抽象方法是一种没有任何实现的方法,该方法的的具体实现由子类提供。

    抽象方法不能被声明成 final 和 static。

    任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。

    如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

    抽象方法的声明以分号结尾,例如:public abstract sample();。

    513e4072745044887be4b6bcdb68099d.png

    synchronized 修饰符

    synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

    31046e343c14aecc730936eba60ca914.png

    transient 修饰符

    序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。

    该修饰符包含在定义变量的语句中,用来预处理类和变量的数据类型。

    0c06b9a8182bc7a119456ad51bb65ec1.png

    volatile 修饰符

    volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

    一个 volatile 对象引用可能是 null。

    f08a4a28f3d1bd6e2775133f6659ee8a.png

    通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用,那么在 第二行 的 active 值为 false 时循环不会停止。

    但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。

    三、关键字

    下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

    b492a4d76035888d27212d329c07bcc4.png

    55efc92e02ed6711bf777b136e994bb8.png

    daae7b24fae051b4f3e1f0d0727152a0.png

    c6f278f4f32642a51c4a151ffc67d6bd.png

    展开全文
  • 关于常量修饰符 const

    2018-06-30 16:24:16
    一直对const的理解就是简单的常量修饰符定义一个不可改变的变量【注意这里是变量,也就是说const叫常量修饰符,但实际上它定义的是一个变量,只不过由编译器限定未不可修改】。
    原文地址为: 关于常量修饰符 const

          一直对const的理解就是简单的常量修饰符,定义一个不可改变的变量【注意这里是变量,也就是说const叫常量修饰符,但实际上它定义的是一个变量,只不过由编译器限定未不可修改】。

            后来听了老师的课发现const有许多有意思的用法:

            1:const int i = 10; --> i的值不可改变,若i = 11;则报错

            2:const int *j = (int*)&i; 和 int const *j = (int*)&i; --> j指向的变量的内容不可变,若 *j = 20; 则报错

            3:int * const t = (int*)&i; --> t指向的地址不能改变,若t++; 则报错

            老师给出的建议是看const前面是什么,那么那部分就不可修改,比如int const i = 5; const 前是int, 则表示i的值不能被修改

                                                                                                                                      int const * j; const 前也是int, 则表示i指向的变量的值不能被修改

                                                                                                                                      而int * const j; const 前是int *,表示指针指向的值不能被修改


            还有一个有意思的大家可以自己试一下,这个我还不知道是什么原因,

    const in a = 10;
    int *p = (int*)&a;
    int *j = (int*)&a;

    cout << *p << " " << a << " " << *j << endl;
    cout << p << " " << &a << " " << j << endl;
    *p = 20;
    cout << *p << " " << a << " " << *j << endl;
    cout << p << " " << &a << " " << j << endl;

    上面这段代码的结果很有意思,执行完*p = 20;后,*p和*j都变为20,但是a还是10。与此同时可以看到p和j指向的地址和a的地址是相同的。



    在别人的博客里找到了答案

    http://blog.chinaunix.net/uid-26853826-id-3365403.html

    const全局变量存储在全局存储空间,其值只有可读属性,不能修改;

    const局部变量存储在堆栈中,可通过指针修改其值;

    const变量在预处理是处理,编译器只对其值读取一次。



    转载请注明本文地址: 关于常量修饰符 const
    展开全文
  • Java常量定义

    2021-01-20 03:44:48
     由于java interface中声明的字段在编译时会自动加上static final的修饰符,即声明为常量。  public interface Constants{  String name = 111;  }  public class read{  public static void main...
  • 修饰符类型: 无符号 有符号 long short 常量:是指在运行过程中,不变化的值。 0123 //八进制 0x3a //16进制 U23 //无符号整型 234ul //无符号长整型(u和L的大小写与位置都可以互换) 整数常量:可以为...
  • c++ 常量修饰符

    2018-06-07 16:14:50
    常量就像是常规的变量,只不过常量的值在定义后不能进行修改。整数常量整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。整数常量也...
  • 常类型是指使用类型修饰符const修饰的类型,常类型的变量或对象的值是不能被更新的。const 推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。 2、Const作用: (1)可以定义const常量,...
  • 今天复习抽象类和接口,抽象类中变量的不能用 abstract 修饰(所以没有抽象变量这一说法),接口中常量(接口没有变量)、方法的默认修饰符位 public abstract,然而你思考过接口中可以定义 protect abstract、default ...
  • 字段的定义与前面介绍的变量和常量定义类似,只是在变量或常量前面可以加上访问修饰符、修饰 符。C# 语言中类定义后就要确定类中包含的内容,类中包含的内容被称为类中的成员。类中成员的访问修饰符有 4 个,具体...
  • (转)java中的类和方法的修饰符

    千次阅读 2021-03-22 16:11:51
    Java程序在定义类时,除了使用class关键字标识之外,还可以在class之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类。修饰符之间的先后排列次序对类的性质没有任何...
  • 前面不加任何修饰符 3.变量名字母一般都大写 4.常量可以被子类继承 5.一个常量是属于一个类的,而不是某个对象的 作用:当某些值是固定不变的,就用const 1.const 定义常量和define()定义常量的区别? 希望一...
  • 枚举类型及修饰符总结

    千次阅读 2021-05-08 17:22:21
    ##枚举类型及修饰符总结 一、枚举类型 1、枚举类型相当于特殊的类,经过编译之后同样产生一个class文件。枚举类型中可以定义方法(包括构造方法)、属性、静态的方法和属性、继承接口、重载覆盖等,类似于class。 例...
  • 下面要给大家分享的是一道比较常见的Java面试题,是和java接口的修饰符有关的内容,下面一起来看一下具体的题目以及答案解析吧。1、题目Java接口修饰符可以有?A、privateB、protectedC、finalD、abstract2、答案C和...
  • 左值和右值 简言之,左值指的是变量/变量表达式(指向内存位置的表达式eg:1/2a+1...常量定义(字符常量和常变量) c/c++中常量(通常定义成大写形式)有两种定义方式: 1、使用#define 预处理器 eg:#define PI 3.1...
  • c语言常量(c语言常量定义规则)

    千次阅读 2021-05-20 08:57:57
    还有 知不知道在C语言中形式参数和实际参数之间的联系是什么.C语言定义常量常用的方法有以下2种:第一种:宏定义#define N 3 // 定义了一个常量为3的宏N,在程序中N就代表3第二种:给变量初始化赋值 int a = 2;...
  • 本小节详细介绍了 Java 访问修饰符。它们控制 Java 类及其成员(函数和数据)的可见性。它们是公共的、私有的和受保护的。 但是,当没有修饰符存在时,Java 也实现了默认情况。这意味着一个类、它的函数、字段只能...
  • Java常量定义方法汇总

    千次阅读 2021-03-04 03:24:56
    Java常量定义方法汇总时间:2017-06-13来源:华清远见JAVA学院实际工作开发中,我们经常会使用到常量。那么Java常量如何定义呢?Java常量定义的规范是什么?定义Java常量又有哪些注意事项呢?今天华清Java学院小编整理...
  • 修饰符

    千次阅读 2021-03-31 16:48:18
    1、 类的修饰符分为:可访问控制符和非访问控制符两种。 可访问控制符是:公共类修饰符 public protect 非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final 1、公共类修饰符 public : Java 语言中类的可...
  • MMTTMM访问控制修饰符Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。默认的,也称为default,在同一包内可见,不使用任何修饰符。私有的,以private修饰符指定,...
  • C 语言类型修饰符 Const 的教程使用说明 Const 也是应该广泛的关键字 表示后面定义有可能是一个不变的常量 但是 跟各种数据类型定义组合能演变出复杂含义常类型是指使用类型修饰符 const 说明的 类型常类型的变量或...
  • 1、 接口的修饰符只有:public2、 类的修饰符分为:可访问控制符和非访问控制符两种。可访问控制符是:公共类修饰符 public非访问控制符有:抽象类修饰符 abstract ;最终类修饰符 final1、公共类修饰符public: ...
  • final 最终修饰符,修饰类、方法和变量,修饰的类不能够被继承,修饰的方法不能被重新定义,修饰的变量表示为不可修改的常量。 abstract ,抽象修饰符,用来创建抽象类和抽象方法。 synchronized 修饰符,用于线程...
  • 文章目录Java修饰符权限final的关键字常量枚举抽象类抽象类概述抽象类的案例抽象类的特征、注意事项抽象类的应用知识:模板方法模式接口接口概述、特点接口的基本使用:被实现接口与接口的关系:多继承JDK8开始接口...
  • Java 默认修饰符 总结

    千次阅读 2021-02-28 12:44:41
    Java 默认修饰符总结1.类(class)可见性修饰符:public—在所有类中可见,在其他包中可以用import导入。...变量(variable)Java中变量有两种,方法变量和字段变量方法变量只能用一个修饰符:final—表示常量...
  • Java修饰符简单整理Java修饰符访问权限修饰符public 公有访问修饰符protected 受保护的访问修饰符default 默认...修饰符final修饰变量(表示常量)final修饰类(表示最终类)final修饰类的方法接口及其成员的访问属性...
  • 什么是修饰符

    千次阅读 2022-04-01 18:04:51
    修饰符分为:权限修饰符和状态修饰符 权限修饰符:private(私有的),默认,protected(受保护的),public(公共的)。 private:只能在同一个类中才可以访问 默认:只有同一个类中,或者同一个包中子类和无关...
  • Java中,类及其组成所使用的常见修饰符(1)修饰符的分类:权限修饰符:private、默认、protected、public状态修饰符:static、final抽象修饰符:abstract(2)常见的类及其组成所使用的修饰符:修饰类的:有:默认、...
  • 接口和接口成员的修饰符

    千次阅读 2022-01-04 17:07:51
    介绍了接口,接口的方法和变量的修饰符的使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 148,132
精华内容 59,252
关键字:

常量定义的修饰符