本章介绍一些编程中的基本概念，比如：变量、常量、运算符、标识符等。这些是编程中的“砖块”，是编程的基础。 要想开始正式编程，还需要再学“控制语句”，控制语句就像“水泥”，可以把“砖块”粘到一起，最终形成“一座大厦”。
注释
为了方便程序的阅读，Java语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。
注释不会出现在字节码文件中，即Java编译器编译时会跳过注释语句。
在Java中根据注释的功能不同，主要分为单行注释、多行注释和文档注释
单行注释
单行注释使用“//”开头，“//”后面的内容均为注释。
多行注释
多行注释以“/*”开头以“*/”结尾，在“/*”和“*/”之间的内容为注释，在使用多行注释时注意，注释不能嵌套。
文档注释
文档注释以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签（后期再写项目时，可以生成项目的API）
【示例 1】注释
/**
* Welcome类（我是文档注释）
* @author admin
* @version 1.0
*/
public class Welcome {
//我是单行注释
public static void main(String[] args/*我是行内注释 */) {
System.out.println("Hello World!");
}
/*
我是多行注释！
我是多行注释！
*/
}标识符
标识符是用来来给变量、类和方法进行命名的，如age、name、gender等。标识符需要遵守一定的规则：
标识符必须以字母、下划线_、美元符号$开头。
标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
Java 标识符大小写敏感，且长度无限制。
标识符不可以是Java的关键字。
*标识符的使用规范
表示类名的标识符用大写字母开始。如：Man, GoodMan
表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。我们称之为“驼峰原则”，比如：eat(),eatFood()
Java不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集。因此，这里的字母的含义不仅仅是英文，还包括汉字等等。但是不建议大家使用汉字来定义标识符！
【示例 2】合法的标识符
int a = 3;
int _123 = 3;
int $12aa = 3;
int 变量1 = 55;
【示例 3】不合法的标识符
int 1a = 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
变量(variable)
变量的本质
变量的本质，就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。 我们可以通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。
Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。 比如，int a=3; 表示a变量的空间大小为4个字节。
变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。
·变量的声明
格式为：
type varName [=value][,varName[=value]...]; //[]中的内容为可选项，即可有可无
数据类型 变量名 [=初始值] [,变量名 [=初始值]…];
【示例 4】 声明变量
double salary ;
long earthPopulation ;
int age ;int i ,j; // 两个变量的数据类型都是int 并不推荐，逐一声明每一个变量可以提高程序可读性
不同数据类型的常量会在内存中分配不同的空间，如图1所示。
图1声明变量的内存示意图
＊注意事项
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量的分类
从整体上可将变量划分为局部变量、成员变量(也称为实例变量)和静态变量。
【表1】局部变量、成员变量、静态变量的区别
| 类型 | 声明位置 | 从属于 | 生命周期 |
| 局部变量 | 方法或语句块内部 | 方法/语句块 | 声明位置开始，直到方法或语句块执行完毕，局部变量消失 |
| 成员变量 (实例变量) | 类内部，方法外部 | 对象 | 对象创建，成员变量也跟着创建。对象消失，成员变量也跟着消失； |
| 静态变量 (类变量) | 类内部，static修饰 | 类 | 类被加载，静态变量就有效；类被卸载，静态变量消失。 |
方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。
【示例 7】局部变量
public void test() {
int i;
int j = i+5 ; // 编译出错，变量i还未被初始化
}public void test() {
int i;
i=10;
int j = i+5 ; // 编译正确
}
| 数据类型 | 实始值 |
| int | 0 |
| double | 0.0 |
| char | ‘\u0000’ |
| boolean | false |
【示例 8】实例变量的声明
public class Test {
int i;
}· 静态变量（类变量 static variable）
使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。 (注：讲完内存分析后我们再深入！先放一放这个概念！)如果不自行初始化，他与成员变量相同会自动初始化成该类型的默认初始值，如表2所示。
常量(Constant)
常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、’c’true，false，”helloWorld”等等。
在Java语言中，主要是利用关键字final来定义一个常量。 常量一旦被初始化后不能再更改其值。
声明格式为：final type varName =value ;
【示例 9】常量的声明及使用
public class TestConstants {
public static void main(String[] args) {
final double PI = 3.14;
// PI = 3.15; //编辑错误，不能再被赋值！
double r = 4;
double area = PI * r * r;
double circle = 2 * PI * r;
System.out.println("area = " + area);
System.out.println("circle = " + circle);
}
}变量和常量命名规范
所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则 : monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则: Man, GoodMan
方法名：首字母小写和驼峰原则: run(), runRun()
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
基本数据类型(primitive data type)
•Java是一种强类型语言，每个变量都必须声明其类型。
•Java的数据类型分为两大类：基本类型（primitive type）和引用类型（reference type）
•Java中定义了3类8种基本数据类型
•逻辑型－boolean
•文本型－char
•数值型－byte, short, int, long, float, double
＊注意事项
·引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！
整型变量/整形变量
整型用于表示没有小数部分的数值，它允许是负数。
整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。于此相反，C和C++程序需要针对不同的处理器选择最有效的整形。
| 类型 | 占用存储空间 | 表数范围 |
| Byte | 1字节 | -128~127 |
| Short | 2字节 | -215 ~ 215-1 （-32768~32767） |
| Int | 4字节 | (-2147483648~2147483647) 约21亿 |
| Long | 8字节 | -263 ~ 263-1 |
• Java语言整型常数的三种表示形式：
• 十进制整数，如：99, -500, 0。
• 八进制整数，要求以 0 开头，如：015。
• 十六进制数，要求 0x 或 0X 开头，如：0x15 。
• 二进制数，要求0b或0B开头，如：0b01110011 。
• Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，
如：
【示例10】长整型常数的声明
longa = 55555555; //编译成功，在int表示的范围内(21亿内)。
longb = 55555555555;//不加L编译错误，已经超过int表示的范围。
报错：The literal 55555555555 of type int is out of range，所以我们需要修改代码为：
longb = 55555555555L;浮点型变量/常量
带小数的数据在Java中称为浮点型。浮点型可分为float类型和double类型。
| 类型 | 占用存储空间 | 表数范围 |
| Float | 4字节 | -3.403E38~3.403E38 |
| Double | 8字节 | -1.798E308~1.798E308 |
• float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
• double表示这种类型的数值精度是float类型的两倍，又被称作双精度，绝大部分应用程序都采用double类型。
• Java浮点类型常量有两种表示形式
• 十进制数形式，例如: 3.14 314.0 0.314
• 科学记数法形式，如： 314e2 314E2 314E-2
【示例11】使用科学记数法给浮点型变量赋值
double f = 314e2; //314*10^2-->31400.0
double f2 = 314e-2; //314*10^(-2)-->3.14 【示例12】float类型赋值时需要添加后缀F/f
float f = 3.14F;
double d1= 3.14;
double d2 = 3.14D;【示例13】浮点数的比较
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");/输出结果为d1==d2
}else{
System.out.println("d1!=d2");
} 运行以上两个示例，发现示例13的结果是“false”，而示例14的输出结果是“d1==d2”。这是因为由于字长有限由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。 浮点数一般都存在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。
Java.Math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。
＊注意：不要使用浮点数进行比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用BigDecimal
【示例1４】使用BigDecimal进行浮点数的比较
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
BigDecimal bd = BigDecimal.valueOf(1.0);
bd = bd.subtract(BigDecimal.valueOf(0.1);
bd = bd.subtract(BigDecimal.valueOf(0.1);
bd = bd.subtract(BigDecimal.valueOf(0.1);
bd = bd.subtract(BigDecimal.valueOf(0.1);
bd = bd.subtract(BigDecimal.valueOf(0.1);
Syetem.out.println(bd);
Syetem.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1);//0.5000000000000001
}
}浮点数使用总结
默认是double类型
浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
避免比较中使用浮点数，需要比较请使用BigDecimal类
字符型变量/常量
• 字符型在内存中占有2个字节，在Java中使用单引号来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示含有一个字符的字符串。
•char 类型用来表示在Unicode编码表中的字符。Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符。
【示例1５】字符型举例
char eChar = 'a';
char cChar ='中'; 【示例1６】字符型的十六进制值表示方法
char c = '\u0061'【示例1７】转义字符
char c2 = '\n'; //代表换行符 | 转义符 | 含义 | Unicode值 |
| \b | 退格（backspace） | \u0008 |
| \n | 换行 | \u000a |
| \r | 回车 | \u000d |
| \t | 制表符（tab） | \u0009 |
| \“ | 双引号 | \u0022 |
| \‘ | 单引号 | \u0027 |
| \\ | 反斜杠 | \u005c |
注：String类，其实是字符序列(char sequence)。
bolean类型：
• boolean类型有两个值，true和false,在内存中占一位（不是一个字节），不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
• boolean类型用来判断逻辑条件，一般用于程序流程控制 。
【示例1８】boolean类型
boolean flag ;
flag = true; //或者flag=false;
if(flag) {
// true分支
} else {
// false分支
} ＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
运算符(operator)
计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。
【表】运算符分类
| 算数运算符 | 二元运算符 | +，-，*，/，% |
| 一元运算符 | ++，-- | |
| 赋值运算符 | = | |
| 扩展运算符 | +=，-=，*=，/= | |
| 关系运算符 | >，<，>=，<=，==，!= instanceof | |
| 逻辑运算符 | &&，||，! | |
| 位运算符 | &，|，^，~ ， >>，<<，>>> | |
| 条件运算符 | ?: | |
| 字符串连接符 | + | |
二元运算符：
二元运算符指的是需要两个操作数才能完成运算的运算符。
二元运算符的运算规则：
整数运算：
如果两个操作数有一个为Long, 则结果也为long，
没有long时，结果为int。即使操作数全为shot,byte，结果也是int。
浮点运算：
如果两个操作数有一个为double, 则结果为double.
只有两个操作数都是float, 则结果才为float.
取模运算：
其操作数可以为浮点数,一般使用整数，结果是“余数”,“余数”符号和左边操作数相同。如：7%3=1,-7%3=-1,7%-3=1
算术运算符中++，--属于一元运算符，该类运算符只需要一个操作数。
【示例19】一元运算符++与--
int a = 3;
int b = a++; //执行完后,b=3。先给b赋值，再自增。
System.out.println("a="+a+"\nb="+b);
int c = ++a; //执行完后,c=5。a先自增，再给c赋值
System.out.println("a="+a+"\nc="+c);赋值及其扩展赋值运算符：
【表】赋值及其扩展赋值运算符
| 运算符 | 用法举例 | 等效的表达式 |
| += | a += b | a = a+b |
| -= | a -= b | a = a-b |
| *= | a *= b | a = a*b |
| /= | a /= b | a = a/b |
| %= | a %= b | a = a%b |
【示例20】扩展运算符
int a=3;
int b=4;
a+=b;//相当于a=a+b;
System.out.println("a="+a+"\nb="+b);
a=3;
a*=b+3;//相当于a=a*(b+3)
System.out.println("a="+a+"\nb="+b);关系运算符
关系运算符用来进行比较运算，如表所示。关系运算的结果是布尔值：true/false；
【表】关系运算符
| 运算符 | 含义 | 示例 |
| == | 等于 | a==b |
| != | 不等于 | a!=b |
| > | 大于 | a>b |
| < | 小于 | a<b |
| >= | 大于或等于 | a>=b |
| <= | 小于或等于 | a<=b |
＊注意事项
1. =是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。
2. ==、!= 是所有（基本和引用）数据类型都可以使用
3. > 、>=、 <、 <= 仅针对数值类型（int double char）
逻辑运算符
Java中的逻辑运算符如表所示。逻辑运算的操作数和运算结果都是boolean值。
【表】逻辑运算符
| 运算符 | 说明 | |
| 逻辑与 | &( 与) | 两个操作数为true，结果才是true，否则是false |
| 逻辑或 | |(或) | 两个操作数有一个是true，结果就是true |
| 短路与 | &&( 与) | 只要有一个为false，则直接返回false |
| 短路或 | ||(或) | 只要有一个为true，则直接返回true |
| 逻辑非 | !（非） | 取反：!false为true，!true为false |
| 逻辑异或 | ^（异或） | 相同为false，不同为true |
短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。
【示例21】短路与和逻辑与
//1>2的结果为false，那么整个表达式的结果即为false，将不再计算2>(3/0)
booleanc =1>2 && 2>(3/0);
System.out.println(c);
//1>2的结果为false，那么整个表达式的结果即为false，还要计算2>(3/0)，0不能做除数，//会输出异常信息
booleand =1>2 & 2>(3/0);
System.out.println(d);位运算符：
位运算指的是进行二进制位的运算，常用的位运算符如表所示。
【表】位运算符
| 位运算符 | 说明 |
| ~ | 取反 |
| & | 按位与 |
| | | 按位或 |
| ^ | 按位异或 |
| << | 左移运算符，左移1位相当于乘2 |
| >> | 右移运算符，右移1位相当于除2取商 |
【示例22】左移运算和右移运算
int a = 3*2*2;
int b = 3<<2; //相当于：3*2*2;
int c = 12/2/2;
int d = 12>>2; //相当于12/2/2;
*注意：
· 不要将“&&”和“&”、“||”和“|”、“！”和“~”混为一谈！这是两个完全不同的运算符。
· 不要把“^”当做数学运算“乘方”，是“位的异或”操作。
【示例23】连接符”+”
int a=12;
System.out.println("a="+a);//输出结果:a=12【示例24】三目条件运算符
int score = 80;
int x = -100;
String type =score<60?"不及格":"及格";
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type);
System.out.println("flag= "+ flag);运算符优先级的问题
【表】运算符的优先级
| 优先级 | 运算符 | 类 | 结合性 |
| 1 | () | 括号运算符 | 由左至右 |
| 2 | !、+（正号）、-（负号） | 一元运算符 | 由左至右 |
| 2 | ~ | 位逻辑运算符 | 由右至左 |
| 2 | ++、-- | 递增与递减运算符 | 由右至左 |
| 3 | *、/、% | 算术运算符 | 由左至右 |
| 4 | +、- | 算术运算符 | 由左至右 |
| 5 | <<、>> | 位左移、右移运算符 | 由左至右 |
| 6 | >、>=、<、<= | 关系运算符 | 由左至右 |
| 7 | ==、!= | 关系运算符 | 由左至右 |
| 8 | & | 位运算符、逻辑运算符 | 由左至右 |
| 9 | ^ | 位运算符、逻辑运算符 | 由左至右 |
| 10 | | | 位运算符、逻辑运算符 | 由左至右 |
| 11 | && | 逻辑运算符 | 由左至右 |
| 12 | || | 逻辑运算符 | 由左至右 |
| 13 | ? : | 条件运算符 | 由右至左 |
| 14 | =、+=、-=、*=、/=、%= | 赋值运算符、扩展运算符 | 由右至左 |
逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）
如：a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
数据类型的转换
自动类型转换
自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。在下图所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会精度的损失。
可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围
【示例25】自动类型转换特例
short b = 12; //合法
short b = 1234567; //非法1234567超出了short的表数范围
强制类型转换
强制类型转换(Cast)，又被称为造型，用于显式的转换一个数值的类型。 在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
语法格式：(type)var
运算符“()”中的type表示将值var想要转换成的目标数据类型。
【示例26】强制类型转
double x = 3.14;
int nx = (int)x; //值为3
char c = 'a';
int d = c+1;
System.out.println(nx);
System.out.println(d);
System.out.println((char)d);【示例27】强制类型转换特例
int x = 300;
byte bx = (byte)x; //值为44
基本类型转化时常见错误和问题
操作比较大的数时，要留意是否溢出，尤其是整数操作时。
【示例28】常见问题一
int money = 1000000000; //10亿
int years = 20;
int total = money*years; //返回的是负数
long totall = money*years; //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
long total2 = money*((long)years); //先将一个因子变成long，整个表达式发生提升。全部用long来计算。
简单的键盘输入和输出
为了我们能写出更加复杂的程序，可以让我们的程序和用户可以通过键盘交互，我们先学习一下简单的键盘输入和输出。
import java.util.Scanner;
public class Welcome{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//将输入的一行付给string1
String string1 = scanner.nextLine();
//将输入单词到第一个空白符为止的字符串付给string2
String string2 = scanner.next();
//将输入的数字赋值给变量
int a = scanner.nextInt();
System.out.println("-----录入的信息如下-------");
System.out.println(string1);
System.out.println(string2);
System.out.println(a*10);
}
};
3062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
