精华内容
下载资源
问答
  • 在类中声明的变量称为
    千次阅读
    2021-02-27 12:17:22

    变量为我们提供了程序可以操纵的命名存储。Java提供了三种类型的变量。类变量-类变量也称为静态变量,是在类中但使用方法,构造函数或块之外使用static关键字声明的。每个类每个类变量只有一个副本,而不管从中创建了多少个对象。

    实例变量-实例变量在类中声明,但在方法外部。为堆中的对象分配空间时,将为每个实例变量值创建一个插槽。实例变量包含必须由整个类中必须存在的多个方法,构造函数或块或对象状态必不可少的部分引用的值。

    局部变量-局部变量在方法,构造函数或块中声明。输入方法,构造函数或块时将创建局部变量,并且一旦退出方法,构造函数或块,该变量将被销毁。

    示例

    public class VariableExample{

    int myVariable;

    static int data = 30;

    public static void main(String args[]){

    int a = 100;

    VariableExample obj = new VariableExample();

    System.out.println("Value of instance variable myVariable: "+obj.myVariable);

    System.out.println("Value of static variable data: "+VariableExample.data);

    System.out.println("Value of local variable a: "+a);

    }

    }

    输出结果Value of instance variable myVariable: 0

    Value of static variable data: 30

    Value of local variable a: 100

    更多相关内容
  • java声明变量

    千次阅读 2022-03-01 15:23:26
    1.关键字 AJava关键字是Java语言保留供内部使用的,如 class 用于定义...就是给,接口,方法,变量等起名字的字符序列。用来查找、定位、标明、唯一确认内容。 ·表示类名的标识符用大写字母开始。如: Man , ..

    1.关键字

    AJava关键字是Java语言保留供内部使用的,如 class 用于定义类。 关键字也可以称为保留字,它们的意思 是一样的。是被系统征用的特殊单词(标识符),而且是被广大程序员所认知的。

     goto和const作为保留字存在。

    类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记

    不能使用关键字作为变量名或方法名

    2. 标识符

    就是给类,接口,方法,变量等起名字的字符序列。用来查找、定位、标明、唯一确认内容。

      ·表示类名的标识符用大写字母开始。如: Man , GoodMan

      ·表示方法和变量的标识符用小写字母开始,后面的描述性词以大写开始。 eat() , eatFood()

    Java 标识符有如下命名规则:

        标识符必须以字母、下划线_ 、美元符开头。

        标识符其它部分可以是字母、下划线“_”、美元符“ ”和数字的任意组合。

        Java 标识符大小写敏感,且长度无限制。

        不可以是Java的关键字 JAVA不采用通常语言使用的ASCII字符集,而是采用unicode这样的标准的国际字符集。因此,这里的字 母的含义:英文、汉字等等。(不建议大家使用汉字来定义标识符!)

    合法的标识符

    int a = 3;
    int _123 = 3;
    int $12aa = 3;
    int 变量1 = 55;

    不合法的标识符

    int 1a = 3; //不能用数字开头
    int a# = 3; //不能包含#这样的特殊字符
    int int = 3; //不能使用关键字

    3. 变量(variable)

         我们通过变量来操纵存储空间中的数据,变量就是指代这个存储空间!空间位置是确定的,但是里面放 置什么值不确定!

      Java是一种强类型语言,每个变量都必须声明其类型。

         Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。

         变量在使用前必须对其声明, 只有在变量声明以后,才能为其分配相应长度的存储单元,声明格式 为:

    type varName [=value] ;

       注意事项:

       每个变量都有类型,类型可以是基本类型,也可以是引用类型。 变量名必须是合法的标识符。       变量声明是一条完整的语句,因此每一个声明都必须以分号结束。 

       变量声明举例

    double salary ;
    boolean done;
    long earthPopulation ;
    int age ;

    可以在一行中声明多个变量

    int i ,j; // both are integer

    不提倡这种风格,逐一声明每一个变量可以提高程序可读性

         可以将变量的声明和初始化放在同一行中,例如

    int age = 18;
    float e = 2.718281828f;

        实例变量(成员变量 member variable):方法外部、类的内部定义的变量。从属于对象,生命周 期伴随对象始终,如果不自行初始化,他会自动初始化成该类型的默认初始值(数值型变量初始化成 0或0.0,字符型变量的初始化值是16位的0,布尔型默认是false) 静态变量(类变量 static variable):使用static定义。 从属于类,生命周期伴随类始终,从类加 载到卸载。 (注:讲完内存分析后我们再深入!先放一放这个概念!),如果不自行初始化,他会自动 初始化成该类型的默认初始值(数值型变量初始化成0或0.0,字符型变量的初始化值是16位的0, 布尔型默认是false)

    说明以下的变量分别是什么类型的变量(局部、静态、实例),分别是声明还是定义亦或是其他操作

    public class LocalVariableTest {
       public static void main(String[ ] arg) {
       boolean flag = true;
       char c1, c2;
       c1 = '\u0041';
       c2 = 'B';
       int x;
       x = 9;
       int y = x;
       float f = 3.15f;
       double d = 3.1415926;
       }
    }

    4. 常量(Constant) 常量:

    初始化(initialize)后不能再改变值!

    public class Constants {
      public static void main(String[] args) {
      final double PI = 3.14;
      // PI = 3.15; //error
      double r = 4;
      double area = PI * r * r;
      double circle = 2 * PI * r;
      System.out.println("area = " + area);
      System.out.println("circle = " + circle);
      }
    }
    

    5. 命名规则(规范)

         所有变量、方法、类名:见名知意

         类成员变量:首字母小写和驼峰原则 : monthSalary

         局部变量:首字母小写和驼峰原则

         常量:大写字母和下划线:MAX_VALUE

         类名:首字母大写和驼峰原则: Man, GoodMan

         方法名:首字母小写和驼峰原则: run(), runRun()

       6. 基本数据类型(primitive data type)

           Java是一种强类型语言,每个变量都必须声明其类型。

           Java的数据类型分为两大类:基本类型(primitive type)和引用类型(reference type)

           Java中定义了3类8种基本数据类型

                 逻辑型-boolean

                 文本型- char

                 数值型- byte, short, int, long, float, double

     注:引用数据类型的大小统一为4个字节,记录的是其引用对象的地址!

    6.1. 整型

        整型用于表示没有小数部分的数值,它允许是负数。

        整型的范围与运行Java代码的机器无关,这正是Java程序具有很强移植能力的原因之一。于此相反,C和 C++程序需要针对不同的处理器选择最有效的整形

     Java 语言整型常数的三种表示形式:

            十进制整数,如:99, -500, 0。

            八进制整数,要求以 0 开头,如:015。

            十六进制数,要求 0x 或 0X 开头,如:0x15 。

    Java语言的整型常数默认为int型,声明long型常量可以后加‘ l ’或‘ L ’ ,如:

    long a = 55555555; //不出错,在Int表示的范围内(21亿内)。
    long b = 55555555555;//不加l出错,已经超过int表示的范围。

    Java中没有无符号类型

    6.2. 浮点型

     Java 浮点类型常量有两种表示形式

    十进制数形式,例如: 3.14 314.0 0.314

    long a = 55555555; //不出错,在Int表示的范围内(21亿内)。
    
    long b = 55555555555;//不加l出错,已经超过int表示的范围。

     科学记数法形式,如 314e2 314E2 314E-2

        浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。 如果需要进行不产生舍 入误差的精确数字计算,需要使用BigDecimal类。

       主要理由:由于字长有限,浮点数能够精确表示的数是有限的,因而也是离散的。浮点数一般都存 在舍入误差,很多数字无法精确表示(例如0.1),其结果只能是接近, 但不等于。

       二进制浮点数不能精确的表示0.1,0.01,0.001这样10的负次幂。并不是所有的小数都能可以精确的 用二进制浮点数表示。最好完全避免使用浮点数比较:

    double f = 314e2; //31410^2-->31400.0
    double f2 = 314e-2; //31410^(-2)-->3.14
    float f = 0.1f;
    double d = 1.0/10;
    System.out.println( f d); //false
    float d1 = 423432423f;
    float d2 = d1+1;
    if(d1 d2){
    System.out.println("d1==d2");
    }else{
    System.out.println("d1!=d2");
    }

    大数值:

        Java.math下面的两个有用的类:BigInteger和BigDecimal,这两个类可以处理任意长度的数 值,BigInteger实现了任意精度的整数运算,BigDecimal实现了任意精度的浮点运算。

        浮点数使用总结:

           1. 默认是double

            2. 浮点数存在舍入误差,很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计 算,需要使用BigDecimal类避免比较中使用浮点数。

    6.3. 字符型

       单引号用来表示字符常量。例如 ‘A’ 是一个字符,它与 “A” 是不同的, “A” 表示含有一个字符的字符 串。 

       char 类型用来表示在 Unicode 编码表中的字符。

       Unicode 编码被设计用来处理各种语言的所有文字,它占2个字节,可允许有65536 个字符;ASCII码占 1个字节,可允许有128个字符,是Unicode编码表中前128个字符。

    char eChar = 'a';
    char cChar ='中';
    

        Unicode具有从0到65535之间的编码,他们通常用从 ’\u0000’ 到 ’\uFFFF’ 之间的十六进制值来表示(前 缀为u表示Unicode)

    char c = '\u0061';

    Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义

    char c2 = '\n'; //代表换行符 •
    

     注:以后我们学的String类,其实是字符序列(char sequence)

    6.4. boolean类型

       boolean类型有两个值,true和false,不可以 0 或非 0 的整数替代 true 和 false ,这点和C语言不 同。

       boolean 类型用来判断逻辑条件,一般用于程序流程控制 。

       大小占一位,不是一个字节

    boolean flag ;
    flag = ………;
    if(flag) {
    // true分支
    } else {
    // false分支
    }
    

         实践:Less is More!!请不要这样写:if ( is == true && done == false ) ,只有新手才那么写。 对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==fasle 和 ==true。

    展开全文
  • 成员变量类变量(Java)

    千次阅读 2019-12-29 09:33:18
    变量定义 成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类方法、构造方法和特定类的语句块...类变量:类变量声明在类中,方法体之外,但必须声明为static类型。 ...

    变量定义

    成员变量:是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。(成员变量亦称实例变量)
    类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。(类变量亦称静态变量)

    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。

    成员变量和类变量的区别:

    1、两个变量的生命周期不同
    成员变量随着对象的创建而存在,随着对象的回收而释放。
    静态变量随着类的加载而存在,随着类的消失而消失。
    2、调用方式不同
    成员变量只能被对象调用。
    静态变量可以被对象调用,还可以被类名调用。
    3、别名不同
    成员变量也称为实例变量。
    静态变量也称为类变量。
    4、数据存储位置不同
    成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
    静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。
    static 关键字
    static 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。
    特点:
    1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
    2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。
    3、静态随着类的加载而加载。而且优先于对象存在。
    弊端:
    1、有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。
    2、静态方法只能访问静态成员,不可以访问非静态成员。因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。
    3、静态方法中不能使用this,super关键字。因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。
    什么时候定义静态成员呢?
    成员分两种:
    1、成员变量。(数据共享时静态化)
    该成员变量的数据是否是所有对象都一样,如果是,那么该变量需要被静态修饰,因为是共享的数据。如果不是,那么就说这是对象的特有数据,要存储到对象中。
    2、成员函数。(方法中没有调用特有数据时就定义成静态)
    如果判断成员函数是否需要被静态修饰呢?
    只要参考,该函数内是否访问了对象中的特有数据,如果有访问特有数据,那方法不能被静态修饰。 如果没有访问过特有数据,那么这个方法需要被静态修饰。
    成员变量和静态变量的区别:
    1、成员变量所属于对象。所以也称为实例变量。
    静态变量所属于类。所以也称为类变量。
    2、成员变量存在于堆内存中。
    静态变量存在于方法区中。
    3、成员变量随着对象创建而存在。随着对象被回收而消失。
    静态变量随着类的加载而存在。随着类的消失而消失。
    4、成员变量只能被对象所调用 。
    静态变量可以被对象调用,也可以被类名调用,所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。

    展开全文
  • C++中变量声明与定义的规则

    千次阅读 2021-04-19 10:56:43
    其中声明规定了变量的类型和名字,定义除此功能外还会申请存储空间并可能为变量赋一个初始值。 extern 如果想声明一个变量而非定义它,就使用关键字extern并且不要显式地初始化变量: extern int i; // 声明i而非...

    声明与定义分离

    Tips:变量能且仅能被定义一次,但是可以被多次声明。

    为了支持分离式编译,C++将定义和声明区分开。其中声明规定了变量的类型和名字,定义除此功能外还会申请存储空间并可能为变量赋一个初始值。

    extern

    如果想声明一个变量而非定义它,就使用关键字extern并且不要显式地初始化变量:

    extern int i;      // 声明i而非定义i
    extern int i = 1;  // 定义i, 这样做抵消了extern的作用

    static

    当我们在C/C++用static修饰变量或函数时,主要有三种用途:

    • 局部静态变量
    • 外部静态变量/函数
    • 类内静态数据成员/成员函数

    其中第三种只有C++中有,我们后续在面向对象程序设计中再探讨,这里只讨论静态局部/全局变量。

    1. 静态局部变量

    在局部变量前面加上static说明符就构成静态局部变量,例如:

    // 声明局部静态变量
    static int a;
    static int array[5] = {1, 2, 3, 4, 5};
    • 静态局部变量在函数内定义,但不像自动变量那样当函数被调用时就存在,调用结束就消失,静态变量的生存期为整个源程序
    • 静态变量的生存期虽然为整个源程序,但是作用域与自动变量相同,即只能在定义该变量的函数内使用该变量,退出函数后虽然变量还存在,但不能够使用它
    • 对基本类型的静态局部变量如果在声明时未赋初始值,则系统自动赋0值;而对普通局部变量不赋初始值,那么它的值是不确定的

    根据静态局部变量的特点,它的生存期为整个源程序,在离开定义它的函数(作用域)但再次调用定义它的函数时,它又可继续使用,而且保存了前次被调用后留下的值。因此,当多次调用一个函数且要求在调用之间保留某些变量的值时,可考虑采用静态局部变量,虽然用全局变量也可以达到上述目的,但全局变量有时会造成意外的副作用,因此最好采用局部静态变量。例如:

    #include <iostream>
    
    void foo() {
        int j = 0;         // 普通局部变量
        static int k = 0;  // 静态局部变量
        ++j;
        ++k;
        printf("j:%d, k:%d\n", j, k);
    }
    
    int main(void)
    {
        for (int i = 1; i <= 5; i++) {
            foo();
        }
    }
    
    // 输出:
    j:1, k:1
    j:1, k:2
    j:1, k:3
    j:1, k:4
    j:1, k:5

    2. 静态全局变量(C++废弃,用匿名命名空间替代)

    Tips:对于全局变量,不管是否被static修饰,它的存储区域都是在静态存储区,生存期为整个源程序。只不过加上static后限制这个全局变量的作用域只能在定义该变量的源文件内。

    全局变量(外部变量)的声明之前加上static就构成了静态的全局变量,全局变量本身就是静态存储变量,静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同,这两者的区别在于非静态全局变量的作用域是整个源程序。当一个源程序由多个源程序组成时,非静态的全局变量在各个源文件中都是有效的,而静态全局变量则限制了其作用域,即只在定义该变量的源文件内有效,在同一源程序的其他源文件中不能使用它。

    这种在文件中进行静态声明的做法是从C语言继承而来的,在C语言中声明为static的全局变量在其所在的文件外不可见。这种做法已经被C++标准取消了,现在的替代做法是使用匿名命名空间。

    匿名命名空间:指关键字namespace后紧跟花括号括起来的一系列声明语句,具有如下特点:

    • 在匿名命名空间内定义的变量具有静态生命周期
    • 匿名空间在某个给定的文件内可以不连续,但是不能跨越多个文件
    • 每个文件定义自己的匿名命名空间,不同文件匿名命名空间中定义的名字对应不同实体
    • 如果在一个头文件中定义了匿名命名空间,则该命名空间内定义的名字在每个包含该头文件的文件中对应不同实体
    namespace {
        int i;  // 匿名命名空间内定义的变量具有静态生命周期, 作用域仅限于当前文件
    }

    3. 总结

    static这个说明符在不同地方所起的作用域是不同的,比如把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期,把全局变量改变为静态变量后是改变了它的作用域,限制了它的使用范围。

    auto

    1. C++98中auto用法(C++11已废弃)

    C++98 auto用于声明变量为自动变量(拥有自动的生命周期),C++11已经删除了该用法,取而代之的是“变量的自动类型推断方法”。

    // c++ 98:
    int a = 10;         // 拥有自动生命期
    auto int b = 20;    // 拥有自动生命期(C++11编译不过)
    static int c = 30;  // 延长了生命期

    C++11新标准引入了auto类型说明符,让编译器通过初始值来自动推断变量类型(这意味着通过auto定义的变量必须有初始值)。

    // c++ 11:
    int a = 10;
    auto auto_a = a;  // 自动类型推断为int类型

    2. auto会去除变量的引用语义

    当引用对象作为初始值时,真正参与初始化的是引用对象的值,此时编译器会以引用对象的类型作为auto推算的类型:

    int main(void) {
        int i = 10;
        int &ri = i;
        auto auto_i = ri;  // 去除引用语义, 自动推断为int
    }

    如果希望推断出来的auto类型包含引用语义,我们需要用&明确指出:

    int main(void) {
        int i = 10;
        auto &auto_i = i;  // 加上引用语义, 自动推断为int&
    }

    3. auto忽略顶层const

    auto一般会忽略掉顶层const,同时底层const会被保留下来:

    int main(void) {
        const int ci = 10;    // 常量int
        auto auto_ci = ci;    // auto_ci被推断为int类型
        auto_ci = 20;         // 正确: auto_ci非常量
    
        const int &cr = ci;   // cr是指向常量int的常量引用
        auto auto_cr = cr;    // auto_cr被推断为int类型: 去除了引用语义 + 去除了顶层const
        auto_cr = 20;         // 正确: auto_cr非常量
    
        const int *cp = &ci;  // cp是指向常量int(底层)的常量指针(顶层)
        auto auto_cp = cp;    // auto_cp被推断为const int*类型(指向常量int的指针): 去除了顶层const + 保留底层const
        // *auto_cp = 10;     // 错误: 不能修改auto_cp指向的常量
    }

    如果希望推断出来的auto类型是一个顶层const,我们需要通过const关键字明确指出:

    int main(void) {
        const int ci = 10;          // 常量int
        const auto auto_ci = ci;    // auto_ci被推断为const int类型
        // auto_ci = 20;            // 错误: auto_ci是一个常量, 禁止修改
    }

    const

    有时我们希望定义一个不能被改变值的变量,可以使用关键字const对变量类型加以限定。

    1. const对象必须初始化

    因为const对象一经创建后其值就不能再改变,所以const对象必须初始化,但是初始值可以是任意复杂的表达式:

    const int i = get_size();  // 正确: 运行时初始化
    const int j = 42;          // 正确: 编译时初始化
    const int k;               // 错误: k是一个未经初始化的常量

    2. 默认情况下const仅在文件内有效

    举个例子,我们在编译时初始化一个const对象:

    const int i = 10;

    编译器会在编译过程把用到该变量的地方都替换为对应的值。为了执行这个替换,编译器必须知道变量的初始值,如果程序包含多个文件,那么每个用了这个const对象的文件都必须得能访问到它的初始值才行(即每个文件都要定义const对象)。为了避免对同一变量的重复定义,当多个文件中出现同名的const对象时,其实等同于在不同文件中分别定义了独立的变量。

    /*
     * 下面是合法的, 不存在变量i重复定义问题
     */
    
    // foo.cpp
    const int i = 10;
    
    // bar.cpp
    const int i = 5;

    如果想在多个文件之间共享const对象,那么必须在变量的定义之前添加extern关键字:

    /*
     * 下面是合法的, main.cpp和foo.cpp中的const int对象是同一个
     */
    
    // foo.cpp
    extern const int i = 10;
    
    // main.cpp
    #include <iostream>
    
    int main(void) {
        extern int i;
        std::cout << "i:" << i << std::endl;
    }

    3. 允许常量引用绑定非常量对象、字面值甚至一般表达式

    一般而言,引用的类型必须与其所引用对象的类型一致,但是有两个例外:

    • 初始化常量引用时允许用任意表达式作为初始值,只要该表达式的结果能转换成引用类型即可,允许为一个常量引用绑定非常量的对象、字面值甚至是一个一般表达式(如下)
    • 可以将基类的指针或引用绑定到派生类对象上(后续面向对象章节再探讨)
    int i = 10;
    
    const int &ri1 = i;      // 合法: 绑定到非常量对象
    const int &ri2 = 100;    // 合法: 绑定到字面值
    const int &ri3 = 1 + 1;  // 合法: 绑定到一般表达式

    4. 顶层const与底层const

    指针本身是一个对象,因此指针本身是不是常量与指针所指对象是不是常量是两个独立的问题,前者被称为顶层const,后者被称为底层const。

    Tips:指针类型既可以是顶层const也可以是底层const,其他类型要么是顶层常量要么是底层常量。

    顶层const用于表示任意的对象是常量,包括算数类型、类和指针等,底层const用于表示引用和指针等复合类型的基本类型部分是否是常量。

    int i = 10;
    
    int *const p1 = &i;        // 顶层const: 不能改变p1的值
    const int *p2 = &i;        // 底层const: 不能通过p2改变i的值
    const int *const p3 = &i;  // 底层const + 顶层const
    
    const int &r1 = i;         // 底层const: 不能通过r1改变i的值

    constexpr

    C++11引入了常量表达式constexpr的概念,指的是值不会改变并且在编译期间就能得到计算结果的表达式。

    const int i = 10;          // 常量表达式
    const int j = i + 1;       // 常量表达式
    const int k = size();      // 仅当size()是一个constexpr函数时才是常量表达式, 运行时才能获得具体值就不是常量表达式

    在一个复杂系统中,我们很难分辨一个初始值是否是常量表达式,通过constexpr关键字声明一个变量,我们可以让编译器来验证变量的值是否是一个常量表达式。

    1. 字面值是常量表达式

    算术类型、引用和指针都属于字面值类型,自定义类则不属于字面值类型,因此也无法被定义为constexpr。

    Tips:尽管指针和引用都能被定义成constexpr,但它们的初始值却受到严格限制。一个constexpr指针的初始值必须是nullptr、0或者是存储于某个固定地址中的对象。

    2. constexpr是对指针的限制

    在constexpr声明中定义了一个指针,限定符constexpr仅对指针有效,与指针所指对象无关:

    const int *pi1 = nullptr;      // 底层const: pi1是指向整型常量的普通指针
    constexpr int *pi2 = nullptr;  // 顶层const: pi2是指向整型的常量指针

    我们也可以让constexpr指针指向常量:

    constexpr int i = 10;
    constexpr const int *pi = &i;  // 顶层const + 底层const

    Reference

    [1] https://www.cnblogs.com/lca1826/p/6503194.html

    [2] https://blog.csdn.net/u012679707/article/details/80188124

    [3] C++ Primer

    展开全文
  • 编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ; 其中面向对象语言主要体现三个特征:封装性、继承、...2、类声明变量称为对象变量,也简称 对象 ; 3、class 关键字是用来定义 ; 4、...
  • JavaScript中声明变量的三种方式

    千次阅读 2019-02-24 15:53:39
    1:let和const是ES6新增声明变量的关键字, 2:let声明的变量不会进行变量提升, console.log(name) //name is not undefined let name='张三' 3:let的声明方式和var基本上是一样的,一经声明不赋值输出undefined,后续...
  • 函数声明变量的定义

    千次阅读 2019-04-14 19:44:13
    函数声明变量的定义声明与定义比较前向引用函数属性内部/内嵌函数函数应用:打印图形和数学计算变量作用域全局变量与局部变量局部变量全局变量globa语句可变类型的全局变量 声明与定义比较 ​ 某些编程语言...
  • 如何Python定义变量

    千次阅读 2021-01-25 11:29:59
    我们首先看一下变量的分类,通常情况下,我们所说到的定义一个变量,如果没有特殊说明,那么就是定义一个全局...全局变量供全局共享,全局和函数均可访问,达到同步作用。同时还可以被外部文件访问。 使用 全局变量使
  • Java类变量类型

    千次阅读 2021-02-28 14:52:19
    1.局部变量:在方法、构造方法、语句块定义的变量。其声明和初始化在方法实现,在...成员变量:定义在类中,方法体之外。变量在创建对象时实例化。成员变量可被类的方法、构造方法以及特定类的语句块访问。1 ...
  • 在声明成员变量时,用关键字static给予修饰的称作类变量,否则成为实例变量类变量称为static变量、静态变量),例如: class Person { int x; //实例变量 static int y; //类变量 } 上述Person...
  •  java,将一个定义另一个里面或者是方法里面,这样的称为是内部内部。大概可以分为四类:成员内部、局部内部、匿名内部和静态内部。  这四种类具体的区别可参考java内部详解 二,...
  • 从一个类调用另一个类变量的方法 一、无需实例化举例 public class A { // a是静态变量(static),称为变量...// 在类B使用类A变量 public class B { public void Test1() { //存取A.a,不用实例...
  • C语言,把变量定义主函数之外和定义主函数之内有什么区别答案:7信息版本:手机版解决时间 2018-12-14 06:44已解决2018-12-13 14:23C语言,把变量定义主函数之外和定义主函数之内有什么区别最佳答案2018-...
  • C++通过及相关的封装、继承、多态和虚函数机制支持面向对象的程序设计和开发。...C++中类声明(也又称)式如下:class 类名 { 访问范围说明符: 成员变量1; 成员变量2; ... 成员函数1声明; 成员函数1定义;
  • 只能内部类中定义静态; 静态内部与外层绑定,即使没有创建外层的对象,它一样存在; 静态的方法可以是静态的方法也可以是非静态的方法,静态的方法可以外层通过静态调用,而非静态的方法必须要创建...
  • Javaswitch case语句中声明变量

    千次阅读 2020-04-27 21:48:03
    Javaswitch case语句中声明变量 Java使用switch case语句时很容易出现以下两个报错: 1、Duplicate local veriable out. (局部变量重复) 2、The local veriable out may not have been initialized. (局部...
  • PHP 和 JavaSript 区别_后端开发PHP是一种...C语言中在main函数中定义的变量不是全局变量,而是局部变量。main函数中定义的变量与全局变量的生命周期一样长。(推荐教程:C语言教程)注意:全局变量一定是定义在函数...
  • 全局变量在整个源文件的作用域都是有效的,只需要一个源文件定义全局变量其他不包含全局变量定义的源文件中用extern关键字再次声明这个全局变量即可。 也可以一个源文件定义这个全局变量头文件中用...
  • 成员变量类中变量(独立于方法之外的变量) 局部变量类的方法变量。 而 java的成员变量又有俩种: 静态变量类变量): 独立于方法之外的变量,用 static 修饰。 实例变量: 独立于方法之外的变量,不过...
  • java当中的成员变量定义了的属性,下面的文章要给大家详细讲解的就是成员变量的定义和声明的内容,一起来了解一下吧。例:一个学生当中一般都需要有姓名性别以及年龄等属性,这个时候的话,就需要定义姓名、...
  • Java基础---类变量和实例变量

    千次阅读 2022-02-18 22:23:58
    成员变量:把内、方法体外的变量称为成员变量。 package com.chen.offer.BiliBili; /** * @author chenshimiao * @Email 16622880228@163.com * @date 2022/2/18 10:27 下午 * * 区分成员变量 实例变量和...
  • Python变量

    千次阅读 2020-12-04 20:40:32
    第三章 变量变量的声明python语言是动态语言变量不需要事先声明变量的类型不需要声明每个变量使用前都必须赋值,变量赋值以后该变量才会被创建。 Python ,变量就是变量,它没有类型,我们所说的 类型是变量所...
  • js有三种声明变量的方式:var、let、const,其中,let、const 是 ES6 中新加的。 一、 var 1. var关键字定义变量 定义方式: var 变量名; (1) var message; // 没有初始化变量,message的值为undefined ...
  • 这种变量称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。 当一个对象被实例化之后,每个实例变量的值就跟着确定; 实例变量在对象创建的时候创建,在对象被销毁的时候销毁; 实例变量的值应该...
  • 了解术语很重要。实例变量类变量都是成员变量。它们都是成员变量,因为它们都与特定相关联。但是,实例变量类变量之间存在差异。...重要的是要记住,类变量在C ++,Java和C#称为静态成员变量的每个对...
  • VB 变量声明及作用域

    千次阅读 2019-12-09 23:30:30
    一、变量声明 一般来说,变量必须先声明后使用。即告诉编译器在程序使用了哪些变量,及为变量开辟多大的内存空间。...为了避免写错变量名引起的麻烦,可在类模块、窗体模块或标准模块的声明...
  • Java——类变量和实例变量的区别

    万次阅读 多人点赞 2019-04-29 15:47:01
    成员变量:把内、方法体外定义的变量称为成员变量。 Java的成员变量分为两种: 一是没有static修饰的,这些成员变量是对象的成员,称为实例变量。 二是有static修饰的,称为变量(静态变量)。 静态...
  • 变量声明变量使用的注意事项

    千次阅读 2020-04-06 13:37:30
    《零基础学 JavaScript》+《JavaScript 权威指南》(第6版) 一、变量声明的注意事项   1. 重复的声明   2....  使用 var 重复声明变量是合法且无害的。如果重复声明带有初始化器(即声明且赋...
  • 第四章 变量

    千次阅读 2020-12-04 20:40:25
    一、 变量的声明python语言是动态语言变量不需要事先声明变量的类型不需要声明每个变量使用前都必须赋值,变量赋值以后该变量才会被创建。 Python ,变量就是变量,它没有类型,我们所说的 类型是变量所指的...
  • 类变量(静态变量

    千次阅读 2018-03-22 22:16:13
    变量(静态变量)类变量称为静态变量在类中以static关键字声明,但必须在方法构造方法和语句块之外。无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。静态变量除了被声明为常量外很少使用。常量是指...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 407,313
精华内容 162,925
热门标签
关键字:

在类中声明的变量称为