在日常生活中,人们会用到大量数据,像去ATM机取款,首先,需要插入银行卡,这个过程其实就是ATM机的系统在获取银行卡号这个数据,而后,输入密码,这个过程也是在获取数据,也就是密码。在后续进行的业务处理中,像存钱、取钱、转帐汇款等等,银行卡号和密码会被反复的、频繁的使用, 那就需要一个存储这些数据的地方。
在软件系统中,是将数据存储在内存之中的,而对内存中的数据的引用就是变量,可以理解为变量就是内存中数据的代词。
简单说, 变量就是指代在内存中开辟的存储空间,用于存放运算过程中需要用到的数据。代码如下所示:
int a = 5; int b = 6; int c = a + b;
如上代码中,变量a、b、c指代内存中三块用于存储整数的存储空间,分别用于存储两个整数及这两个整数之和,int意为整数数据类型,后续课程会详细介绍。
对于变量,我们需要关注如下几个方面:
当需要使用一个变量时,必须对该变量进行声明,变量的声明包含两点:变量名和数据类型,代码如下所示:
int a
上面的代码中,int为变量的数据类型,a为变量的名称,当声明如上语句时,JVM会为该变量在内存中开辟存储空间,不同的变量类型决定了存储空间的结构(后面详细介绍)。
Java语言语法规定,变量使用之前必须声明,否则会有编译错误。代码如下所示:
public static void main(String[] args) { a = 1; // 编译错误,变量没有声明 int score = 0; scord = 100; // 编译错误 System.out.println(score); }
从上面的代码中,可以看到出现了两个编译错误,编译错误即为javac过程出现的错误,主要是由于语法问题导致的。第一个错误,a =1,是因为该变量没有声明。第二个错误,scord=100,是因为前面声明的为score,编译器并未找到scord变量,该错误是因为拼写错误造成的。
如果多个变量的类型一样,可以在一条语句中声明,中间使用逗号分隔, 代码如下所示:
public static void main(String[] args) { int a=1, b=2; int c, d=3; }
从上面的代码中,可以看到,第一条语句,声明了两个整型变量,分别赋值为1和2,中间使用逗号分隔,最后以;号结尾。第二条语句,声明了两个整型变量,c没有赋初始值,d赋初值为3。
在java语言中,对于变量、常量、方法、类、包等等都有名字,将这些名字统一称之为java标识符,标识符的命名规则如下列表所示:
看如下的一些实例,可以体现出java标识符的命名规则:
int 123go = 100; // 编译错误,标识符不能以数字开头。 int 成绩 = 60;// 编译没错,标识可以是中文,但不建议使用。 int break= 200; // 编译错误,break是Java保留字。 int score = 80; System.out.println(Score); // 编译错误,Java大小写敏感,Score变量没有声明。
Java 变量的命名应“见名知意”,同时,Java编程规范要求:变量的命名需采用“驼峰命名法”,即如果变量的名字有多个单词组成,除第一个单词外,其他单词的首字母大写,其余的字母小写,例如:salary、 javaScore 、studentName、empSalary 等。
Java语法规定:变量在使用之前必须初始化,即必须给该变量赋予特定的值,而在C语言中,变量使用之前可以不需要初始化,但是,其初始值不确定,而Java语言的设计者为了避免因此而带来的错误,规定变量必须初始化之后才能使用,代码如下所示:
public static void main(String[] args) { int a, b = 10; int c = a + b; // 编译错误 System.out.prinltn(c); }
上面的代码出现了编译错误, 原因是变量b赋了初始值,在给变量c赋值时可以使用b,而变量a并未赋初始值就直接使用了,违反了java语法的规定,变量使用之前必须初始化,所以出现编译错误。
可以在变量声明时初始化,语法:变量类型 变量名称 = 初始值;代码如下所示:
public static void main(String[] args) { int sum = 0; //声明同时初始化 int a = 5; int b = 6; sum = a + b; System.out.println(sum); }
可以在变量声明以后,通过赋值语句对变量进行初始化,但一定确保在第一次使用该变量之前,代码如下所示:
public static void main(String[] args) { int sum; sum = 0; // 在使用sum变量之前对其进行初始化。 sum = sum + 100; System.out.println(sum); }
变量,顾名思义,可以改变的量,在java语言中,可以对其赋值、更改等操作,但是需要注意的是,对变量的操作即为对其所存储的数据的操作。代码如下所示:
public static void main(String[] args) { int a = 100; a = a + 200;//该条语句的义:将变量a中的值加上200所得结果再存入变量a }
变量在声明时指定了它的数据类型, Java编译器会检测对该变量的操作是否与其类型匹配,如果对变量的赋值或者操作与其类型不匹配,会产生编译错误。代码如下所示:
public static void main(String[] args) { int salary; salary = 15000.50; // 编译错误,整型变量不可以赋予浮点值(小数)。 double d = 123.456; int n = d%2; // 编译错误,d%2结果为double型,不能赋给整型的n。 }
Java语言有8种基本数据类型, 分别用于存储整数、浮点数、字符数据和布尔类型数据。需要注意的是: 现在所介绍的仅仅是基本数据类型,后续还会介绍很多非基本数据类型。基本数据类型如图 – 1所示:
图- 1
从图- 1中可以看出, 基本数据类型主要分为4大类 (整数类型、浮点类型、char、boolean), 整数类型又分为了4小类(byte、short、int、long), 浮点类型也分了2小类(float、double),这些数据类型的区别是怎样的?通过图– 2展示了这8种数据类型的存储空间及使用场景:
图- 2
在如上这8种数据类型中,最常用的有5种,分别为int、long、double、char、boolean。其余的数据类型几乎不用,要求对这5种基本数据类型重点掌握,其余的数据类型,有兴趣了解就可以了。
int是最常用的整数类型,一个int类型的变量占用4个字节,即32位的内存空间。Int的最大表示范围为:-231~231-1,即-2147483648 ~2147483647,大约正负21个亿多些。
所谓整数直接量(literal)就是直接写出的整数,例如:下面的语句中,100就是直接量。
int a = 100;
关于整数直接量,需要注意如下要点:
int d = 10000000000; // 编译错误10000000000这个数值写出来就是错误的,因为Java认为所有直接写出的整数都是int类型,而这个数值超过了int的表达范围。
int a = 100000; // 10进制 int b = 0x186a0; // 16进制 int c = 0303240; // 8进制
若对两个整数相除,会舍弃小数的部分(注意:不是四舍五入),结果也是整数。示例代码如下所示:
int c = 5/3; System.out.println(c); // c的值为1,取整 int total = 87; int error = 23; int percent = error / total * 100; System.out.println(percent+"%"); //结果为0%,23除以87整数部分为0,乘以100,为0 percent = 100 * error / total; System.out.println(percent + "%"); // 结果为26%,230除以87整数部分为26
当两个整数进行运算时, 其结果可能会超过整数的范围而发生溢出,正数过大而产生的溢出,结果为负数;负数过大而产生的溢出,结果为正数。示例代码如下所示:
int a = 2147483647; //int类型整数的上限 int b = -2147483648; //int类型整数的下限 a = a + 1; b = b - 1; System.out.println("a=" + a); //输出结果: a=-2147483648 溢出,结果错误。 System.out.println("b=" + b); //输出结果: b=2147483647溢出,结果错误。
在表示整数时,如果int类型的范围不够,可以使用long类型,一个long型的变量占用8个字节(即64位),最大表示范围为:-263 ~ 263-1,即 -9223372036854775808 ~ 9223372036854775807。
如果要表示long直接量,需要以 L 或 l 结尾。示例代码如下:
long a = 10000000000; //会有编译错误,因为10000000000编译器认为是int类型,而这个值,已经超出了int的范围 long b = 10000000000l; //正确
对于较大的整数运算(超过int的表达范围),可以使用long型。示例代码如下:
long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l; //必须有一个long型数据参与的运算结果才是long型 System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确 long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458; System.out.println("distance2="+ distance2); //distance2=-1973211136 溢出,=号后面的数据默认为int类型,超出了范围,发生溢出。
JDK提供 System.currentTimeMillis() 方法,返回1970年1月1日零点到此时此刻所经历的毫秒数,数据太大,故其数据类型为long。示例代码如下:
long time = System.currentTimeMillis(); System.out.println(time); //输出的结果为: 1383835712828
通过上面的代码可以看出,输出的结果已经超出int类型的最大值,因此,JDK设计的返回类型为long型,该方法常常被用于计时操作。
前面所学习的int、long都是用于存储整数的,小数即为浮点数,包括: float(单精度)和double(双精度),double类型的精度值是float类型的两倍,因此而得名双精精,在实际的应用开发中,float应用极少,大多数场合使用double表示浮点数。示例代码如下:
double pi = 3.14; double r = 8; double s = pi * r * r; System.out.println("s=" + s); // 输出的结果为:s=200.96
浮点数的直接量有两种写法:1)通常写法,如:3.14、314、0.1、.5。 2)科学计数法,如:1.25E2、1.25e2、1.25E-2。其中,1.25E2表示1.25乘以10的2次方。
默认的浮点直接量为double型,如果需要表示float类型的直接量,需要加“f”或“F”后缀。例如:
float f1 = 3.14 //编译错误,应该写成3.14f
2进制系统中无法精确的表示1/10,就好像十进制系统中无法精确的表示1/3一样,
所以,2进制表示10进制会有一些舍入误差,对于一些要求精确运算的场合会导致代码的缺陷。示例代码如下所示:
double money = 3.0; double price = 2.9; System.out.println(money - price); //输出的结果是: 0.10000000000000009
如果需要精确的运算可以考虑放弃使用double或float而采用BigDecimal 类来实现。关于这一点,将在后续的章节中介绍。
字符类型char事实上是一个16位无符号整数(都是正数),这个值是对应字符的编码,Java字符类型采用Unicode字符集编码(通用码、统一码、万国码),而Unicode是世界通用的定长字符集,所有的字符都是16位来表示。例如:字符a实际的值为97,字符A实际的值为65,字符0实际的值为48。
字符直接量可以采用诸如:‘中’的形式,也可以采用16进制的表示形式,例如: ‘\u4e2d’,代码如下所示:
char c1 = ‘中’; //c1中存的是”中”的编码 char c2 = '\u4e2d'; //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式 System.out.println(c1); System.out.println(c2);
如上代码的输出结果:c1的值为中,c2值也为中,但c1和c2内部存储的其实是”中”这个字符所对应的Unicode码,即:一个无符号的整数。
在对char型变量赋值时,可以采用如下三种方式:
方式一:
字符直接量:形如‘A’,变量中实际存储的是该字符的Unicode编码(无符号整数值),一个char型变量只能存储一个字符。示例如下:
char c1 = 'A';
方式二:
整型直接量:范围在0~65535之间的整数,变量中实际存储的即该整数值,但表示的是该整数值所对应的Unicode字符。示例如下:
char c2 = 65;
Unicode形式:形如‘\u0041’,Unicode字符的16进制形式。示例如下:
char c3 = '\u0041';
字符直接量需要包含在一对’’单引号之中,那如果想表示单引号’的字符时,需要怎么表示?想表示回车、换行符时,怎么表示?
因为单引号为特殊意义的字符, 那么,对于不方便输出的字符可以采用转义字符来表示,示例代码如下:
char c = '\\'; System.out.println(c); //输出的结果为:\
常用转义字符如下图 – 2所示:
图- 2
boolean类型适用于关系、逻辑运算, 表示某个条件是否成立, 只允许取值true或false,true表示条件成立, 而false表示条件不成立。
boolean型变量经常用于存储关系运算的结果,所谓关系运算就是比较两个变量的大小相等等关系(此知识点,后续详细介绍)。boolean示例代码如下所示:
int age = 18; boolean isChild = age<16; System.out.println(isChild); // isChild的值为false boolean running = true; boolean closed = false;
不同的基本类型直接可以相互转化,主要有两种方式:
图- 3
因为大类型的精度值大于小类型,取值范围大于小类型,所以,当使用强制转化时,有可能会造成精度的损失或者溢出,所以,在使用强制转化时要求显式的告诉编译器,正在进行强制转换。
基本类型转化如下示例所示,注意强制转换时可能会造成的精度丧失和溢出。
int a = 100; int b = 200; long c = a + b; //自动将int转化为long long l1 = 1024l; int i = (int) l1; //需要加强制转化符由于1024在int的范围内,所以没有产生溢出 long l = 1024L * 1024 * 1024 * 4; int j = (int) l; //会产生溢出 System.out.println(j); // 结果为:0 double pi = 3.1415926535897932384; float f = (float) pi; //会造成精度的损失,因为单精度的精确度小于double System.out.println(f); //结果为:3.1415927
如果在一个表达式中出现了多种数据类型,则运算结果会自动的向较大的类型进行转化,
示例如下:
//由于有long型的直接量参与,整个表达式的结果为long long distance = 10000 * 365 * 24 * 60 * 60 * 299792458l; //由于有double型的直接量599.0参与,整个表达式的结果为 double double change = 800 - 599.0; //结果为0.0,右边都是int型数据运算结果也为int类型,结果为0,再赋值给double 型,将0转化为 0.0 double persent1 = 80 / 100; //结果为0.8,右边表达式有double型直接量参与, 运算结果为double型 double persent2 = 80.0 / 100;
在前面所介绍的8种数据类型中,byte、char、short、int、long都表示整数类型,而整型的直接量为int,在实际使用中,为了方便使用,遵循了如下的规则:
byte b = 97; short s = 97; char c = 97;
byte b = 97; int num = b + b; //num的值为194
Java算术运算符除了通常的加(+)、减(-)、乘(*)、除(\)之外,还包括取模运算(%)和自增(++)及自减(--)运算。+,-,*,/ 比较简单,实验一下即可。
取模运算(%)意为取余数,只能适用于整数及char类型。示例代码如下所示:
// 输出255除以8所得的余数。 int n = 225; System.out.println(n % 8); //结果为1
Java的自增运算符(++)和自减运算符(--)继承自C++,可以使变量的值加1或减1,但其写在变量前和变量后有不同的效果:
示例代码如下所示:
int a = 10, b = 20; int c1 = a++; // 先将a的值赋给c1,然后a再自加 int c2 = ++b; // 先将b的值自加,然后再赋给c2 System.out.println("a=" + a + ", b=" + b + ", c1=" + c1 + ", c2=" + c2); // 输出的结果为: a=11, b=21, c1=10, c2=21
Java中的关系运算符用于判断数据之间的大小关系,包括大于(>)、小于(<)、大于等于(>=)、小于等于(<=)、等于(==)、不等于(!=) 六个运算符。
在实际应用中常常使用,假设现在想实现转帐功能,输入转帐的金额,需要判断所转帐的金额是否大于当前帐户的金额,那结果只有两个,大于或不大于,在java语言中,使用boolean类型来表示这种是否的状态,如果关系成立为true,否则为false。示例代码如下所示:
int max = 10; int num = 9; boolean b1 = max > 15; boolean b2 = num%2 == 1; System.out.println(b1); // 结果为false System.out.println(b2); // 结果为true
前面的关系运算符是用于比较两个数值之间的大小关系的, 而逻辑运算符是用来进行逻辑运算的,它是建立在关系运算的基础之上的。当两个关系运算需要兼顾考虑时,可以使用逻辑运算符。
逻辑运算符包括:与(&&)、或(||)和非(!)。参与逻辑运算的变量或表达式都是boolean类型,运算结果也为boolean类型。逻辑运算规则如下图 - 4所示:
图- 4
通过分析可以看出:
两个boolean变量参与“&&”运算时,只有当两个变量均为true的时,运算结果才为true,否则结果为false。示例代码如下所示:
int score = 80; boolean b = score >= 60 && score < 90; System.out.println(b); // 结果为true,因为score的值同时满足大于等于60和小于90这两个条件,逻辑表达式“score >= 60”和“score < 90”的结果均为true,所以&&运算的结果即为true。
两个boolean变量参与“||”运算时,当两个变量有一个为true时,结果即为true,只有当两个变量均为false时结果为false。示例代码如下所示:
boolean flag = true; int n = 200; boolean b1 = flag || (n >= 0 && n < 100); System.out.println(b1); // 结果为true,上面这段代码中,表达式“flag || (n >= 0 && n < 100)”的含义是:当flag为true或者n在0到100之间(n大于等于0且小于100)时,结果为true,否则为false。根据flag和n的值,最后的运算结果为true。
“!”运算相对简单,只有一个boolean变量参与运算,运算的值与该变量相反,变量为true时结果为false,变量为false是结果为true。示例代码如下所示:
boolean flag = true; int n = 200; boolean b = !flag || (n >= 0 && n < 100); System.out.println(b); // 结果为false,上面这段代码中,表达式“!flag || (n >= 0 && n < 100)”的含义是:当flag为false或者n在0到100之间(n大于等于0且小于100)时,结果为true,否则为false。根据flag和n的值,最后的运算结果为false。
Java逻辑运算中的&&和||有短路的特性,当第一个关系表达式就可以判断出整个表达式的结果时,就不会再去判断后面的第二个表达式。
示例代码如下所示:
int i = 100, j = 200; boolean b1 = (i > j) && (i++ > 100); System.out.println(b1); // 结果为:false System.out.println(i); // 结果为:100,发生短路,i++不会被执行 boolean b2 = i > 0 || j++ > 200; System.out.println(b2); // 结果为:true System.out.println(j); // 结果为:200,发生短路,j++不会被执行