精华内容
下载资源
问答
  • 编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ; 其中面向对象语言主要体现三个特征:封装性、继承、...2、类声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是用来定义类 ; 4、...

    编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ;

    其中面向对象语言主要体现三个特征:封装性、继承、动态 ;

    类的定义:类声明和类体。基本格式如下:

    class 类名{

       类体

    }

    特点:

    1、类是Java程序的基本要素,一个Java应用程序就是由若干个类所构成;

    2、类声明的变量称为对象变量,也简称 对象 ;

    3、class 关键字是用来定义类 ;

    4、类的目的是抽象出一类事物共有的属性和行为,并用一定的语法格式来描述所抽象出的属性和行为;

    4、类名必须是合法的Java标识符;

    Java标识符详细说明:(以及中文标识符的说明)

    https://blog.csdn.net/LagerSwan/article/details/104081548


    类的声明:

    如下所示:

    class Number {

    .....

    }

    class 数字 {

    .....

    }

    其中 class Number 与 class 数字 称为类的声明,而 Number 和 数字 则为类名 ;


    类体,即 { } 中的内容:

    类体的内容由如下两部分构成:

    • 变量的声明:用来存储属性的值 ;(体现了对象的属性)
    • 方法的定义:方法可以对类中声明的变量进行操作;(体现了对象的行为)

    如下代码演示:

    public class Class_Test {
    	int number = 10;
    	double numberd = 11.111;
    	double TestDouble() {
    		double numbers = 100 ;
    		numbers += numberd;
    		return numbers;
    	}
    	public static void main(String[] args) {
    		Class_Test test = new Class_Test();
    		System.out.println(test.TestDouble());
    	}
    }

    在以上代码中,声明了一个类 Class_Test ,两个变量 number 与 numberd ,一个方法 TestDouble() ,一个主方法 main () ;


    成员变量的定义:

    一、成员变量的类型:

    成员变量的类型可以是Java中的任何一种数据类型,包括了基本数据类型:整形、浮点型、逻辑类型、字符类型 ;引用类型中的:数组、对象和接口;  

    如下代码演示:

    public class Class_Test {
    
    	public static void main(String[] args) {
    		
    		//成员变量的说明
    		//基本数据类型的成员变量
    		int testt = 11 ;
    		float testf = 11.111f ;
    		double testd = 11.11111 ;
    		//引用类型的变量
    		int a [] ;
    		Class_Test test ;
    		
    	}
    }

    在以上代码中,成员变量:testt,testf,testd 是基本数据类型的变量;a [ ] ,test是引用类型的变量,a [ ] 为数组的变量,test 为类声明的变量,即类对象;

    二、成员变量的有效范围:

    成员变量在整个类内都是有效的,其有效性与它在类体中声明的先后位置是不关的;

    如下代码演示:   最终输出: 110

    public class Class_Test {
    	
    	//成员变量的有效范围:
    	int number = 11 ;
    	int Int_Test(){
    		int int1 = number * digit ;
    		return int1;
    	}
    	int digit = 10 ;
    
    	public static void main(String[] args) {
    		//类体的说明
    		Class_Test test = new Class_Test();
    		System.out.println(test.Int_Test());	
    	}
    }
    

    不建议大家这样编写程序,当代码量多时,对代码的可读性有一定的影响,建议先声明成员变量,再定义方法;

    三、成员变量的编写风格:

    建议大家在声明成员变量时,变量的名字使用驼峰规则,即变量名由多个单词组成时,从第二个单词开始的其他单词的首字母大学;如:computerArea 、ClassExceptionShow 


    方法的使用:

    在类体中,方法的定义包括两部分:方法头、方法体 ;  一般格式如下:

    方法头 {

       方法体

    }

    一、方法头说明

    方法头由方法的类型、名称、名称后面的 () 以及 ()里面的参数列表所构成;

    如下代码演示:

    //无参数的方法头
    double testd (){
        return 11.111;
    }
    
    //有参数的方法头, x 和 y 即为参数
    double testd (double x,double y){
        return x+y;
    }

    二、方法体说明:

    方法体即 方法()后面的 { } 以及 { } 里面的内容;

    在方法体中声明的变量为局部变量,而不是成员变量,局部变量只在方法体内有效,而且与声明时的前后位置有关;

    如下代码演示:

    double testd = 10 ;
    double testd (double x,double y){      //参数 x,y是局部变量
       double sum;                         //参数 sum 是局部变量
       sum = x + y ;
    
       if(sum>x){
           sum += testd ;         //参数 testd 是成员变量(全局变量)
    }
    
        return sum;        //return 语句,返回 sum 的值
    }

    局部变量的介绍:

    1、局部变量不同与成员变量,局部变量只在方法中有效,而且与其声明的位置顺序有关;

    2、若局部变量声明在一个复合语句中,那么该局部变量的有效范围只在复合语句中有效;

    double testd (double x,double y){      //参数 x,y是局部变量
    	   double sum;                         //参数 sum 是局部变量
    	   sum = x + y ;
    	   if(sum != 0){
    	       int ints = 1;        // ints 为复合语句中的局部变量
    	       sum += ints ;
    	}
            double bottom = 1.1;
            bottom += ints ;         //程序报错:ints cannot be resolved to a variable
    	    return sum;
    	}

    3、若局部变量声明在一个循环语句中,那么该局部变量的有效范围只在循环语句中有效;和以上复合语句是一样的;


    总结:成员变量与局部变量的区别

    1、局部变量不同与成员变量,局部变量只在方法中有效,而成员变量在整个类中都有效;

    2、局部变量与其声明的位置顺序有关,而成员变量与其声明的位置顺序无关;

    3、若局部变量的名字和成员变量的名字相同,那么成员变量会被隐藏,即在方法体中成员变量暂时是无效的,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = x + 10 ; //y的值为 15 ,而不是20,此时成员变量 x = 10 在该方法体中,暂时失效;
       }
    
    }

    4、当想使用方法中被隐藏的成员变量,可以使用关键字 this 进行调用,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = this.x + 10 ; //此时 y 的值为 20 ,而不是15,this.x调用的为成员变量 x = 10 ;
       }
    
    }

    5、成员变量有默认值,而局部变量没有默认值,因此在使用局部变量时,要确保该局部变量是有初始值的,否则程序报错;

    class Test_Variable {
    
               int  y ;
    	   void tests () {
    	      int x;       //报错:The local variable x may not have been initialized
    	      y = x + 10 ; 
    	   }
    
    }

     

     

     

    展开全文
  • 判断变量名是否合法

    万次阅读 2019-02-02 12:51:47
    判断变量名是否合法 条件: 1.变量名可以由字母,数字或下划线组成 2.变量名只能以字母或下划线开头

    条件:
    1.变量名可以由字母,数字或下划线组成
    2.变量名只能以字母或下划线开头
    例:
    s = ‘hello@’
    1.判断变量名的第一个元素是否为字母或下划线: s[0]
    2.如果第一个元素符合条件,判断除了第一个元素的其他元素:s[1:]

    for循环:依次遍历字符串的每一个元素
    #for i in 'hello':
    #	if i.isalpha():
    #		print(i)
    
    """
    1.变量名的第一个字符是否为字母或下划线
    2.如果是,继续判断(4)
    3.如果不是,报错,不合法
    4.依次判断除了第一个字符之外的其他字符
    5.判断这个字符是否为数字或下划线
    """
    
    while True:
    	s = input('变量名:')
    	if s == 'exit':
    		print('欢迎下次使用')
    		break
    	if s[0].isalpha() or s[0] == '_':
    		for i in s[1:]:
    			if not(i.isalnum() or i =='_'):
    				print('%s变量名不合法' %(s))
    				break
    		else:
    			print('%s变量名合法' %(s))				
    	else:
    		print('变量名不合法')
    
    展开全文
  • 第三章 Scala基础——变量定义与基本类型

    万次阅读 多人点赞 2019-02-01 23:43:25
    一、定义一个变量 Scala在首次定义一个变量时,必须在...而用“val”修饰的变量,则禁止被重新赋值,类似于Java的final变量,换句话说,就是只能读能写的变量变量名可以是任意的字母、数字和下划线的组合,但...

    一、定义一个变量

    Scala在首次定义一个变量时,必须在变量名前面添加关键字“var”或者“val”。用“var”修饰的变量,可以重新赋予新的值,并且把原值抛弃,类似于Java的非final变量。在后续重新赋值时,就不用再写“var”了。而用“val”修饰的变量,则禁止被重新赋值,类似于Java的final变量,换句话说,就是只能读不能写的变量。

    变量名可以是任意的字母、数字和下划线的组合,但是不能以数字开头。Scala推荐的命名方法是“驼峰命名法”,即每个单词的首字母大写,并且变量名和函数名以小写字母开头,类、对象和特质则以大写字母开头。例如,“val isOne”,“class MyClass”。在首次定义变量时,就必须赋予具体的值来初始化。不能出现如下形式:

    val x

    x = 1

    以下代码都是合法的变量定义:

    scala> val x = 1
    x: Int = 1

    scala> var y = 2
    y: Int = 2

    scala> val msg = "Hello, world!"
    msg: String = Hello, world! 

    var类型的变量在重新赋值时,新值必须和旧值是同一个类型,否则会发生类型匹配错误:

    scala> var x = 1
    x: Int = 1

    scala> x = 10
    x: Int = 10

    scala> x = "abc"
    <console>:12: error: type mismatch;
     found   : String("abc")
     required: Int
           x = "abc"
               ^

    val类型的变量则直接禁止重新赋值:

    scala> val x = 1
    x: Int = 1

    scala> x = 10
    <console>:12: error: reassignment to val
           x = 10
             ^

    如果要赋给多个变量相同的值,那么没必要逐条定义,而是在一条语句里用逗号间隔的变量名。例如:

    scala> val a, b, c = 1
    a: Int = 1
    b: Int = 1
    c: Int = 1

    Scala的变量定义具有覆盖性,也就是说,如果出现了同名的变量,则后出现的变量会覆盖前面的变量。例如:

    scala> val x = 1
    x: Int = 1

    scala> val x = 10
    x: Int = 10

    scala> x
    res0: Int = 10

    要注意的是,赋给变量的对象存在可变与不可变之分。要理解到底是变量指向的对象本身发生了改变,还是变量指向了新的对象。即使是val类型的变量,也能被赋予一个可变对象。这个可变对象能够被重新修改,例如,给可变映射添加新的键值对。事实上,这只是旧对象发生了改变,并未产生新的对象。

    Scala提倡定义val类型的变量,因为它是函数式编程,而函数式编程的思想之一就是传入函数的参数不应该被改变。所以,在Scala里,所有函数的参数都必须是val类型的。但是,Scala也允许指令式编程,因而预留了var类型的变量,尽管并不推荐使用。对于习惯了指令式编程的读者,例如,喜欢编写“for(i = 0; i < N; i++)”来实现一个循环,很显然更倾向于使用var类型的变量,因为在这个for循环里,变量i被多次重新赋值。Scala推荐读者学会使用val,学会函数式编程。笔者也是学习C/C++出身的,但是现在已经完全习惯了函数式编程。使用val类型的一个好处就是,你不用去计算某个变量在某个时刻是什么值,因为val类型的变量一旦被初始化,就一直不变,直到被重新定义。

    二、Scala的基本类型

    Scala是静态语言,在编译期间会检查每个对象的类型。对于类型不匹配的非法操作,在编译时就能被发现。对于动态语言而言,这种非法操作需要等到运行时才能被发现,此时可能造成严重错误。所以,静态语言相比诸如Python这样的动态语言在某些方面是有优势的。对于Chisel而言,我们就需要这种优势。因为Chisel需要编译成Verilog,我们不能产生非法的Verilog语句并且等到模块运行时才去发现它。

    Scala标准库定义了一些基本类型,如下表所示。除了“String”类型是属于java.lang包之外,其余都在Scala的包里。

    Scala的基本类型
    Byte8-bit有符号整数,补码表示,范围是 -2^{7} 到 2^{7}-1
    Short16-bit有符号整数,补码表示,范围是 -2^{15} 到 2^{15}-1
    Int32-bit有符号整数,补码表示,范围是 -2^{31} 到 2^{31}-1
    Long64-bit有符号整数,补码表示,范围是 -2^{63} 到 2^{63}-1
    Char16-bit字符,Unicode编码,范围是 0 到 2^{16}-1
    String字符串
    Float32-bit单精度浮点数,符合IEEE 754标准
    Double64-bit双精度浮点数,符合IEEE 754标准
    Boolean布尔值,其值为true或者false

    事实上,在定义变量时,应该指明变量的类型,只不过Scala的编译器具有自动推断类型的功能,可以根据赋给变量的对象的类型,来自动推断出变量的类型。如果要显式声明变量的类型,或者无法推断时,则只需在变量名后面加上一个冒号“ : ”,然后在等号与冒号之间写出类型名即可。例如:

    scala> val x: Int = 123
    x: Int = 123

    scala> val y: String = "123"
    y: String = 123

    scala> val z: Double = 1.2
    z: Double = 1.2

       Ⅰ、整数字面量

    整数有四种类型,默认情况下推断为Int类型。如果字面量的结尾有l或者L,则推断为Long类型。此外,Byte和Short则需要定义变量时显式声明。注意,赋给的字面值不能超过类型的表示范围。

    整数字面量默认是十进制的,但如果以“0x”或者“0X”开头,则字面量被认为是十六进制。十六进制的字母不区分大小写。例如:

    scala> val a = 100
    a: Int = 100

    scala> val b = 0X123Abc
    b: Int = 1194684

    scala> val c: Byte = 200
    <console>:11: error: type mismatch;
     found   : Int(200)
     required: Byte
           val c: Byte = 200
                         ^

    scala> val d = 200L
    d: Long = 200

      Ⅱ、浮点数字面量 

    浮点数的字面量都是十进制的,类型默认是Double类型。可以增加一个字母“e”或者“E”,再添加一个整数作为指数,这样就构成10的n次幂。最末尾可以写一个“f”或者“F”,表示Float类型;也可以写一个“d”或者“D”,表示Double类型。注意,Double类型的字面量不能赋给Float类型的变量。虽然Float允许扩展成Double类型,但是会发生精度损失。例如:

    scala> val a = 1.2E3
    a: Double = 1200.0

    scala> val b = -3.2f
    b: Float = -3.2

    scala> val c: Float = -3.2
    <console>:11: error: type mismatch;
     found   : Double(-3.2)
     required: Float
           val c: Float = -3.2
                          ^

    scala> val d: Double = -3.2F
    d: Double = -3.200000047683716

      Ⅲ、字符与字符串字面量

     字符字面量是以单引号' '包起来的一个字符,采用Unicode编码。也可以用'\u编码号'的方式来构造一个字符,而且Unicode编码可以出现在代码的任何地方,甚至是名称命名。此外,还支持转义字符。例如:

    scala> val a = 'A'
    a: Char = A

    scala> val b = '\u0041'
    b: Char = A

    scala> val c = '\u0042'
    c: Char = B

    scala> val \u0041\u0042 = 1
    AB: Int = 1

    scala> val d = '\\'
    d: Char = \

    字符串就是用双引号" "包起来的字符序列,长度任意,允许掺杂转义字符。此外,也可以用前后各三个双引号"""  """包起来,这样字符串里也能出现双引号,而且转义字符不会被解读。例如:

    scala> val a = "\\\\\\"
    a: String = \\\

    scala> val b = """So long \u0041 String \\\'\"!"""
    b: String = So long A String \\\'\"!

      Ⅳ、字符串插值

    Scala包括了一个灵活的机制来支持字符串插值,这使得表达式可以被嵌入在字符串字面量中并被求值。第一种形式是s插值器,即在字符串的双引号前加一个s,形如s“…${表达式}…”。s插值器会对内嵌的每个表达式求值,对求值结果调用内置的toString方法,替换掉字面量中的表达式。从美元符号开始到首个非标识符字符(字母、数字、下划线和操作符的组合称为标识符,以及反引号对` `包起来的字符串)的部分会被当作表达式,如果有非标识符字符,就必须放在花括号里,且左花括号要紧跟美元符号。第二种形式是raw插值器,它与s插值器类似,只不过不识别转义字符。第三种形式是f插值器,允许给内嵌的表达式加上printf风格的指令,指令放在表达式之后并以百分号开始。指令语法来自java.util.Formatter。如:

    scala> val name = "ABC"
    name: String = ABC

    scala> println(s"$name DEFG")
    ABC DEFG

    scala> s"Sum = ${1 + 10}"
    res0: String = Sum = 11

    scala> s"\\\\"
    res1: String = \\

    scala> raw"\\\\"
    res2: String = \\\\

    scala> printf(f"${math.Pi}%.5f")
    3.14159

    三、总结

    本章介绍了Scala定义变量的方法及基本变量类型,重点在于学会使用val类型的变量。

     

    上一章   Scala入门——让你的代码跑起来

    下一章   Scala基础——函数及其几种形式

    展开全文
  • 编写 Java 程序,定义 Java 类 Point 用来表示坐标,坐标范围在(0,0)到(100,100)以内,并显示合法的坐标在控制台。 实现思路: 定义 Point 类,为该类分别定义两个属性 X 和 Y,用来表示横坐标和纵坐标。...

    返回本章节

    返回作业目录


    需求说明:

    编写 Java 程序,定义 Java 类 Point 用来表示坐标,坐标范围在(0,0)到(100,100)以内,并显示合法的坐标在控制台。

     

    实现思路:

    定义 Point 类,为该类分别定义两个属性 X 和 Y,用来表示横坐标和纵坐标。

    为 Point 类定义两个构造方法,分别是无参构造方法和有参构造方法。

    在有参构造方法中完成对参数的判定,如果不满足坐标范围则给出错误提示且给坐标一个(1,1)初始坐标,如果参数符合标准,则完成对属性 X 和 Y 的赋值。

    定义 Point 类的 show 方法,完成 X 和 Y 的打印。

    实现代码:

     
    public class Point {
    	int x;
    	int y;
    	
    	public Point(int a,int b) {
    		if((a >= 0 && a <= 100)&&(b >= 0 && b <= 100)) {
    			x = a;
    			y = b;
    		}else {
    			System.out.println("横坐标或纵坐标的取值不符合规范");
    			x = 1;
    			y = 1;
    		}
    	}
    	public void show() {
    		System.out.printf("当前的坐标为%d:%d\n",x,y);
    	}
    	public static void main(String[] args) {
    		Point p1 = new Point(88,77);
    		p1.show();
    		Point p2 = new Point(150,200);
    		p2.show();
    	}
    }

     

    展开全文
  • 其实在前面的例子中已经多次用到了变量。在程序运行期间其值可以改变的量称为变量。一个变量应该有一个名字,并在内存中占据一定的存储单元,在该存储单元中存放变量的值。请注意区分变量名和变量值这两个不同的概念...
  • for循环内变量定义问题

    千次阅读 2015-03-19 20:06:45
    在C99之前的编译器,支持括号内进行定义变量 2.在C++中是允许定义变量的,其c99之后的编译器亦可以在括号内进行声明变量。 #include<stdio.h>//c++可以编译,但是c能编译 int main() { int sum=0; for(int i=...
  • JS:变量定义和赋值

    千次阅读 2019-10-13 12:20:32
    如果在函数里面定义,则全局有效(即使是在括号里)。var变量的值可以更改。var变量支持重复定义,后面的定义会覆盖前面的。比如: <script> var money = 100; //此时全局有效 function test(){ var .....
  • js中定义变量名有哪些规范

    万次阅读 2016-10-11 14:52:34
    c、变量名中允许使用空格,首个字能为数字。 d、不用使用脚本语言中保留的关键字及保留符号作为变量名。 e、变量名区分大小写。(javascript是区分大小写的语言) 举例: a:以字母或下划线_
  • 指针变量定义和初始化

    千次阅读 2019-04-17 08:16:47
    1.指针定义和初始化 2.指向数组的指针 指针数组 指针定义 类型 * ptr = xxx; 指针运算 * 寻址过程,根据地址找到内存单元,然后把里面的值给取出来。 取地址运算 & 指针变量的初始化 语法形式 ...
  • javaScript学习笔记(一)js基础

    万次阅读 多人点赞 2018-09-21 10:07:18
    ================================= 公众号 关注一波 (一叶知秋博客) 定期分享视频资料 一、简介 1、概述: ...JavaScript是目前web开发中...诞生于1995年,当时的主要目的是验证表单的数据是否合法。 Java...
  • switch case 语句内部变量定义

    万次阅读 多人点赞 2015-10-08 08:27:08
    但关于switch case内定义变量的问题,网上的很多博文都有谬误,在这里我写一下对这个语句的了解。 一 先看合法定义方式: int main(int argc, const char * argv[]) { int idx = 2; switch (idx) {
  • lua语法-变量定义与使用

    千次阅读 2018-03-04 14:45:43
    lua语法-变量(全局变量与局部变量) 全局变量:直接定义变量名,并赋值 例如,a = 1; 注:用;结束当前语句(可选,也可以使用分号) ...局部变量:使用local关键字进行定义 ...例如,以下变量定义语句...
  • 变量定义的一般形式为:数据类型 变量名; 多个类型相同的变量:数据类型 变量名, 变量名, 变量名…; 注意:在定义中不允许连续赋值,如int a=b=c=5;是不合法的。 变量的赋值分为两种方式: 先声明再赋值 声明的同时...
  • Python定义变量的方法

    千次阅读 2021-07-01 20:10:55
    合法变量名 在Python中,定义一个变量需要遵循一定的约束,否则,Python可能识别不出它是一个变量变量名由大小写英文字母、数字和下划线_组成 变量不能用数字开头 变量尽量不要和Python关键字重合(比如...
  • 【C++】C++中的C

    千次阅读 多人点赞 2017-12-07 17:49:36
    C++兼容C,但同样的东西,在C++和C中的表现可能不同,下面总结了一些。1、函数空参int f();函数空参时,C表示任意参数,C++表示没有参数。int f(void);C表示没有参数时使用void...int f(int) {} // C++定义函数时,C++
  • 定义变量时省略var是安全的,不过是合法的。定义变量的作用域取决于定义的位置
  • 函数中的声明和变量定义

    千次阅读 2019-04-14 19:44:13
    函数中的声明和变量定义声明与定义比较前向引用函数属性内部/内嵌函数函数应用:打印图形和数学计算变量作用域全局变量与局部变量局部变量全局变量globa语句可变类型的全局变量 声明与定义比较 ​ 在某些编程语言...
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活使用,然而,在我们实际应用中,每一种变量进行一次声明,再结合起来显然是太实际的,类如一位...
  • 例:变量名是否合法: 1.变量名可以由字母,数字或者下划线组成 2.变量名只能以字母或者下划线开头 编程思路: 变量名的第一个字符是否为字母或下划线 如果是,继续判断 如果不是,报错 依次判断除了第一个字符之外的...
  • 1.JS概述 1)概念 js全程:JavaScript(一门客户端脚本语言) a.js可以直接嵌入在html页面中,由浏览器解释执行,进行预编译 ...1.解释执行:需要预编译,逐行执行 2.基于对象:内置了大量的现成对象 ...
  • python之判断变量名是否合法

    万次阅读 2019-01-21 12:41:00
    变量名是否合法:  1.变量名可以由字母,数字或者下划线组成  2.变量名只能以字母或者下划线开头  s = 'hello@'  1.判断变量名的第一个元素是否为字母或者下划线 s[0]  2.如果第一个元素符合条件,判断除了第一个...
  • 定义结构体变量的几种方式

    千次阅读 2018-02-07 13:36:59
    首先要注意区分结构体类型和结构体变量,结构体类型是用户为满足需要自己声明的一种类型,相当于事先准备好的框架,而结构体变量则是使用之前准备好的结构体类型定义的,可以类比“int a; float b;”其中的a,b则是...
  • C语言中的全局变量定义与使用

    千次阅读 2016-04-18 21:55:26
    1. 书中对‘全局变量’的定义  在函数内定义变量是局部变量,而在函数外定义变量叫做外部变量,外部变量是全局变量。全局变量可以为本文件中其他函数所共用它的有效范围... 如果外部变量不在文件的开头定义,其
  • Java数据类型以及变量定义

    千次阅读 2017-11-28 19:57:01
    一. 什么是数据类型呢? 数据类型的分类: 1.基本数据类型 ... 1.... 2....从运行结果可以看出,即使浮点型数据只有整数没有小数,在控制台上输出时系统也会自动加上...5.同一函数中 不要使用 重复的变量能重复定义
  • Java面试题- java变量命名

    千次阅读 2020-01-07 17:27:06
    下面那个标识符符合Java定义要求? A. String B. _Name C. Name123 D. 100Book java基础面试20题-答案解析版 正确答案是:D Java的变量命名 首字母:英文字母、$和下划线。 变量名:由$、字母、数字...
  • 今天在完善通讯录项目的时候发现一个小问题,就是在switch case 语句中定义变量时会报错,出现下面的问题 函数中当时我是这样写的 问题处在哪里呢?很简单,大家看下面的例子 switch(num){ case 1: int ...
  • C++中头文件中定义变量

    千次阅读 2019-11-27 21:42:07
    1、在头文件.h中定义static变量,如: ...2、在头文件.h中定义变量,但是初始化 int x; 相当于定义了一个全局变量x,同时在所有引用该头文件的.cpp文件中声明。作用域为整个项目(所有源文件); ...
  • Java实例变量和类变量

    万次阅读 多人点赞 2017-09-04 09:02:02
    Java程序的变量大体可分为成员变量和局部变量。其中局部变量可分为如下3类。 形参:在方法签名中定义的...代码块的局部变量:在代码块内定义的局部变量,必须在代码块内对其进行显式初始化,这种类型的局部变量从初始化
  • c语言定义变量时需要在最前边定义,否则会出现错误!!如下例题:给定一段连续的整数,求出他们中所有偶数的平方和以及所有奇数的立方和。 #include&lt;stdio.h&gt; void main() { int min,max,i,mid; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,015
精华内容 75,206
关键字:

不合法的变量定义