java入门学习1

变量

JAVA基本类型 运算符和表达式-1 1. 变量

1.1. 什么是变量

在日常生活中，人们会用到大量数据，像去ATM机取款，首先，需要插入银行卡，这个过程其实就是ATM机的系统在获取银行卡号这个数据，而后，输入密码，这个过程也是在获取数据，也就是密码。在后续进行的业务处理中，像存钱、取钱、转帐汇款等等，银行卡号和密码会被反复的、频繁的使用， 那就需要一个存储这些数据的地方。

在软件系统中，是将数据存储在内存之中的，而对内存中的数据的引用就是变量，可以理解为变量就是内存中数据的代词。

简单说， 变量就是指代在内存中开辟的存储空间，用于存放运算过程中需要用到的数据。代码如下所示： copytextpop-up int a = 5; int b = 6; int c = a + b; int a = 5; int b = 6; int c = a + b;

如上代码中，变量a、b、c指代内存中三块用于存储整数的存储空间，分别用于存储两个整数及这两个整数之和，int意为整数数据类型，后续课程会详细介绍。 对于变量，我们需要关注如下几个方面：

变量的声明：用特定语法声明一个变量，让运行环境为其分配空间。 变量的命名：需要有个见名知意的名字，而且要符合Java语言规范。 变量的初始化：变量声明后，要为其赋一个确定的初值后再使用。

变量的访问：可以对变量中的数据进行存取、操作，但必须和其类型匹配。 1.2. 变量的声明 1.2.1. 变量的声明

当需要使用一个变量时，必须对该变量进行声明，变量的声明包含两点：变量名和数据类型，代码如下所示： copytextpop-up int a int a

上面的代码中，int为变量的数据类型，a为变量的名称，当声明如上语句时，JVM会为该变量在内存中开辟存储空间，不同的变量类型决定了存储空间的结构（后面详细介绍）。 1.2.2. 未经声明的变量不能使用

Java语言语法规定，变量使用之前必须声明，否则会有编译错误。代码如下所示： copytextpop-up

public static void main(String[] args) {

a = 1; // 编译错误，变量没有声明

int score = 0；

scord = 100； // 编译错误

System.out.println(score); }

public static void main(String[] args) { a = 1; // 编译错误，变量没有声明 }

int score = 0；

scord = 100； // 编译错误 System.out.println(score);

从上面的代码中，可以看到出现了两个编译错误，编译错误即为javac过程出现的错误，主要是由于语法问题导致的。第一个错误，a =1，是因为该变量没有声明。第二个错误，scord=100，是因为前面声明的为score，编译器并未找到scord变量，该错误是因为拼写错误造成的。

1.2.3. 一条语句中声明多个同类型变量

如果多个变量的类型一样，可以在一条语句中声明，中间使用逗号分隔， 代码如下所示： copytextpop-up

public static void main(String[] args) {

int a=1, b=2;

int c, d=3; }

public static void main(String[] args) { int a=1, b=2; int c, d=3; }

从上面的代码中，可以看到，第一条语句，声明了两个整型变量，分别赋值为1和2，中间使用逗号分隔，最后以；号结尾。第二条语句，声明了两个整型变量，c没有赋初始值，d赋初值为3。 1.3. 变量的命名

1.3.1. 命名需要符合标识符语法要求

在java语言中，对于变量、常量、方法、类、包等等都有名字，将这些名字统一称之为java标识符，标识符的命名规则如下列表所示： 可以由字母、数字、“_”或“$”符组成，但是不能以数字开头。 中文可以作为变量名，但不提倡使用。

Java大小写敏感，即：严格区分大小写，在给命名变量时需要注意。 不能使用Java保留字（一些Java语言规定好的，有特殊含义的字符），如：int、if、else、for、break等。

看如下的一些实例，可以体现出java标识符的命名规则： copytextpop-up

int 123go = 100； // 编译错误，标识符不能以数字开头。

int 成绩 = 60；// 编译没错，标识可以是中文，但不建议使用。

int break= 200； // 编译错误，break是Java保留字。 int score = 80;

System.out.println(Score); // 编译错误，Java大小写敏感，Score变量没有声明。 int 123go = 100； // 编译错误，标识符不能以数字开头。

int 成绩 = 60；// 编译没错，标识可以是中文，但不建议使用。 int break= 200； // 编译错误，break是Java保留字。 int score = 80;

System.out.println(Score); // 编译错误，Java大小写敏感，Score变量没有声明。 1.3.2. 命名需见名知意，且符合Java规范 Java 变量的命名应“见名知意”，同时，Java编程规范要求：变量的命名需采用“驼峰命名法”，即如果变量的名字有多个单词组成，除第一个单词外，其他单词的首字母大写，其余的字母小写，例如：salary、 javaScore 、studentName、empSalary 等。 1.4. 变量的初始化

1.4.1. 未经初始化的变量不能使用 Java语法规定：变量在使用之前必须初始化，即必须给该变量赋予特定的值，而在C语言中，变量使用之前可以不需要初始化，但是，其初始值不确定，而Java语言的设计者为了避免因此而带来的错误，规定变量必须初始化之后才能使用，代码如下所示： copytextpop-up

public static void main(String[] args) { int a, b = 10;

int c = a + b; // 编译错误 System.out.prinltn(c); }

public static void main(String[] args) { int a, b = 10;

int c = a + b; // 编译错误 System.out.prinltn(c); }

上面的代码出现了编译错误， 原因是变量b赋了初始值，在给变量c赋值时可以使用b，而变量a并未赋初始值就直接使用了，违反了java语法的规定，变量使用之前必须初始化，所以出现编译错误。

1.4.2. 在声明变量时初始化

可以在变量声明时初始化，语法：变量类型 变量名称 = 初始值；代码如下所示： copytextpop-up

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 = 0; //声明同时初始化 int a = 5;

}

int b = 6; sum = a + b;

System.out.println(sum);

1.4.3. 在第一次使用变量前初始化 可以在变量声明以后，通过赋值语句对变量进行初始化，但一定确保在第一次使用该变量之前，代码如下所示： copytextpop-up

public static void main(String[] args) { int sum;

sum = 0; // 在使用sum变量之前对其进行初始化。 sum = sum + 100;

System.out.println(sum); }

public static void main(String[] args) { int sum; }

sum = 0; // 在使用sum变量之前对其进行初始化。 sum = sum + 100;

System.out.println(sum);

1.5. 变量的访问

1.5.1. 可以对变量中的值进行存取，操作

变量，顾名思义，可以改变的量，在java语言中，可以对其赋值、更改等操作，但是需要注意的是，对变量的操作即为对其所存储的数据的操作。代码如下所示： copytextpop-up

public static void main(String[] args) { int a = 100;

a = a + 200;//该条语句的义：将变量a中的值加上200所得结果再存入变量a }

public static void main(String[] args) { int a = 100;

a = a + 200;//该条语句的义：将变量a中的值加上200所得结果再存入变量a }

1.5.2. 变量的操作必须与类型匹配 变量在声明时指定了它的数据类型， Java编译器会检测对该变量的操作是否与其类型匹配，如果对变量的赋值或者操作与其类型不匹配，会产生编译错误。代码如下所示： copytextpop-up

public static void main(String[] args) { int salary;

salary = 15000.50; // 编译错误，整型变量不可以赋予浮点值（小数）。

double d = 123.456;

int n = d%2; // 编译错误，d%2结果为double型，不能赋给整型的n。 }

public static void main(String[] args) { int salary;

salary = 15000.50; // 编译错误，整型变量不可以赋予浮点值（小数）。

double d = 123.456;

int n = d%2; // 编译错误，d%2结果为double型，不能赋给整型的n。 }

2. JAVA基本类型

2.1. 8种基本数据类型

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种基本数据类型重点掌握，其余的数据类型，有兴趣了解就可以了。 2.2. int类型 2.2.1. int类型

int是最常用的整数类型，一个int类型的变量占用4个字节，即32位的内存空间。Int的最

大表示范围为：-231～231-1，即-2147483648 ~2147483647，大约正负21个亿多些。 2.2.2. 整数直接量是int类型

所谓整数直接量（literal）就是直接写出的整数，例如：下面的语句中，100就是直接量。 copytextpop-up

int a = 100； int a = 100；

关于整数直接量，需要注意如下要点：

整数的直接量的类型默认为int类型，如果直接写出的整数超过了int的表达范围，将会出现编译错误，下面的语句，就是因为超出了整数的范围而导致的编译错误。 copytextpop-up

int d = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。

int d = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。

除了通常的十进制数字形式，整数直接量也可以写成16进制的形式（以0X或0x开头）或8进制的形式（以0开头），请看如下直接量三种表现形式： copytextpop-up

int a = 100000; // 10进制 int b = 0x186a0; // 16进制 int c = 0303240; // 8进制 int a = 100000; // 10进制 int b = 0x186a0; // 16进制 int c = 0303240; // 8进制

2.2.3. 整型数据除法运算中的取整

若对两个整数相除，会舍弃小数的部分（注意：不是四舍五入），结果也是整数。示例代码如下所示： copytextpop-up 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 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 2.2.4. 运算时要防止溢出的发生

当两个整数进行运算时， 其结果可能会超过整数的范围而发生溢出，正数过大而产生的溢出，结果为负数；负数过大而产生的溢出，结果为正数。示例代码如下所示： copytextpop-up

int a = 2147483647; //int类型整数的上限 int b = -2147483648; //int类型整数的下限 a = a + 1; b = b - 1;

System.out.println(\ //输出结果： a=-2147483648 溢出，结果错误。 System.out.println(\ //输出结果： b=2147483647溢出，结果错误。 int a = 2147483647; //int类型整数的上限 int b = -2147483648; //int类型整数的下限 a = a + 1; b = b - 1;

System.out.println(\ //输出结果： a=-2147483648 溢出，结果错误。 System.out.println(\ //输出结果： b=2147483647溢出，结果错误。

2.3. long类型 2.3.1. long类型

在表示整数时，如果int类型的范围不够，可以使用long类型，一个long型的变量占用8个字节（即64位），最大表示范围为：-263 ~ 263-1，即 -9223372036854775808 ~ 9223372036854775807。

如果要表示long直接量，需要以 L 或 l 结尾。示例代码如下： copytextpop-up

long a = 10000000000; //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围 long b = 10000000000l; //正确

long a = 10000000000; //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围 long b = 10000000000l; //正确

2.3.2. 使用long类型进行较大整数的运算 对于较大的整数运算（超过int的表达范围），可以使用long型。示例代码如下： copytextpop-up

long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l;

//必须有一个long型数据参与的运算结果才是long型

System.out.println(\结果正确

long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458;

System.out.println(\ //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。

long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l; //必须有一个long型数据参与的运算结果才是long型

System.out.println(\结果正确

long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458;

System.out.println(\ //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。 2.3.3. 通过时间毫秒数来存储日期和时间

JDK提供 System.currentTimeMillis() 方法，返回1970年1月1日零点到此时此刻所经历的毫秒数，数据太大，故其数据类型为long。示例代码如下： copytextpop-up

long time = System.currentTimeMillis();

System.out.println(time); //输出的结果为： 1383835712828 long time = System.currentTimeMillis();

System.out.println(time); //输出的结果为： 1383835712828

通过上面的代码可以看出，输出的结果已经超出int类型的最大值，因此，JDK设计的返回类型为long型，该方法常常被用于计时操作。 2.4. double类型

2.4.1. 使用double进行浮点数的运算

前面所学习的int、long都是用于存储整数的，小数即为浮点数，包括： float（单精度）和double（双精度），double类型的精度值是float类型的两倍，因此而得名双精精，在实际的应用开发中，float应用极少，大多数场合使用double表示浮点数。示例代码如下： copytextpop-up double pi = 3.14; double r = 8;

double s = pi * r * r;

System.out.println(\ // 输出的结果为：s=200.96 double pi = 3.14; double r = 8;

double s = pi * r * r;

System.out.println(\ // 输出的结果为：s=200.96 2.4.2. 浮点数直接量是double类型

浮点数的直接量有两种写法：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”后缀。例如： copytextpop-up

float f1 = 3.14 //编译错误，应该写成3.14f float f1 = 3.14 //编译错误，应该写成3.14f 2.4.3. double运算时会出现舍入误差

2进制系统中无法精确的表示1/10，就好像十进制系统中无法精确的表示1/3一样，

所以，2进制表示10进制会有一些舍入误差，对于一些要求精确运算的场合会导致代码的缺陷。示例代码如下所示： copytextpop-up

double money = 3.0; double price = 2.9;

System.out.println(money - price); //输出的结果是： 0.10000000000000009

double money = 3.0; double price = 2.9;

System.out.println(money - price); //输出的结果是： 0.10000000000000009

如果需要精确的运算可以考虑放弃使用double或float而采用BigDecimal 类来实现。关于这一点，将在后续的章节中介绍。 2.5. char类型 2.5.1. char类型

字符类型char事实上是一个16位无符号整数（都是正数），这个值是对应字符的编码，Java字符类型采用Unicode字符集编码（通用码、统一码、万国码），而Unicode是世界通用的定长字符集，所有的字符都是16位来表示。例如：字符a实际的值为97，字符A实际的值为65，字符0实际的值为48。 字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如： ‘\中’，代码如下所示： copytextpop-up

char c1 = ‘中’; //c1中存的是”中”的编码

char c2 = '\中'; //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式 System.out.println(c1); System.out.println(c2);

char c1 = ‘中’; //c1中存的是”中”的编码

char c2 = '\中'; //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式 System.out.println(c1); System.out.println(c2);

如上代码的输出结果：c1的值为中，c2值也为中，但c1和c2内部存储的其实是”中”这个字符所对应的Unicode码，即：一个无符号的整数。 2.5.2. 对char型变量赋值

在对char型变量赋值时，可以采用如下三种方式： 方式一：

字符直接量：形如‘A’，变量中实际存储的是该字符的Unicode编码（无符号整数值），一个char型变量只能存储一个字符。示例如下： copytextpop-up char c1 = 'A'; char c1 = 'A';

方式二：

整型直接量：范围在0~65535之间的整数，变量中实际存储的即该整数值，但表示的是该整数值所对应的Unicode字符。示例如下： copytextpop-up char c2 = 65; char c2 = 65;

Unicode形式：形如‘\A’,Unicode字符的16进制形式。示例如下： copytextpop-up char c3 = '\A'; char c3 = '\A'; 2.5.3. 使用转义字符

字符直接量需要包含在一对’’单引号之中，那如果想表示单引号’的字符时，需要怎么表

示？想表示回车、换行符时，怎么表示？

因为单引号为特殊意义的字符， 那么，对于不方便输出的字符可以采用转义字符来表示，示例代码如下： copytextpop-up char c = '\\\\';

System.out.println(c); //输出的结果为：\\ char c = '\\\\';

System.out.println(c); //输出的结果为：\\ 常用转义字符如下图 – 2所示：

图- 2

2.6. boolean类型

2.6.1. 使用boolean变量进行关系运算

boolean类型适用于关系、逻辑运算， 表示某个条件是否成立， 只允许取值true或false，true表示条件成立， 而false表示条件不成立。

boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系（此知识点，后续详细介绍）。boolean示例代码如下所示： copytextpop-up int age = 18;

boolean isChild = age<16;

System.out.println(isChild); // isChild的值为false boolean running = true; boolean closed = false; int age = 18;

boolean isChild = age<16;

System.out.println(isChild); // isChild的值为false boolean running = true; boolean closed = false;

2.7. 基本类型间转换 2.7.1. 类型间转换

不同的基本类型直接可以相互转化，主要有两种方式： 自动类型转化（隐式类型转换）：从小类型到大类型可以自动完成。类型的大小关系如下图 - 3所示：

图- 3

强制转化：从大类型到小类型需要强制转换符，语法如下： （需要转换成的类型）变量

因为大类型的精度值大于小类型，取值范围大于小类型，所以，当使用强制转化时，有可能会造成精度的损失或者溢出，所以，在使用强制转化时要求显式的告诉编译器，正在进行强制转换。

2.7.2. 强制转换时的精度丧失和溢出

基本类型转化如下示例所示，注意强制转换时可能会造成的精度丧失和溢出。 copytextpop-up 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 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 2.7.3. 数值运算时的自动转换

如果在一个表达式中出现了多种数据类型，则运算结果会自动的向较大的类型进行转化， 示例如下： copytextpop-up

//由于有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;

//由于有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;

2.7.4. byte、char、short转换为int

在前面所介绍的8种数据类型中，byte、char、short、int、long都表示整数类型，而整型的直接量为int，在实际使用中，为了方便使用，遵循了如下的规则：

int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。示例如下： copytextpop-up byte b = 97; short s = 97; char c = 97; byte b = 97; short s = 97; char c = 97;

byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。示例如下： copytextpop-up byte b = 97;

int num = b + b; //num的值为194 byte b = 97;

int num = b + b; //num的值为194 3. 运算符和表达式-1 3.1. 算数运算

3.1.1. 使用%运算符

Java算术运算符除了通常的加（+）、减（-）、乘（*）、除（\\）之外，还包括取模运算（%）和自增（++）及自减（--）运算。+，-，*，/ 比较简单，实验一下即可。

取模运算（%）意为取余数，只能适用于整数及char类型。示例代码如下所示： copytextpop-up

// 输出255除以8所得的余数。 int n = 225;

System.out.println(n % 8); //结果为1 // 输出255除以8所得的余数。 int n = 225;

System.out.println(n % 8); //结果为1 3.1.2. 使用“++”和“--”运算符

Java的自增运算符（++）和自减运算符（--）继承自C++，可以使变量的值加1或减1，但其写在变量前和变量后有不同的效果：

如果写在变量前，表示在使用这个变量之前加1或减1 如果写在变量后，表示这个变量使用完之后再加1或减1 示例代码如下所示： copytextpop-up int a = 10, b = 20;

int c1 = a++; // 先将a的值赋给c1，然后a再自加 int c2 = ++b; // 先将b的值自加，然后再赋给c2

System.out.println(\// 输出的结果为： a=11, b=21, c1=10, c2=21 int a = 10, b = 20;

int c1 = a++; // 先将a的值赋给c1，然后a再自加 int c2 = ++b; // 先将b的值自加，然后再赋给c2

System.out.println(\

// 输出的结果为： a=11, b=21, c1=10, c2=21 3.2. 关系运算

3.2.1. 使用关系运算符

Java中的关系运算符用于判断数据之间的大小关系，包括大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、等于（==）、不等于（!=） 六个运算符。

在实际应用中常常使用，假设现在想实现转帐功能，输入转帐的金额，需要判断所转帐的金额是否大于当前帐户的金额，那结果只有两个，大于或不大于，在java语言中，使用boolean类型来表示这种是否的状态，如果关系成立为true，否则为false。示例代码如下所示： copytextpop-up 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 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 3.3. 逻辑运算 3.3.1. 逻辑运算

前面的关系运算符是用于比较两个数值之间的大小关系的， 而逻辑运算符是用来进行逻辑运算的，它是建立在关系运算的基础之上的。当两个关系运算需要兼顾考虑时，可以使用逻辑运算符。

逻辑运算符包括：与（&&）、或（||）和非（!）。参与逻辑运算的变量或表达式都是boolean类型，运算结果也为boolean类型。逻辑运算规则如下图 - 4所示：

图- 4

通过分析可以看出：

当变量b1和变量b2同时为true时，&&表达式为true。 当变量b1和变量b2有一个为true时，||表达式为false。

！只有一个表达式，当b1为true时，!b1为false，b1为false时，!b1为true。 3.3.2. 使用“&&”运算符

两个boolean变量参与“&&”运算时，只有当两个变量均为true的时，运算结果才为true，否则结果为false。示例代码如下所示： copytextpop-up int score = 80;

boolean b = score >= 60 && score < 90; System.out.println(b);

// 结果为true，因为score的值同时满足大于等于60和小于90这两个条件，逻辑表达式“score >= 60”和“score < 90”的结果均为true，所以&&运算的结果即为true。 int score = 80;

boolean b = score >= 60 && score < 90; System.out.println(b);

// 结果为true，因为score的值同时满足大于等于60和小于90这两个条件，逻辑表达式“score >= 60”和“score < 90”的结果均为true，所以&&运算的结果即为true。 3.3.3. 使用“||”运算符

两个boolean变量参与“||”运算时，当两个变量有一个为true时，结果即为true，只有当两个变量均为false时结果为false。示例代码如下所示： copytextpop-up 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 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。

3.3.4. 使用“!”运算符

“!”运算相对简单，只有一个boolean变量参与运算，运算的值与该变量相反，变量为true时结果为false，变量为false是结果为true。示例代码如下所示： copytextpop-up 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。 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。 3.3.5. 关于“短路逻辑”的问题

Java逻辑运算中的&&和||有短路的特性，当第一个关系表达式就可以判断出整个表达式的结果时，就不会再去判断后面的第二个表达式。 对于“&&”，当第一个操作数为false时，将不会判断第二个操作数，因为此时无论第二个操作数是什么最后的结果一定是false； 对于“||”，当第一个操作数为true时，将不会判断第二个操作数，因为此时无论第二个操作数为何，最后的运算结果一定是true。 示例代码如下所示： copytextpop-up 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++不会被执行 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++不会被执行

Top

JAVA Fundamental DAY02 变量使用常用错误汇总

整数类型（int、long）使用常见问题汇总 浮点类型（float、double）使用常见问题汇总 对char类型变量的各种赋值方式汇总 类型转换常见问题汇总 年龄判断程序

1 变量使用常用错误汇总 1.1 问题

在我们使用变量的过程中，会遇到一些问题，在此将这些问题进行汇总，在今后使用的过程中，避免出错。即使出现错误也可以很快的找到问题所在。 1.2 方案

变量在使用的过程中，常见问题总结为如下几点： 1） 使用未经声明的变量。

2） 使用不符合Java标识符命名规则的变量。 3） 使用未经初始化的变量。

4） 变量的赋值与变量的类型不匹配 1.3 步骤

实现此案例需要按照如下步骤进行。 步骤一：使用未经声明的变量

Java语言语法规定，变量使用之前必须声明，否则会有编译错误。大多数时候我们都记得这个规范，但是还是会出现变量未声明就使用的情况，请看如下代码： public static void main(String[] args) { a = 1; // 编译错误，变量没有声明 int score = 0；

scord = 100； // 编译错误 System.out.println(score); }

编译上述代码，会发现在代码“a=1；”处和代码“scord=100；”处出现编译错误。出现编译错误的原因是变量a和变量scord没有被声明。变量的声明包含两点：变量的类型和变量的名称。a变量没有被声明的原因是没有变量的类型。scord变量没有被声明的原因也是因为没有变量类型，但是查看代码scord=100；的上下行的代码会发现声明了score变量，分析这三行代码，scord=100行出现编译错误的原因是变量没有被声明，没有声明的原因是变量score拼写成了scord。

步骤二：使用不符合Java标识符命名规则的变量 Java中的变量的命名必须符合Java标识符的规则： 1） 可以以字母、数字、“_”和“$”符组成； 2） 首字符不能以数字开头；

3） 中文可以作为变量名，但不提倡使用； 4） Java大小写敏感，命名变量时需要注意；

5） 不能使用Java保留字（一些Java语言规定好的，有特殊含义的字符），如：int、if、for、break等。

下面的代码体现了Java变量的命名规则：

int 123go = 100； // 编译错误，不能以数字开头。 int 成绩 = 60；// 编译没错，但不建议使用。

int break= 200； // 编译错误，break是Java保留字。 int score = 80;

System.out.println(Score);

// 编译错误，Java大小写敏感，Score变量没有声明。 上述代码中，分别有如下错误：

1） 变量“123go”不符合Java的命名规范，原因是变量名不能以数字开头；

2） 变量“成绩“编译时是正确的，但是这种使用汉字进行命名的方式不建议使用；

3） 变量”break“处会出现编译错误，原因是break是Java的保留字，不能作为变量名； 4） 在输出变量”Score“处会出现编译错误，原因是变量名是大小写敏感的。int score=80；处声明的变量和下一行代码中输出的Score是两个变量，所以变量Score没有声明。Java语言语法规定，变量使用之前必须声明，否则会有编译错误。 另外，Java 变量名的定义应“见名知意”；同时，Java编程规范要求：变量的命名需采用“驼峰命名法”，即如果变量的名字由多个单词组成，除第一个单词外，其他单词的首字母大写，其余的字母小写，例如：salary、 empNo studentName 等。 步骤三：使用未经初始化的变量

Java语言规定变量在使用之前必须初始化，即必须给该变量赋予特定的值。请看下列代码： public static void main(String[] args) { int a, b = 10;

int c = a + b; // 编译错误，变量a没有初始化 System.out.println(c); }

在上述代码中，代码行int c = a + b;处会出现编译错误，因为此行代码使用到了变量a，但是该变量却没有被初始化。

另外，有些语句结构（如if、for等）需要条件满足时才会执行；Java编译器不认为在这些语句块中的赋值语句可以实现初始化操作。查看如下代码： int sum; int a = 20; int b = 10; if(a>0) {

sum = 0; // 当a大于0的时候，该语句才会执行。 sum = a + b; }

System.out.println(sum); // 编译错误，编译器认为sum没有初始化。

上述代码中，语句System.out.println(sum);处会出现编译错误，Java编译器不认为放在if语句块中的sum=0；可以实现初始化操作。 步骤四：变量的赋值与变量的类型不匹配

变量在声明时指定了类型，Java编译器会检测对该变量的操作是否与其类型匹配，如果对变量的赋值或者操作与其类型不匹配，会产生编译错误。 public static void main(String[] args) { int salary;

salary = 15000.50; // 编译错误,整型变量不可以赋予浮点值（小数）。 }

上述代码中，变量salary声明时的类型为int，后续赋值为15000.50，而15000.50是浮点类型，因此导致编译错误。整数类型变量不可以赋予浮点类型的值。 1.4 完整代码

本案例是总结性的知识，没有完整的代码。 2 整数类型（int、long）使用常见问题汇总 2.1 问题

在我们使用整数类型的过程中，会遇到一些问题，在此将这些问题进行汇总，在今后使用的过程中，避免出错。即使出现错误也可以很快的找到问题所在。 2.2 方案

整数类型在使用的过程中，常见的问题有以下几点： 1） 整数直接量超出了整数的范围。

2） 关于整数的除法：两个整数相除，会舍弃小数的部分，结果也是整数。

3） 整数运算的溢出：两个整数进行运算时，其结果可能会超过整数的范围而溢出。 4） 表示long直接量，需要以 L 或 l 结尾。 2.3 步骤

实现此案例需要按照如下步骤进行。 步骤一：整数直接量超出了整数的范围 int是最常用的整数类型。一个int类型的变量占用4个字节（32位），最大表示范围为：-2^31 ~ 2^31-1，即 -2147483648 ~2147483647。

整数直接量(literal)， 即直接写出的整数。整数的直接量的类型默认为int类型，如果直接写出的整数超过了int的表达范围，将会出现编译错误。请看如下代码： int d = 10000000000;

以上代码中，10000000000不属于int类型的直接量，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。 步骤二：关于整数的除法

在Java中，两个整数相除，会舍弃小数的部分，结果也是整数。请看如下代码： int c = 5/3;

System.out.println(c); // c的值为1

在上述代码中，运行后，c的值为1。说明两个整数相除，舍弃了小数部分，只保留了整数部分。

步骤三：整数运算的溢出

两个整数进行运算时，其结果可能会超过整数的范围而溢出，请看如下代码： int a = 2147483647; int b = -2147483648; a = a + 1;

b = b - 1;

System.out.println(\System.out.println(\上述代码运行后的输出结果为: a=-2147483648 b=2147483647

变量a最初的值为2147483647，是int类型的最大值，加1以后出现了溢出现象，a的值变成了int类型的最小值。而b变量最初赋的值为-2147483648，是int类型的最小值，减1以后出现了溢出现象，b的值变成了int类型的最大值。这显然不符合加法和减法的规则，所以，在今后使用的时候要注意类似的问题。 步骤四：表示long直接量，需要以 L 或 l 结尾

在表示整数时，如果int类型的范围不够，可以使用long型，一个long型的变量占用8个字节（64位），最大表示范围为：-2^63 ~ 2^63-1，即 -9223372036854775808 ~ 9223372036854775807。当一个直接量超过int类型的最大值时，那要用long类型来表示，如果要表示long直接量，需要以 L 或 l 结尾。请看下列代码： long a = 10000000000; // 会有编译错误 long b = 10000000000L;

上述代码中，10000000000超过了int类型的最大值，把它直接赋值给long类型会出现编译错误。需要像变量b那样在10000000000后边加L。 2.4 完整代码

本案例是总结性的知识，没有完整的代码。 3 浮点类型（float、double）使用常见问题汇总 3.1 问题

在我们使用浮点类型的过程中，会遇到一些问题，在此将这些问题进行汇总，在今后使用的过程中，避免出错。即使出现错误也可以很快的找到问题所在。 3.2 方案

浮点类型在使用的过程中，常见的问题有以下几点： 1） 浮点数的直接量为double类型。 2） 浮点数存在舍入误差问题。 3.3 步骤

实现此案例需要按照如下步骤进行。 步骤一：浮点数的直接量为double类型

浮点数，就是小数，包括： float和double。默认的浮点直接量为double型，如果需要表示float类型的直接量，需要加“f”或“F”后缀。请看如下代码： float f1 = 3.14 ；

以上代码，会出现编译错误。3.14是double类型的直接量，如果表示float类型的直接量应该写成3.14f。

步骤二：浮点数存在舍入误差问题

由于浮点数内部用二进制的方式来表示十进制，会存在舍入误差。二进制系统中无法精确的表示1/10，就好像十进制系统中无法精确的表示1/3一样。对于一些要求精确运算的场合会导致代码的缺陷。请看如下代码： double money = 3.0; double price = 2.9;

System.out.println(money - price);

上述代码的输出结果为： 0.10000000000000009

查看上述结果，并没有如我们想象的为0.1。如果需要精确的运算可以考虑放弃使用double或float而采用BigDecimal 类来实现。关于这一点，将在后续的章节中介绍。 3.4 完整代码

本案例是总结性的知识，没有完整的代码。 4 对char类型变量的各种赋值方式汇总 4.1 问题

在我们使用char类型的过程中，会遇到一些问题，在此将这些问题进行汇总，使今后使用的过程中，不出错。即使出现错误也可以很快的找到问题所在。 4.2 方案

char类型在使用的过程中，常见的问题有以下几点： 1） 字符类型存储中文。

2） char类型的值可以作为整数类型直接使用。 4.3 步骤

实现此案例需要按照如下步骤进行。 步骤一：字符类型存储中文

char类型是否可以存储中文？答案是肯定的。字符类型事实上是一个16位无符号整数，这个值是对应字符的编码, Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位字符直接量。对于中文，可以采用诸如： ‘中’ 的形式，也可以采用其对应的16进制的表示形式，例如： ‘\中’。 步骤二：整数类型和char类型的关系

char类型的值可以直接作为整数类型的值来使用，字符类型事实上是一个16位无符号整数，即全部是正数，表示范围是0～65535。请看如下代码： char zhong='疯'; int zhongValue=zhong; System.out.println(zhongValue); 上述代码的输出结果为： 30127

上述输出结果为0～65535范围的。

另外，如果把0~65535范围内的一个int整数赋给char类型变量，系统会自动把这个int类型整数当成char类型来处理。请看如下代码： char c=97;

System.out.println(c);

上述代码的输出结果为a。这说明系统自动把整数类型97当成char类型来处理，处理的结果为a，即，97为字母a的unicode码。 4.4 完整代码

本案例是总结性的知识，没有完整的代码。 5 类型转换常见问题汇总 5.1 问题

在我们数据类型转换的过程中，会遇到一些问题，在此将这些问题进行汇总，使今后使用的过程中，不出错。即使出现错误也可以很快的找到问题所在。 5.2 方案

数据类型转换在使用的过程中，常见的问题有以下几点：

1） 强制转换时的精度丧失和溢出。 2） 数值运算时的自动转换。

3） byte、char、short转换为int的问题。 5.3 步骤

实现此案例需要按照如下步骤进行。 步骤一：强制转换时的精度丧失和溢出

基本类型之间的相互转换，需要注意的是，强制转换时可能会造成精度的丧失和溢出，请看如下代码：

long l = 1024L * 1024 * 1024 * 4;

int j = (int) l; // 会产生溢出

System.out.println(j); // 结果为：0

上述代码输出的结果为0，是因为在将long类型变量l转换为int类型变量j的时候产生了溢出。

另外，请看如下精度丧失的例子： double pi = 3.141592653589793;

float f = (float) pi; // 会造出精度的损失 System.out.println(f); // 结果为：3.1415927

上述代码的输出结果为3.1415927，值保留了7位小数，这是因为将double类型的变量pi转换为float类型的变量f时造成了精度的损失。 步骤二：数值运算时的自动转换 多种基本类型参与的表达式运算中，运算结果会自动的向较大的类型进行转化。请看如下示例：

long distance = 10000 * 365 * 24 * 60 * 60 * 299792458L;

上述代码中，有int类型数据和long类型数据，由于有long型的直接量299792458L参与，整个表达式的结果为long。 double change = 800 - 599.0;

上述代码中，由于有double型的直接量599.0参与，整个表达式的结果为 double。 double persent1 = 80 / 100;

上述代码中，结果为0.0。右边都是int型数据，语法运算后的结果也为int类型，结果为0，再赋值给double型，将0转化为 0.0。请对比下面的代码： double persent2 = 80.0 / 100;

上述代码中，结果为0.8，右边表达式有double型直接量参与，运算结果为double型。 步骤三：byte、char、short转换为int的问题

byte、char、short 三种类型实际存储的数据都是整数，在实际使用中遵循如下规则： 1） int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。

2） byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。请看如下示例代码： byte b1=28; byte b2=20; byte b3=b1+b2;

上述代码在第三行会出现编译错误，原因是b1+b2的结果为int类型。改变上述代码如下： byte b1=28; byte b2=20; int b3=b1+b2;

查看上述代码，会发现不会再出现编译错误。char类型、short类型和byte类型是相似的。 5.4 完整代码

本案例是总结性的知识，没有完整的代码。 6 年龄判断程序 6.1 问题

本案例需要使用交互的方式判断年龄的范围：用户从控制台输入一个年龄，由程序判断该年龄是否在18～50之间。程序交互过程如图－1所示：

图- 1 6.2 步骤

实现此案例需要按照如下步骤进行。 步骤一：定义类及 main方法

首先定义一个名为 Age的类，并在类中添加Java应用程序的主方法main，代码如下所示： public class Age { public static void main(String[] args) { } }

步骤二：读取控制台输入

在main方法中，实例化Scanner类，并调用Scanner类的nextInt() 方法接收用户从控制台输入的年龄，使用完毕后将scanner对象关闭，以释放资源。代码如下所示： #cold_boldimport java.util.Scanner;

public class Age { public static void main(String[] args) { #cold_bold Scanner scanner = new Scanner(System.in); #cold_bold #cold_bold #cold_bold } }

System.out.println(\请输入年龄：\int age = scanner.nextInt(); scanner.close();

在此需要注意导入Scanner类所在的包。 步骤三：判断年龄所在的范围

接收到年龄后，判断年龄是否在18～50之间。如果输出结果为true，则说明年龄在18～50之间，否则，年龄不在18～50之间，代码如下所示： import java.util.Scanner;

public class Age { public static void main(String[] args) { Scanner scanner = new Scanner(System.in);

System.out.println(\请输入年龄：\ int age = scanner.nextInt(); #cold_bold System.out.println(age >= 18 && age <= 50); } }

在上述代码中，使用了“&&”逻辑运算符来连接两个条件。年龄在18～50之间，即，年龄大于等于18且年龄小于等于50，因此需要使用“&&”运算符。 6.3 完整代码

本案例的完整代码如下所示： import java.util.Scanner;

public class Age { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); }

}

System.out.println(\请输入年龄：\int age = scanner.nextInt(); scanner.close();

System.out.println(age >= 18 && age <= 50);

本文来源：https://www.bwwdw.com/article/ea53.html