精华内容
下载资源
问答
  • 大家都知道,一般而言,在windows系统中,为新创建的文件命名时,在保证后缀合法的基础上,还要保证文件名本身也合法,比如能含有某些符号和空格等。但在某些情况下,即使已经将文件命名为合法的名称,仍然存在...

        大家都知道,一般而言,在windows系统中,为新创建的文件命名时,在保证后缀合法的基础上,还要保证文件名本身也合法,比如不能含有某些符号和空格等。但在某些情况下,即使已经将文件命名为合法的名称,仍然存在出现问题的可能,比如下面就会谈到我今天所遇到的情况。

        事情的背景故事是这样的。我,一个C++初学者,在“CodeBlocks”软件下,参考《C++ Primer Plus》进行一些练习。当我为了测试“i++”与“++i”在“for循环”头部的表达式中所产生的效果的区别时(其实是没有区别的),创建了一个名为 “for_update_test.cbp”(起这个名字,是因为“i++”可以被认为是“for循环”头部的“update-expression”部分) 的C++ console 项目,并在该项目下面进行编程和测试。我打开了source下面的main()部分并进行了简单的编程,代码如下:

    #include <iostream>
    
    using namespace std;
    
    int main()
    {
        int a[5] ={1,2,3,4,5};
    
        cout << "the situation of i++" << endl;
        for (int i=0;i<5;i++)
        {
            cout << a[i] << endl;
        }
    
        cout << "the situation of ++i" << endl;
        for (int i=0;i<5;++i)
        {
            cout << a[i] << endl;
        }
    
        cin.get();
        return 0;
    }

        这当然是一些最基本的内容,大家谁都会。但在我编译然后运行程序时,出现了意想不到的结果。

        为什么会这样呢?我问我自己。

        首先,我猜测,有可能是我写错了程序吧?于是我就仔细检查了我写的内容,但确实没发现写错什么东西,而且编译时候也没有报错。

       之后,我猜测,是不是我的编译器没有设置对,但我检查了settings->compiler里面的设置,使用的是默认的GNU GCC compiler,除了新勾选的C++11这个功能,也没有任何奇怪的内容。

        然后,我猜测,也许是我的CodeBlocks软件有bug?于是我上百度和谷歌搜索我这个情况,也没有找到相同的情况。一般不能运行程序都是因为编译器有问题,但我的编译器明明是没有问题的。这就令人费解了。而且更令我惊讶的是,我试了一些以前编写的其他项目里程序,都可以完全正常的运行。

        在不知所措的情况下,我重启了我的电脑,然而重启之后这个程序依然运行不下去,依然是得到上面的结果。而我之前编写的其他项目程序依然可以运行。但在我新建的这个项目里面,我甚至连一个“hello world”都运行不了,仍然得到上面的“Process returned 4258096”,而这个错误代码根本也搜索不到。

        在重启电脑也不能解决问题的情况下,我怀疑我的CodeBlocks软件本身有问题,于是立刻卸载重装。然而重装之后,该程序依然不能运行。

        我居然连一个“hello world”都无法运行了?虽然是一个初学者,但我觉得我不能连这样一个问题都解决不掉。

        我认为,我的突破口在于我之前编写的其他项目代码仍然可用,我只有从这个“不能运行的代码”和我之前编写的“可用的代码”之间找出区别,才能找到解决问题的方法。事实上,确实也是如此。

        仔细排查了从“创建新项目”到“代码编译运行”的所有流程,我发现,这次编写的内容,除了项目名称之外,没有任何设置上的区别,因此我认为问题很大程度上是出在新创建的项目的名称上的。于是我又新创建了好几个“C++ console”项目,例如“forupdatetest.cbp”以及“for_test.cbp”和“fccc.cbp”等,然后把相同代码粘贴到它们的main()函数中进行编译运行,结果发现,“forupdatetest.cbp”项目也出现了不能运行的情况,而“for_test.cbp”和“fccc.cbp”则可以运行。

        这激起了我强烈的兴趣。难道一个项目文件名就可以影响代码的运行?!

        为了了解更多细节,我关闭了CodeBlocks软件界面,打开储存文件的路径检查文件,结果确实发现了一些线索。

        “for_update_test.cbp”所生成的.exe可执行文件居然是带有“护盾”标识的文件!

        反观“for_test.cbp”所生成的.exe可执行文件,就没有这样的标识。

        试着点开这个带“护盾”的可执行文件,会出现特殊的效果,即“是否允许更改”等字样,可以选择“是”来执行这个程序。

        之后,就出现了正常该执行该代码的结果,如下:

        之后还会弹出如下所示的一个窗口:

        我隐隐约约感觉到这个可执行文件的不寻常,感觉它有点像一些Windows系统自带的文件。我猜测,也许是“update”这个词命中了Windows系统的一些检测机制。也许,整个问题,就出在这个文件当中包含这个“update”词汇上。

        为此,我建立了一些新的包含“update”字眼的C++ console 项目文件来测试它们生成的可执行文件是否会出现特殊效果。结果确实如我所想。

       

        凡是“显式”或者“隐式”包含“update”字样的C++ console项目,都会生成带有“护盾”标志的可执行文件,且它们在CodeBlocks环境中都是可以正常编译,但无法正常运行的。因此我推测,CodeBlocks环境运行已经编译的代码时,其实也是在间接调用由该项目生成的可执行文件,而一旦这个可执行文件带有“护盾”,即需要更多权限才能打开时,CodeBlocks环境就无法正常运行这个程序。

        与之形成对比的是不带有“update”字样或者错误拼写“update”字样的项目文件,都不会生成带有“护盾”的可执行文件。

        这说明了什么?

        我的推断是:Windows系统会自动识别显式或者隐式带有“update”字眼的可执行文件,并在用户运行该文件前进行询问,目的可能是保护系统或者其他我所不了解的功能。而我这次恰好由于建立了带有“update”字眼的项目并生成了带有“update”字眼的可执行文件,导致了CodeBlocks环境无法正常运行编译好的程序。

        这次意外导致我花费了几个小时去排查问题,过程很崩溃、很郁闷,但结果还算比较圆满。虽然没能彻底弄清楚里面的机制,但至少明白了一点,就是“给项目命名时绝对不要出现‘update’字眼”,因为这样会让计算机自动生成带有“护盾”的可执行程序(经调查,这个“护盾”功能是系统生成的防止其他软件未经授权自动运行的),会导致后期的运行时出现一些小问题。

        通过这次经历,我深深体会到,我们学习编程,除了了解代码的写法,更应该增加对计算机本身的了解。毕竟计算机是一个我们出生之前几十年就被发明出来的一种设备,其中绝大部分结构和功能对我们来说都是“黑箱系统”,是只可以见其运行结果而不可见其运行过程的。

        我觉得,如果希望能够更好地利用这个博大精深的工具,那么最好的办法就是了解它的内部设计,让这个“黑箱系统”变成“灰箱系统”,甚至“白箱系统”。只有在“知己知彼”的情况下,才能让我们设计的程序发挥出它最好的效果,实现“计算机为人服务”的最终目的。

    展开全文
  • windows 支持特殊符号做名字

    千次阅读 2018-03-05 17:21:01
    原则上可以利用键盘输入英文字母、符号、空格、中文等均可以作为合法字符,但由于以下字符由系统保留它用,因此能用在文件命名中: : / \ ? * “ &lt; &gt; | 注:此外,如果空格用在文件名的...
    
    原则上可以利用键盘输入的英文字母、符号、空格、中文等均可以作为合法字符,但由于以下字符由系统保留它用,因此不能用在文件命名中:
    :   /  \  ?  *  “  <  >  | 
    注:此外,如果空格用在文件名的第一个字符,则忽略不计。
    展开全文
  • Java语言规定标识符由任意顺序字母、下划线(_)、美元符号($)和数字组成,并且第一个字符能是数字。标识符能是Java中保留关键字。下面是合法标识符:nameuser_age$page下面是非法标识符:4wordStringUser nam...

    一、变量与常量

    1、标识符与关键字

    (1). 标识符

    标识符可以简单的理解为一个名字,用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。如图所示。

    876a01ebe472e06b2f7fc47611852419.png

    Java语言规定标识符由任意顺序的字母、下划线(_)、美元符号($)和数字组成,并且第一个字符不能是数字。标识符不能是Java中的保留关键字。

    下面是合法标识符:

    name

    user_age

    $page

    下面是非法标识符:

    4word

    String

    User name

    Java语言使用Unicode标准字符集,最多可以标识65535个字符,因此,Java语言中的字母不仅包括通常的拉丁文字a、b、c等,还包括汉字、日文以及其他许多语言中的文字。

    4f96447c8ad5a5d6b53e0dac4798df9a.png注意:在Java语言中标识符中的字母是严格区分大小写的。如good和Good是不同的两个标识符。

    (2).关键字

    关键字是Java语言中已经被赋予特定意义的一些单词。不可以把这些字作为标识符来使用。数据类型中提到的int、boolean等都是关键字,Java中的关键字如表所示:

    6b8786e1ba695d9f8535cc9528130ba6.png

    2、 定义变量

    变量可以理解为日常生活中的一个容器,例如箱子,它可以装衣服、金银首饰、图书、旅行用品等,关键时刻还可以藏人,总之变量的内容是可以改变的。变量的使用是程序设计中一个十分重要的环节,经常被使用,例如,如图所示。

    2c770852004a8e246624bae5d7bf9e0e.png

    为什么要定义变量呢?简单的说,就是要告诉编译器(compiler)这个变量是属于哪一种数据类型,这样编译器才知道需要配置多少空间给它,以及它能存放什么样的数据。在程序运行过程中,空间内的值是变化的,所以称为变量。为了便于操作,给这个空间取个名字,称为变量名,内存空间内的值就是变量值。

    变量的命名必须是合法的标识符。在声明变量时可以不为其赋值,也可以直接赋初值。

    例 声明变量,实例代码如下:

    int age;                                          //声明int型变量

    char char1 = 'r';                        //声明char型变量并赋值

    编写以上程序代码,究竟会产生什么样的作用呢?要了解这个问题,就需要对变量的内存配置有一定的认识。用图解的方式,将上例程序代码在内存中的状况表现出来。

    45089d94ce1ab8736322a81f9f60ab94.png

    系统的内存可大略的分为3个区域:系统区(OS)、程序区(Program)、数据区(Data)。当程序执行时,程序代码会加载到内存中的程序区,数据暂时存储在数据区中。假设上述两个变量定义在方法体中,则程序加载到程序区中。当执行此行程序代码时,会在数据区配置空间给这两个变量

    对于变量的命名并不是任意的,应遵循以下几条规则。

    1、变量名必须是一个有效的标识符。

    2、变量名不可以使用Java中的关键字。

    3、变量名不能重复。

    4、应选择有意义的单词作为变量名。

    c15991564c09dcc7128ec09586ee97a5.png说明:在Java语言中允许使用汉字或其他语言文字作为变量名。如“int 年龄 = 21”,在程序运行时并不出现什么错误,但建议读者尽量不要使用这些语言文字作为变量名。

    3、申明常量

    在程序运行过程中一直不会改变的量称为常量(constant),通常也被称为“final变量”。常量在整个程序中只能被赋值一次。在为所有对象共享值时,常量是非常有用的。

    在Java语言中声明一个常量,除了要指定数据类型外,还需要通过final关键字进行限定。声明常量的标准语法为:

    final 数据类型 常量名称[=值]

    0bf9a2b73f55ec11dc0a28c2a19d319f.png说明:常量名通常使用大写字母,这也符合Java编码规范,但这并不是必须的,声明常量时,完全可以和变量名一样使用小写字母。但是,那样容易造成混淆,降低代码可读性,所以才有规范要求常量名全部大写,并使用“_”下划线字符分割多个单词。

    例 声明常量,实例代码如下:

    final double PI = 3.1415926D;    //声明double型常量PI并赋值

    final boolean BOOL = true;       //声明boolean型常量BOOL并赋值

    当定义的final变量属于“成员变量”,则必须在定义的时候就设定它的初值。否则将会有编译错误。下面的实例可看出变量与常量的区别。

    例 在项目中创建类Part,在类体中创建变量age与常量PI。在主方法中分别将变量与常量赋值,通过输出信息可测试变量与常量的有效范围。

    1 public class Part { //新建类Part

    2

    3 static final double PI = 3.14; //声明常量PI,此时PI如不对其进行赋值,则会出现错误提示

    7 static int age = 23; //声明int型变量age,并进行赋值

    8

    9 public static void main(String[] args) { //主方法

    11 final int number; //声明int型常量number

    12 number = 1235; //对常量进行赋值

    15 age = 22; //再次对变量进行赋值16 //number = 1236;//错误的代码,因为number为常量,只能进行一次赋值

    18 System.out.println("常量PI的值为:" + PI); //将PI的值输出

    20 System.out.println("赋值后number的值为:" + number); //将number的值输出

    22 System.out.println("int型变量age的值为:" + age); //将age的值输出

    25 }

    27 }

    运行结果如图所示。

    2afce3fd031479f469c8c6908040157f.png

    4、变量的有效范围

    由于变量被定义出来后,只是暂存在内存中,等到程序执行到某一个点后,该变量会被释放掉,也就是说变量有它的生命周期。因此变量的有效范围是指程序代码能够访问该变量的区域,若超出该区域访问变量则编译时会出现错误。在程序中,一般会根据变量的有效范围,将变量分为“成员变量”和“局部变量”。

    (1).成员变量

    在类体中所定义的变量被称为成员变量。成员变量在整个类中都有效,所以成员变量也称作全局变量。

    成员变量的有效范围是整个类的代码段,也就是在类体中的任何位置都可以使用该变量。

    例 声明成员变量,并在不同方法中为成员变量赋值,代码如下:

    1 public classTemp {

    3 int num=0;

    5 float price=3.50f;

    7 public void method1(){ //方法1访问变量num和price

    9 num=1;

    11 price=12.55f;

    13 }14

    15 public void method2(){ //方法2也可以访问变量num和price

    17 num=num*10;

    19 price=price*0.5f;

    21 }

    23 }

    类的成员变量又可分为静态变量和实例变量两种。

    (1)、静态变量

    静态变量的有效范围是整个类,并且可以被类的所有实例共享。可通过“类名.静态变量名”的方式来访问静态变量。静态变量的生命周期取决于类的生命周期,当类被加载时,为类中的静态变量分配内存空间,当卸载类时,释放静态变量占用的空间,静态变量被销毁。类加载时,就为静态变量分配内存空间,之后无论创建了多少类的实例,都不会再为静态变量分配内存空间,这些实例会使用同一个静态变量。

    (2)、实例变量

    实例变量与类的实例对应,它的有效范围是整个实例。每创建一个类的实例,都会为当前实例分配实例变量的内存空间。所以实例变量的生命周期取决于实例的生命周期,实例被创建时,为实例变量分配内存空间,当销毁实例时,释放实例变量占用的内存空间。

    例 声明静态变量和实例变量,实例代码如下:

    public class Temp {

    int x = 45; //定义实例变量

    static int y = 90; //定义静态变量

    }

    2.局部变量

    在方法体中定义的变量就是一种局部变量,局部变量只在当前代码块(即花括号之内)中有效。局部变量的生命周期取决于声明位置的代码块,超出这个代码块的范围就不能在使用代码块内的局部变量。

    就拿方法类说,方法内声明的变量、包括参数变量都属于局部变量,当方法被调用时,Java虚拟机为方法中的局部变量分配内存空间,当该方法的调用结束后,则会释放方法中局部变量占用的内存空间,局部变量也将会销毁,然后Java的垃圾回收机制会在某一时刻清理该内存空间。

    变量的有效范围如图所示:

    b5684dfb58def92dfcc09fb9f746b102.png

    db4fe5021b48d5da0a5d38d70b5ac4fd.png说明:局部变量可与全局变量的名字相同,此时全局变量将被隐藏,但是可以使用“this.”做前缀来访问全局变量。

    例 在项目中创建类ValClass,分别定义名称相同的局部变量与成员变量,当名称相同时成员变量将被隐藏。

    1 public class ValClass{ //新建类

    2 static String words = "成员变量"; //定义成员变量words

    3

    4 public static void main(String[] args) { //主方法

    5 String words = "局部变量"; //定义局部变量words

    6 System.out.println("words变量现在是:" + words); //将words的值输出

    7 }8 }

    运行结果如图所示。

    4ccf9c399edd47e1ba443c1f729ca3a5.png

    二、运算符

    1、赋值运算符

    赋值运算符是以符号“=”表示,它是一个二元运算符(对两个操作数作处理),其功能是将右方操作数所含的值赋值给左方的操作数。其语法格式如下:

    变量 = 表达式;

    例如:

    int a = 100;

    该表达式是将100赋值给变量a。左方的操作数必须是一个变量,而右边的操作数则可以是任何表达式,包括变量(如a、number)、常量(如123、'book')、有效的表达式(如45*12)。例如:

    例 使用赋值运算符为变量赋值,实例代码如下:

    int a = 10; //声明int型变量a

    int b = 5; //声明int型变量b

    int c = a+b; //将变量a与b进行运算后的结果赋值给c

    遵循赋值运算符的运算规则,可知系统将先计算a+b的值,结果为15。然后将15赋值给变量c。因此“c=15”。

    ebed6213950234c6780611bf3e0536d6.png说明:由于赋值运算符“=”处理时会先取得右方表达式处理后的结果,因此一个表达式中若含有两个以上的“=”运算符时,会从最右方“=”开始处理。

    例 在项目中创建类Eval,在主方法中定义变量,使用赋值运算符为变量赋值。

    1 public class Eval { //创建类

    2 public static void main(String[] args) { //主方法

    3 int a, b, c; //声明int行变量a,b,c

    5 a = 15; //将15赋值给变量a

    7 c = b = a + 4; //将a与4的和赋值给变量b,然后再赋值给变量c

    9 System.out.println("c值为:" + c); //将变量c的值输出

    11 System.out.println("b值为:" + b); //将变量b的值输出

    13 }

    16 }

    运行结果如图所示。

    d787b2252870475b5e238e0dea697f4a.png

    c88d2b9042399e3d666ed8e5f83ba329.png说明:在Java里可以把赋值运算符连在一起使用。如:

    x = y = z = 5;

    在这个语句中,变量x、y、z 都得到同样的值5,在程序开发中不建议使用这种赋值语法。

    再例如,在下面的a=a+10表达式中,先计算表达式a+10,结果为19,然后执行表达式a=19。

    int a=9;

    a=a+10;

    System.out.println(a);

    在Java中,类似a=a+10这样的表达式还可写为以下形式:

    a+=10;

    其中,+=称为复合赋值运算符,类似的复值运算符还有-=、*=、/=、%=、&=、|=和^=等。对于这些运算符的具体应用如表所示。

    03a243dea99c0a4f43280c6cd7eb98e0.png

    9217c518a4326c4d9137f6c2dfca2c97.png说明:赋值运算符的左边必须为变量,不能为任何表达式。

    2、算数运算符

    Java中的算术运算符主要有+(加号)、—(减号)、*(乘号)、/(除号)、%(求余),它们都是二元运算符。Java中算术运算符的功能及使用方式如表所示。

    3e2b90456c2dc3ca1ebc043f9a18a634.png

    其中“+”和“-”运算符还可以作为数据的正负符号,例如+5,-7。

    下面通过一个小程序来介绍使用算术运算符的方法。

    例 在项目中创建类Arith,在主方法中定义变量,使用算术运算符将变量的计算结果输出。

    1 public class Arith { //创建类

    2

    3 public static void main(String[] args) { //主方法

    4 float number1 = 45.56f; //声明float型变量并赋值

    6 int number2 = 152; //声明int型变量并赋值

    8 System.out.println("和为:" + number1 + number2); //将变量相加之和输出

    10 System.out.println("差为:" + (number2 - number1)); //将变量相减之差输出

    12 System.out.println("积为:" + number1 * number2); //将变量相乘的积输出

    14 System.out.println("商为:" + number1 / number2); //将变量相除的商输出

    16 }

    19 }

    运行结果如图所示。

    bbe8bd140557fab8ceaab776f13550c3.png

    在应用算术运算符时,可以分为对整型数据的运算和对浮点型数据的运算,下面进行详细介绍。

    1.整型数据的算术运算

    整型数据的“+”、“-”、“*”、的运算与数学中的运算相同,这里不再介绍,下面介绍整型数据间的“/”和“%”运算。

    (1)整数的除法(运算符“/”)运算

    当整数间进行除法运算时,其结果将舍弃小数部分,并且忽略四舍五入,最终的结果为商的整数部分,所以通过计算机来计算“5/3*3”与“5*3/3”的结果是不同的,前者为3,而后者为5。

    例 在项目中创建类Arith1,在主方法中定义变量,使用“/”运算符进行除法运算,并输出计算结果。

    1 public classArith1 {2

    3 public static void main(String[] args) { //主方法

    4 int i1 = 7 / 3; //在数学计算中其结果约为2.33

    6 int i2 = 11 / 3; //在数学计算中其结果约为3.67

    8 int i3 = -7 / 2; //在数学计算中其结果为-3.5

    10 int i4 = 0 / 9;12 System.out.println("7/3=" + i1); //输出结果为:2

    14 System.out.println("11/3=" + i2); //输出结果为:3

    16 System.out.println("-7/2=" + i3); //输出结果为:-3

    18 System.out.println("0/9=" + i4); //输出结果为:0

    21 }

    23 }

    运行结果如图所示。

    ebddee6d36fa704b83f1fddceb6e7647.png

    (2)整数的求余(运算符“%”)运算

    当整数间进行求余运算时,其运算结果为整数除法运算后的余数。

    例 在项目中创建类Arith2,在主方法中定义变量,使用“%”运算符进行求余运算,并输出计算结果。

    public classArith2 {public static void main(String[] args) { //主方法

    int i1=11%4; //结果为:3

    int i2=8%4; //结果为:0

    int i3=9%10; //结果为:9

    int i4=-7%3; //结果为:-1

    int i5=0%9; //结果为:0

    System.out.println("11%4="+i1);

    System.out.println("8%4="+i2);

    System.out.println("9%10="+i3);

    System.out.println("-7%3="+i4);

    System.out.println("0%9="+i5);

    }

    }

    运行结果如图所示。

    9c71601223c6a6524d42b6c9d2417a25.png

    3、自增和自减运算符

    自增、自减运算符是单目运算符,可以放在操作元之前,也可以放在操作元之后。操作元必须是一个整型或浮点型变量。自增、自减运算符的作用是使变量的值增1或减1。放在操作元前面的自增、自减运算符,会先将变量的值加1(减1),然后再使该变量参与表达式的运算。放在操作元后面的自增、自减运算符,会先使变量参与表达式的运算,然后再将该变量加1(减1)。

    例 应用两种自增运算符的输出结果。下面的代码:

    int i=1;

    System.out.println("使用i++的结果:");

    System.out.println(i++);

    System.out.println(i);

    i=1;

    System.out.println("使用++i的结果:");

    System.out.println(++i);

    System.out.println(i);

    运行结果如图所示。

    3838391bf9417c3447383079856f04f6.png

    下面我们通过图来看一看i++与++i的区别。

    a869de2b94d9f21df8cfff1e08644625.png

    例 应用两种自减运算符的输出结果。下面的代码:

    int i=1;

    System.out.println("使用i--的结果:");

    System.out.println(i--);

    System.out.println(i);

    i=1;

    System.out.println("使用--i的结果:");

    System.out.println(--i);

    System.out.println(i);

    运行结果如图所示。

    771da4adf4319edf76ca6125e3983484.png

    de1544ff6aaada86ff13246d31209452.png注意:自动递增、递减运算符的操作元只能为变量,不能为字面常数和表达式,且该变量类型必须为整型、浮点型或Java包装类型。例如:++1、(num+2)++都是不合法的。

    4、比较运算符

    比较运算符属于二元运算符,用于程序里的变量之间、变量和自变量之间以及其他类型的信息之间的比较上。比较运算符的运算结果是boolean型。当运算符对应的关系成立时,运算结果是true,否则是false。所有比较运算符通常用在条件语句中作为判断的依据。比较运算符共有6个,如表所示

    运算符

    作用

    举例

    操作数据

    结果

    >

    比较左方是否大于右方

    'a'>'b'

    整型、浮点型、字符型

    false

    <

    比较左方是否小于右方

    156 < 456

    整型、浮点型、字符型

    false

    ==

    比较左方是否等于右方

    'c'=='c'

    基本数据类型、引用型

    true

    >=

    比较左方是否大于等于右方

    479>=426

    整型、浮点型、字符型

    True

    <=

    比较左方是否小于等于右方

    12.45<=45.5

    整型、浮点型、字符型

    true

    !=

    比较左方是否不等于右方

    'y'!='t'

    基本数据类型、引用型

    true

    6d1e812b121b92ed00d371b5548369c5.png注意:相等“==”运算符和“=”赋值运算符要严格区分,不要混淆,如果在条件判断语句中,把“==”写成“=”会导致错误发生。这是初学者最容易犯错的地方,可以把常量放置“==”的左面,右面放变量或其它。例如if(3 == x),这也是一些程序开发人员的惯用写法,这样做,“==”错写为“=”时,编译器会报告错误。

    例 在项目中创建类Compare,在主方法中创建整型变量,使用比较运算符对变量进行比较运算,将运算后的结果输出。

    public class Compare { //创建类

    public static voidmain(String[] args) {int number1 = 4; //声明int型变量number1

    int number2 = 5; //声明int型变量number2

    System.out.println("number1 > number2的返回值为:" + (number1 >number2));/*依次将变量number1与变量number2的比较结果输出*/System.out.println("number1 < number2的返回值为:" + (number1

    System.out.println("number1 == number2的返回值为:" + (number1 ==number2));

    System.out.println("number1 != number2的返回值为:" + (number1 !=number2));

    System.out.println("number1 >= number2的返回值为:" + (number1 >=number2));

    System.out.println("number1 <= number2的返回值为:" + (number1 <=number2));

    }

    }

    4ae0813382bd4a073541960ecfd0d804.png

    5、逻辑运算符

    返回类型为布尔值的表达式,比如比较运算符。可以被组合在一起构成一个更复杂的表达式。这是通过逻辑运算符来实现的。逻辑运算符包括&(&&)逻辑与、||(逻辑或)、!(逻辑非)。逻辑运算符的操作元必须是boolean型数据。在逻辑运算符中,除了“!”是一元运算符之外,其他都是二元运算符。表给出逻辑运算符的用法和含义。

    运算符

    含义

    用法

    结合方向

    &&、&

    逻辑与

    op1&&op2

    左到右

    ||

    逻辑或

    op1||op2

    左到右

    逻辑非

    !op

    右到左

    结果为boolean型的变量或表达式可以通过逻辑运算符组合为逻辑表达式。

    用逻辑运算符进行逻辑运算时,结果如表所示。

    表达式1

    表达式2

    表达式1&&表达式2

    表达式1||表达式2

    !表达式1

    true

    true

    true

    true

    false

    true

    false

    false

    true

    False

    false

    false

    false

    false

    True

    false

    true

    false

    true

    true

    逻辑运算符“&&”和“&”都是表示逻辑与,那么他们之间的区别在哪里呢?从表可以看出当两个表达式都为true时,逻辑与的结果才会是true。使用逻辑运算符“&”会判断两个表达式。而逻辑运算符“&&”则是针对boolean类型类进行判断,当第一个表达式为false时,则不去判断第二个表达式,直接输出结果。使用“&&”可节省计算机判断的次数。通常将这种在逻辑表达式中从左端的表达式可推断出整个表达式的值称为“短路”。而那些始终执行逻辑运算符两边的表达式称为“非短路”。“&&”属于“短路”运算符,而“&”则属于“非短路”运算符。

    例 在项目中创建类Calculation,在主方法中创建整型变量,使用逻辑运算符对变量进行运算,将运算结果输出。

    public class Calculation { //创建类

    public static voidmain(String[] args) {int a = 2; //声明int型变量a

    int b = 5; //声明int型变量b

    boolean result = ((a > b) && (a != b)); //逻辑与&&运算

    boolean result2 = ((a > b) || (a != b)); //逻辑或||运算

    System.out.println("(2 > 5) && (2 != 5) = "+result); //变量result输出

    System.out.println("(2 > 5) || (2 != 5) = "+result2); //变量result2输出

    System.out.println("!(5 > 2) = " +!(5 > 2)); //逻辑非!运算}

    }

    bf7fc5db7f8f44585741c5ba2c567320.png

    6、位运算符

    位运算符用于处理整形和字符型的操作数。位运算是完全针对二进制位(bit)单位的操作。Java语言提供的位运算符如表所示。

    运算符

    用法

    含义

    运算分类

    ~ 非

    ~op1

    对op1操作数按位取反

    按位运算

    & 与

    op1 & op2

    op1和op2按位相与

    | 或

    op1 | op2

    op1和op2按位相或

    ^ 异或

    op1 ^ op2

    op1和op2按位异或

    << 左移位

    op1 << op2

    op1按位左移op2次

    移位运算符

    >> 右移位

    op1 >> op2

    op2按位右移op2次

    >>> 无符号右移位

    op1 >>> op2

    op2不带符号按位右移op2次

    2433288b6372054abd69069aefd4a8e7.png说明:Java的位运算符中,“~”非运算是一元运算符,除此之外的都是二元运算符。

    1.“按位与”运算

    “按位与”运算的运算符为“&”,&是二元运算符。“按位与”运算的运算法则是:如果两个整型数据a、b对应位都是1,则该位结果才是1,否则为0。即

    0&0=0                        0&1=0                        1&0=0                        1&1=1

    例如:153的二进制是10011001,46的二进制是00101110,这两个数按位与运算的方法如下,括号中的是十进制数。

    10011001(153)

    &            00101110(46)

    ---------------------------------

    00001000(8)

    2.“按位或”运算

    “按位或”运算的运算符为“|”,它是二元运算符。“按位或”运算的运算法则是:如果两个操作数对应位都是0,则该位的结果才是0,否则为1。即

    0|0=0                        0|1=1                        1|0=1                        1|1=1

    例如:153的二进制是10011001,46的二进制是00101110,这两个数按位进行或运算的方法如下,括号中的是十进制数。

    10011001(153)

    |            00101110(46)

    ---------------------------------

    10111111            (191)

    3.“按位取反”运算

    “按位取反”运算也称“按位非”运算,运算符为“~”,~为一元运算符。它的运算法则是操作数二进制中的1修改为0,0修改为1。即

    ~0=1                        ~1=0

    例如:153的二进制是10011001,把它按位取反的结果为01100110

    4.“按位异或”运算

    “按位异或”运算的运算符位“^”,^为二元运算符。“按位异或”运算的运算法则是:当两个操作数的二进制对应位相同(同时为0或同时为1)时,结果为0,否则为1。即

    0^0=0                        0^1=1                        1^0=1                        1^1=0

    例如:153的二进制是10011001,46的二进制是00101110,这两个数按位进行异或运算的方法如下,括号中的是十进制数。

    10011001(153)

    ^            00101110(46)

    ---------------------------------

    10110111(183)

    5.位移运算

    除了上述按位运算符之外,还可以对数据按二进制位进行移位操作,Java中的移位运算符有三种:

    q << 左移

    q >> 右移

    q >>> 无符号右移

    左移就是将左边的操作数在内存中的二进制数据左移右边操作数指定的位数,左边移空的部分补0。右移则复杂一些。当使用“>>”符号时,如果最高位是0,左移空的位就填入0;如果最高位是1,右移空的位就填入1。如图所示。

    9ff430cae97f37b09a0f4061ae6c58b9.png

    Java还提供了无符号右移“>>>”,不管最高位是0还是1,左移空的高位都添入0。

    680c74a10598149d5ea0964c8b6ce90c.png注意:移位运算符适用的数据类型有byte、short、char、int、long。

    52ad67658a4a16342c61979734563ac7.png技巧:移位能让我们实现整数除以或乘以2的n次方的效果,如:y<<2于y*4的结果相同;y>>1的结果于y/2的结果相同。总之,一个数左移n位,就是将这个数乘以2的n次方,一个数右移n位,就是将这个数除以2的n次方。

    7、三元运算符

    三元运算符使用格式为:

    条件式?值1:值2

    三元运算符的运算规则为:若条件式的值为true,则整个表达式取值1,否则取值2。例如:

    int x = 1;

    int y = 2;

    int num = x < y ? 10 : 20;

    如上例所示,当表达式“x < y”的运算结果返回true时,则变量num取值10,当表达式“x < y”返回false时,则变量num取值20。上例的结果为num等于10。

    例 使用三元运算符求两数中的最大数。

    public classComputeMax {public static voidmain(String[] args) {int x=32; //声明变量x

    int y=23; //声明变量y

    int max=x>y?x:y; //声明变量max并赋值x与y的最大数

    System.out.println("x="+x); //输出x的值

    System.out.println("y="+y); //输出y的值

    System.out.println("x、y两数中最大的值为:"+max);

    }

    }

    af8d66bb14f59fb066baa1734d001428.png

    8、运算符优先级

    Java中的表达式就是使用运算符连接起来的符合Java规则的式子。运算符的优先级决定了表达式中运算执行的先后顺序。通常优先级由高到低的顺序依次是:

    (1) 增量和减量运算

    (2) 算术运算

    (3)比较运算

    (4) 逻辑运算

    (5)赋值运算

    如果两个运算有相同的优先级,那么在左边的表达式要比在右边的表达式先被处理。表显示了在Java里众多运算符的特定的优先级。

    优先级

    描述

    运算符

    0602c89133b44d52682575eba105a7eb.png

    括号

    ( )

    正负号

    + -

    一元运算符

    ++ -- !

    乘除

    * / %

    加减

    + -

    移位运算

    << >> >>>

    比较大小

    < > >= <=

    比较是否相等

    == !=

    按位与运算

    &

    按位异或运算

    ^

    按位或运算

    |

    逻辑与运算

    &&

    逻辑或运算

    ||

    三元运算符

    ?:

    赋值运算符

    = += -= *= /= %=

    7a985dd6d2b331fc97161860312d394a.png技巧:在编写程序时尽量使用括号()运算符号来限定运算次序,以免产生错误的运算顺序。

    三、数据类型转换

    1、自动类型转化

    Java的8个基本数据类型可以进行混合运算。不同类型的数据在运算过程中,首先会自动转换为同一类型,然后才进行运算。数据类型可以根据占用存储空间大小分为高低级别,占用空间越小,级别越低,占用空间越大,级别越高。自动类型转换遵循低级到高级转换的规则。如图所示。从左到右的数据类型不断升高,箭头指明了自动类型转换的规则。

    238610e097f304a30fb131faa5be364e.png

    基本数据类型的自动类型转换会发生在以下几种情况:

    (1)变量赋值

    当为变量赋值的数据类型与变量类型不一致,并且赋值的数据类型级别低于变量类型的级别时,自动数据类型转换会将赋值数据自动转换为变量的类型。

    例如:

    byte byteNum=23; // 声明byte类型变量

    int intNum=byteNum; // 把byte型数据赋值给int型变量

    (2)方法调用

    把一个数值传递给方法的参数,并且这个数值的数据类型低于方法的参数变量的数据类型。

    例如:

    public static void say(intnum){

    System.out.println("这是int类型数值:"+num);

    }public static voidmain(String[] args) {byte byteNum=23;

    say(byteNum);//把byte数值传递给方法的int参数}

    一元运算

    在一元运算中(除了++和—运算符),如果操作数的类型低于int类型(即byte、short和char类型),则操作数会自动转换为int类型。

    二元运算符

    在二元运算中,所有低级的数据类型都会转换为运算中级别最高的数据类型。也就是说,如果有一个操作数是double类型,其他操作数都会自动转换为double类型。如果运算中最高的数据类型是float,其他操作数都会转换为float类型。如果最高的数据类型为long,那么所有操作数都会自动转换为long类型。如果最高的数据类型为int那么所有操作数都会自动转换成int类型。至于byte、short、char类型会自动转换为int或运算中最高的数据类型。

    例 在项目中创建类Conversion,在主方法中创建不同数值型的变量,实现将各变量的自动类型转换。

    public classConversion {public static voidmain(String[] args) {byte b1=34;short s1=123;char c1='B';int i1=40;long l1=900L;float f1=8.11F;double d1=3.1415926;

    System.out.println("double/byte+char->double\t"+(d1/b1+c1));

    System.out.println("long+short->long\t\t"+(l1+s1));

    System.out.println("char+byte+short->int\t\t"+(c1+b1+s1));

    System.out.println("float+b1/s1->float\t\t"+(f1+b1/s1));

    System.out.println("int+double->double\t\t"+(i1+d1));

    }

    }

    运行的结果如图所示:

    83a2c0cffb3e6a4fd1603aa461d704dd.png

    8bbeab097e1bf17db14ad5f2a4d4990e.png技巧:要理解类型转换,大家可以这么想象,大脑前面是一片内存,源和目标分别是两个大小不同的内存块(由变量及数据的类型来决定),将源数据赋值给目标内存的过程,就是用目标内存块去套取源内存中的数据,能套多少算多少。

    2、强制类型转换

    当把高级别(即占用存储空间较大)的数据类型赋值给低级别(即占用存储空间较小)的数据类型时,必须进行的强制类型转换。其语法格式如下:

    (类型)(表达式)

    类型是要转换成的目标类型,例如int、short、double等。表达式是要转换的目标数据,它可以是任何基本类型的算术运算表达式。

    例如:

    long num=900L; // 900

    short snum=(short)num; // 900

    long类型的数值900没有超过short类型的取值范围,所以short类型的变量“snum”完全容纳了强制类型转换后的数值。

    基本数据类型的强制类型转换需要注意数据完整性的问题,当把高级的数据类型强制转换为低级的数据类型时,如果数值超出低级数据类型的取值范围,数值将被截取,导致数据丢失、不完整。

    例如:

    short snum=516; // 516

    byte bnum=(byte)snum; // 4

    snum是short类型,数据长度是16位,而bnum是byte类型,长度为8位。当snum强制转换为byte类型时,数值“516”超出了byte类型的取值范围,这是只能从short类型截取低8为的数据赋值给byte类型的bnum变量。如图所示。

    b9ac8cde8a94569ad20f8e9de3bbbcd7.png

    这样就造成了数据丢失,所以在使用强制数据类型转换时,一定要倍加小心。

    c9d3ac812b32a3e23d4df1a4bcc8dfbe.png注意:boolean布尔型的数值不能被牵制类型转换为其他数据类型,反之亦然。

    例 将long类型数值强制类型转换为其他数据类型

    public classPConversion {public static voidmain(String[] args) {long num=33333;

    System.out.println("原数是:"+num);

    System.out.println("转成int:"+(int)num);

    System.out.println("转成short:"+(short)num);

    System.out.println("转成byte:"+(byte)num);

    System.out.println("转成float:"+(float)num);

    System.out.println("转成char:"+(char)num);

    }

    }

    实例运行结果如图所示。

    ee780fb9ce67fdab3f09ecf1fe6e0fee.png

    展开全文
  • 展开全部如果VC编译器出现如此错误提示...直接从网上拷贝代码贴到Dev C++中会经常遇到 stray '\161' in program 错误,其实问题出在代码中掺入了一些不合法的空格(全角空格),把每行代码后...

    展开全部

    如果VC编译器出现如此错误提示32313133353236313431303231363533e78988e69d8331333339653665"stray '\161'in progtam",说明你用了全角符号的空格。

    直接从网上拷贝代码贴到Dev C++中会经常遇到 stray '\161' in program 错误,其实问题出在代码中掺入了一些不合法的空格(全角空格),把每行代码后的空格删掉即OK了!

    C语言错误对照表:

    1. Ambiguous operators need parentheses — 不明确的运算需要用括号括起

    2. Ambiguous symbol 'xxx' — 不明确的符号

    3. Argument list syntax error — 参数表语法错误

    4. Array bounds missing — 丢失数组界限符

    5. Array size toolarge — 数组尺寸太大

    6. Bad character in paramenters — 参数中有不适当的字符

    7. Bad file name format in include directive — 包含命令中文件名格式不正确

    8. Bad ifdef directive synatax — 编译预处理ifdef有语法错

    9. Bad undef directive syntax — 编译预处理undef有语法错

    10. Bit field too large — 位字段太长

    11. Call of non-function — 调用未定义的函数

    12. Call to function with no prototype — 调用函数时没有函数的说明

    13. Cannot modify a const object — 不允许修改常量对象

    14. Case outside of switch — 漏掉了case 语句

    15. Case syntax error — Case 语法错误

    16. Code has no effect — 代码不可能执行到

    17. Compound statement missing{ — 分程序漏掉"{"

    18. Conflicting type modifiers — 不明确的类型说明符

    19. Constant expression required — 要求常量表达式

    20. Constant out of range in comparison — 在比较中常量超出范围

    21. Conversion may lose significant digits — 转换时会丢失意义的数字

    22. Conversion of near pointer not allowed — 不允许转换近指针

    23. Could not find file 'xxx' — 找不到XXX文件

    24. Declaration missing ; — 说明缺少";"

    25. Declaration syntax error — 说明中出现语法错误

    26. Default outside of switch — Default 出现在switch语句之外

    27. Define directive needs an identifier — 定义编译预处理需要标识符

    28. Division by zero — 用零作除数

    29. Do statement must have while — Do-while语句中缺少while部分

    30. Enum syntax error — 枚举类型语法错误

    31. Enumeration constant syntax error — 枚举常数语法错误

    32. Error directive :xxx — 错误的编译预处理命令

    33. Error writing output file — 写输出文件错误

    34. Expression syntax error — 表达式语法错误

    35. Extra parameter in call — 调用时出现多余错误

    36. File name too long — 文件名太长

    37. Function call missing ) — 函数调用缺少右括号

    38. Fuction definition out of place — 函数定义位置错误

    39. Fuction should return a value — 函数必需返回一个值

    40. Goto statement missing label — Goto语句没有标号

    41. Hexadecimal or octal constant too large — 16进制或8进制常数太大

    42. Illegal character 'x' — 非法字符x

    43. Illegal initialization — 非法的初始化

    44. Illegal octal digit — 非法的8进制数字

    45. Illegal pointer subtraction — 非法的指针相减

    46. Illegal structure operation — 非法的结构体操作

    47. Illegal use of floating point — 非法的浮点运算

    48. Illegal use of pointer — 指针使用非法

    49. Improper use of a typedefsymbol — 类型定义符号使用不恰当

    50. In-line assembly not allowed — 不允许使用行间汇编

    51. Incompatible storage class — 存储类别不相容

    52. Incompatible type conversion — 不相容的类型转换

    53. Incorrect number format — 错误的数据格式

    54. Incorrect use of default — Default使用不当

    55. Invalid indirection — 无效的间接运算

    56. Invalid pointer addition — 指针相加无效

    57. Irreducible expression tree — 无法执行的表达式运算

    58. Lvalue required — 需要逻辑值0或非0值

    59. Macro argument syntax error — 宏参数语法错误

    60. Macro expansion too long — 宏的扩展以后太长

    61. Mismatched number of parameters in definition — 定义中参数个数不匹配

    62. Misplaced break — 此处不应出现break语句

    63. Misplaced continue — 此处不应出现continue语句

    64. Misplaced decimal point — 此处不应出现小数点

    65. Misplaced elif directive — 不应编译预处理elif

    66. Misplaced else — 此处不应出现else

    67. Misplaced else directive — 此处不应出现编译预处理else

    68. Misplaced endif directive — 此处不应出现编译预处理endif

    69. Must be addressable — 必须是可以编址的

    70. Must take address of memory location — 必须存储定位的地址

    71. No declaration for function 'xxx' — 没有函数xxx的说明

    72. No stack — 缺少堆栈

    73. No type information — 没有类型信息

    74. Non-portable pointer assignment — 不可移动的指针(地址常数)赋值

    75. Non-portable pointer comparison — 不可移动的指针(地址常数)比较

    76. Non-portable pointer conversion — 不可移动的指针(地址常数)转换

    77. Not a valid expression format type — 不合法的表达式格式

    78. Not an allowed type — 不允许使用的类型

    79. Numeric constant too large — 数值常太大

    80. Out of memory — 内存不够用

    81. Parameter 'xxx' is never used — 能数xxx没有用到

    82. Pointer required on left side of -> — 符号->的左边必须是指针

    83. Possible use of 'xxx' before definition — 在定义之前就使用了xxx(警告)

    84. Possibly incorrect assignment — 赋值可能不正确

    85. Redeclaration of 'xxx' — 重复定义了xxx

    86. Redefinition of 'xxx' is not identical — xxx的两次定义不一致

    87. Register allocation failure — 寄存器定址失败

    88. Repeat count needs an lvalue — 重复计数需要逻辑值

    89. Size of structure or array not known — 结构体或数给大小不确定

    90. Statement missing ; — 语句后缺少";"

    91. Structure or union syntax error — 结构体或联合体语法错误

    92. Structure size too large — 结构体尺寸太大

    93. Sub scripting missing ] — 下标缺少右方括号

    94. Superfluous & with function or array — 函数或数组中有多余的"&"

    95. Suspicious pointer conversion — 可疑的指针转换

    96. Symbol limit exceeded — 符号超限

    97. Too few parameters in call — 函数调用时的实参少于函数的参数不

    98. Too many default cases — Default太多(switch语句中一个)

    99. Too many error or warning messages — 错误或警告信息太多

    100. Too many type in declaration — 说明中类型太多

    101. Too much auto memory in function — 函数用到的局部存储太多

    102. Too much global data defined in file — 文件中全局数据太多

    103. Two consecutive dots — 两个连续的句点

    104. Type mismatch in parameter xxx — 参数xxx类型不匹配

    105. Type mismatch in redeclaration of 'xxx' — xxx重定义的类型不匹配

    106. Unable to create output file 'xxx' — 无法建立输出文件xxx

    107. Unable to open include file 'xxx' — 无法打开被包含的文件xxx

    108. Unable to open input file 'xxx' — 无法打开输入文件xxx

    109. Undefined label 'xxx' — 没有定义的标号xxx

    110. Undefined structure 'xxx' — 没有定义的结构xxx

    111. Undefined symbol 'xxx' — 没有定义的符号xxx

    112. Unexpected end of file in comment started on line xxx — 从xxx行开始的注解尚未结束文件不能结束

    113. Unexpected end of file in conditional started on line xxx — 从xxx 开始的条件语句尚未结束文件不能结束

    114. Unknown assemble instruction — 未知的汇编结构

    115. Unknown option — 未知的操作

    116. Unknown preprocessor directive: 'xxx' — 不认识的预处理命令xxx

    117. Unreachable code — 无路可达的代码

    118. Unterminated string or character constant — 字符串缺少引号

    119. User break — 用户强行中断了程序

    120. Void functions may not return a value — Void类型的函数不应有返回值

    121. Wrong number of arguments — 调用函数的参数数目错

    122. 'xxx' not an argument — xxx不是参数

    123. 'xxx' not part of structure — xxx不是结构体的一部分

    124. xxx statement missing ( — xxx语句缺少左括号

    125. xxx statement missing ) — xxx语句缺少右括号

    126. xxx statement missing ; — xxx缺少分号

    127. xxx' declared but never used — 说明了xxx但没有使用

    128. xxx' is assigned a value which is never used — 给xxx赋了值但未用过

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • c/c++中,是你用来标识变量名、符号常量名、函数名、数组名、文件名、类名、对象名等。(就好像你父母有了你以后给你起名字)~~ c/c++有效标识符构成规则如下 (1)第一个字符必须是字母(分大小写)或...
  • 变量:在程序的执行过程中,其值能被改变的量常量:在程序的执行过程中,其值能被改变的量标识符:用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。...合法的标识符比如:name、$age、max_time...
  • Java变量与常量的命名都必须使用合法的标识符。本节将向读者介绍标识符与关键字、变量与常量的命名。标识符和关键字标识符标识符可以简单地理解为一个名字,用来标识类名、变量名、方法名、数组名、文件名的有效字符...
  • 一个合法的标识符只能由:字母、数字、下划线、美元符 组成,能含有其他符号能以数字开头; 严格区分大小写; 关键字能做标识符; 理论上没有长度限制,但最好不要太长。 下面的标识...
  • 在编写python程序时应遵循一定规范,这里主要介绍一下python标识符命名规则,代码缩进和代码行过长时处理方式。1、python标识符命名规则(1)在python中...(3)python标识符中能有空格、标点符号;(4)p...
  • 如图1所示图1 Java文件中标识符和关键字Java语言规定标识符由任意顺序字母、下划线(_)、美元符号($)和数字组成,并且第一个字符能是数字。标识符能是Java中保留关键字。下面是合法标识 name user_age $...
  • 如图1所示图1 Java文件中标识符和关键字Java语言规定标识符由任意顺序字母、下划线(_)、美元符号($)和数字组成,并且第一个字符能是数字。标识符能是Java中保留关键字。下面是合法标识 name user_age $...
  • Java中变量与常量

    2021-02-01 12:53:59
    Java语言规定标识符由任意顺序字母、下划线(_)、美元符号($)和数字组成,并且第一个字符能是数字。标识符能是Java中保留关键字。 下面是合法标识符: name user_age $page 下面是非法标识符: 4word ...
  • Java语言标识符由字母、数字、下划线(_)、美元符号($)组成,第一个字符能为数字 合法标识符:tb_user、_u88 非法标识符:7word、5faxJava语言使用Unicode标准字符集,最多可识别65535个字符 标识符能为...
  • 1.标识符和关键字一个JAVA程序由类和对象组成,而类和对象又是由属性(通常是变量)和方法(通常是函数)等组成.1-1....合法性:标识符由字母、数字、下划线和美元符号组成,但是第一个字符能是数字开头....
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    这为什么是合法的C语言表达式呢? 数组的指针 6.12 既然数组引用会退化为指针,如果array是数组,那么array和&array又有什么区别呢? 6.13 如何声明一个数组的指针? 动态数组分配 6.14 如何在运行时设定...
  • 这样是合法的和可移植的吗? 23  2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明能这样做? 25 2.9 为什么能用内建的==和!=操作符比较结构? 26 2.10 结构传递和返回是如何实现...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    这样是合法的和可移植的吗? 23  2.8 我听说结构可以赋给变量也可以对函数传入和传出。为什么K&R1却明确说明能这样做? 25 2.9 为什么能用内建的==和!=操作符比较结构? 26 2.10 结构传递和返回是如何实现...
  • XYZ.C ┌──┴┬─┬───┐ QR.C NA.C A.TXT B.C 如果当前盘为C盘,A盘的当前目录为\D2,则下列对A盘上文件QR.C的指定中,合法的是 A)\D2\D4\QR.C B)D4\QR.C C)A:D4\QR.C D)A:D2\D4\QR.C C 2
  • 变量:在程序的执行过程中,其值能被改变的量常量:在程序的执行过程中,其值能被改变的量标识符:用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。...合法的标识符比如:name、$age、max_time...
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    2.17 有什么容易显示枚举值符号的方法? . . . . . . . . . . . . . . . 11 3 表达式13 3.1 为什么这样代码: a[i] = i++; 能工作? . . . . . . . . . . . . 13 3.2 使用我编译器,下面代码int i=7; printf...
  • 变量与常量的命名都必须使用合法的标识符。 标识符 标识符可以理解为一个名字,用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。Java语言规定标识符由任意顺序的字母、下划线(_)、美元符号($)和...
  • Java 变量与常量

    2018-10-28 23:17:40
    变量与常量的命名都必须使用合法的标识符。 标识符和关键字 标识符 标识符可以简单地理解为一个名字,用来标识类名、方法名、数组名、文件名的有效字符序列。 Java 语言规定标识符由任意顺序的字母、下划线、美元...
  • Java变量与常量

    2021-04-06 16:28:10
    变量与常量的命名都必须使用合法的标识符。 一.标识符和关键字 1.标识符:标识符可以简单地理解为一个名字,用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。Java语言规定标识符由任意顺序的字母、...
  • 1.2 变量与常量 一、标识符与关键字 ...​ cout,52select,a lot,-W,sin 等为不合法标注符。 关键字:也称保留字 是C++编译器预定义、具有固定含义标识符,不允许另作它用。 常用关键字
  • java变量与常量

    2021-03-25 11:43:27
    java程序执行过程中能够...其中能以数字为标识符第一个符号,更能是关键字。严格区分大小写。 例:name $mr user合法 String User非法 2.关键字 java关键有:如图所示 具体作用请参考:https://blog.csdn.net/wei
  • Java基础_变量和常量

    2019-09-20 18:49:25
    变量和常量的命名都必须使用合法的标识符。 标识符 标识符可以理解为一个名字,用来标识类名,方法名,变量名,数组名,文件名的有效字符序列。 Java语言中规定标识符: 1. 由任意字母,数字,下划线_, 美元...

空空如也

空空如也

1 2 3 4 5
收藏数 99
精华内容 39
关键字:

不合法的文件名符号