（二）Java的基本程序结构（一）---注释、数据类型、变量、标识符、运算符、字符串

Java的基本程序结构（一）—注释、数据类型、变量、标识符、运算符、字符串

---

前言

假设已经成功安装了JDK，现在开始介绍程序设计，本节学习知识点： 1.一个简单的Java应用程序 2.注释 3.数据类型 4.变量与常量 5.标识符 6.运算符 7.字符串

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、一个简单的Java应用程序

示例：

public class FirstSample {
	public static void main(String[] args) {
		System.out.println("We will not use 'Hello,World!'");
		System.out.println("Java"); 
		System.out.println();
	}
}

首先Java是区分大小写的，如果出现大小写拼写错误（如System写成system）,程序将无法运行。

public：访问修饰符，用于控制程序的其他部分对这段代码的访问级别。
class：表名Java程序中的全部内容都包含在类中。
类名：关键字class后面紧接类名。名字必须以字母开头，后面可以跟字母和数字的任意组合。长度上基本上没有限制。但是不能使用Java保留字（如public和class）。
{}：在Java中，用大括号划分程序的各个部分（通常简称为“块”），Java中任何方法的代码都用“ { ”开始，用“ } ”结束。
语句：每个句子用分号结束，回车不是语句的结束标志。

类名的命名规范：类名是以大写字母开头的名词。如果名字由多个单词组成，每个单词的第一个字母都应该大写（这种在一个单词中间使用大写字母的方式称为骆驼命名法camel case）。源代码的文件名必须与公共类的名字相同，并用.Java作为扩展名。

运行已编译的程序时，Java虚拟机总是从指定类中的main方法的代码开始执行，这里“方法”就是Java中的“函数”，因此未来代码能够执行，在类的源文件中必须包含一个main方法。

---

二、注释

注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。

Java中的注释分为三种：
单行注释：单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。

// 这里是单行注释

多行注释：多行注释的格式是使用/* 和 */将一段较长的注释括起来。

/*
* 这里是多行注释
* 这里是多行注释
*/

文档注释：文档注释以 /** 开始，以 */ 结束。

/**
* 这里是文档注释
* 这里是文档注释
*/

注意：在Java中，/* */ 注释不能嵌套。也就是说，不能简单的把代码用/*和*/括起来作为注释，因为这段代码本身可能也包含一个*/界定符。

---

三、数据类型

计算机的存储单元
我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位 （bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，
通常用大写字母”B”表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，其换算单位如下：

1B（字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

Java中的数据类型
Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
一共有八种基本类型，其中有4种整形，2种浮点类型，1种字符类型，1种用于表示真值的boolean类型。

数据类型	关键字	内存占用	取值范围
整型类型	byte	2	-128~127
	short	2	-32768~32767
	int(默认)	4	-2的31次方到2的31次方-1
	long	8	-2的63次方到2的63次方-1
浮点类型	float	4	负数：-3.402823E+38到-1.401298E-45 正数： 1.401298E-45到3.402823E+38
	double(默 认)	8	负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324 到1.797693E+308
字符类型	char	2	0-65535
布尔类型	boolean	1	true，false

在java中整数默认是int类型，浮点数默认是double类型。

---

四、变量与常量

1、变量

变量：在程序运行过程中，其值可以发生改变的量。从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

在Java中，每个变量都有一个类型（type）。在声明变量时，先指定变量的类型，然后是变量名。

1.变量名必须是一个以字母开头并由字母或数字构成的序列。
2.与大多数程序设计语言相比，Java中“字母”和“数字”的范围更大。字母包括‘A’-‘Z’、‘a’-‘z’、‘_’、‘$’。
3.变量名中所有字符都是有意义的，并且大小写敏感，长度基本上没有限制。

变量的定义格式

数据类型 变量名 = 初始化值; // 声明变量并赋值 
int age = 18; 
System.out.println(age);

或者

// 先声明，后赋值（使用前赋值即可） 
数据类型 变量名; 
变量名 = 初始化值; 
double money; 
money = 55.5; 
System.out.println(money);

还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

// 定义int类型的变量a和b，中间使用逗号隔开
int a = 10, b = 20; 
System.out.println(a); 
System.out.println(b); 
// 声明int类型的变量c和d，中间使用逗号隔开
int c,d;  
c = 30; d = 40; 
System.out.println(c); 
System.out.println(d);

变量的使用： 通过变量名访问即可。

使用变量时的注意事项

1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。

2、常量

常量：在程序运行过程中，其值不可以发生改变的量。

关键字final

在Java中，利用关键字final指示常量。例如;

final double PI=3.14;
System.out.println(PI);

关键字final表示这个变量只能被赋值一次。一旦被赋值，就不能再更改了。习惯上，常量名使用全大写。

Java中的常量分类：
字符串常量： 用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、“abc”、"中国"等
整数常量 ：整数，例如：-10、0、88等
小数常量 ：小数，例如：-5.5、1.0、88.88等
字符常量 ：用单引号括起来的一个字符，例如：‘a’、‘5’、‘B’、'中’等
布尔常量 ：布尔值，表示真假，只有两个值true和false
空常量 ：一个特殊的值，空值，值为null
除空常量外，其他常量均可使用输出语句直接输出。

---

五、标识符

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。

Java中标识符的组成规则

1.由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
2.不能使用java中的关键字作为标识符。
3.标识符对大小写敏感（区分大小写）。

Java中标识符的命名约定：
小驼峰式命名：变量名、方法名
首字母小写，从第二个单词开始每个单词的首字母大写。
大驼峰式命名：类名
每个单词的首字母都大写。
另外，标识符的命名最好可以做到见名知意

---

六、运算符

1、运算符和表达式

运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式。

例如：

int a = 10; 
int b = 20; 
int c = a + b;
+：是运算符，并且是算术运算符。
a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。

2、算数运算符

符号	作用
+	加
-	减
*	乘
/	除
%	取余

当参与 / 运算的两个操作数都是整数时，表示整数除法；否则表示浮点数除法。整数的求余操作用%表示，例如15/2=7、15%2=1、15.0/2=7.5.

注意：
/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

int a = 10; 
int b = 3; 
System.out.println(a / b); // 输出结果3 
System.out.println(a % b); // 输出结果1

3、赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意

扩展的赋值运算符隐含了强制类型转换。
short s = 10; s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

4、自增自减运算符

符号	作用	说明
++	自增	变量的值加1
–	自减	变量的值减1

注意事项：
++和-- 既可以放在变量的后边，也可以放在变量的前边。
1.单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
2.参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
3.参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。

例如：

int i = 10; 
i++; // 单独使用 
System.out.println("i:" + i); // i:11 

int j = 10; 
++j; // 单独使用 
System.out.println("j:" + j); // j:11 

int x = 10; 
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10 

int m = 10; int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1 
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

5、关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a<b，判断a是否小于b，成立为true，不成立为false
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

注意事项：
关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把“= =”误写成 “=”，"= =“是判断是否相等的关系，”="是赋值。

int a = 10; 
int b = 20; 
System.out.println(a == b); // false 
System.out.println(a != b); // true 
System.out.println(a > b); // false 
System.out.println(a >= b); // false 
System.out.println(a < b); // true 
System.out.println(a <= b); // true 
// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 
boolean flag = a > b; System.out.println(flag); // 输出false

6、逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
	逻辑或	a
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

//定义变量 
int i = 10; 
int j = 20; 
int k = 30; 
//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false 
System.out.println((i > j) & (i > k)); //false & false,输出false 
System.out.println((i < j) & (i > k)); //true & false,输出false 
System.out.println((i > j) & (i < k)); //false & true,输出false 
System.out.println((i < j) & (i < k)); //true & true,输出true 
System.out.println("--------"); 
//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true 
System.out.println((i > j) | (i > k)); //false | false,输出false 
System.out.println((i < j) | (i > k)); //true | false,输出true 
System.out.println((i > j) | (i < k)); //false | true,输出true 
System.out.println((i < j) | (i < k)); //true | true,输出true 
System.out.println("--------"); 
//^ “异或”，相同为false，不同为true 
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false 
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true 
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false 
System.out.println("--------"); 
//! “非”，取反 
System.out.println((i > j)); //false 
System.out.println(!(i > j)); //!false，,输出true

短路逻辑运算符

&&（短路“与”）
如果左边为真，右边执行；如果左边为假，右边不执行。
||（短路“或”）
如果左边为假，右边执行；如果左边为真，右边不执行。

&&和||运算符都是按照“短路”方式来求值的：如果第一个操作数已经能确定表达式的值，第二个操作数就不需要计算了。
不过&和|运算符不采用“短路”方式求值，也就是说，得到计算结果之前，两个操作数都需要计算。

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

// 定义变量
int i = 10;
int j = 20;
int k = 30;
		
// & “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) && (i > k)); // false & false,输出false
System.out.println((i < j) && (i > k)); // true & false,输出false
System.out.println((i > j) && (i < k)); // false & true,输出false
System.out.println((i < j) && (i < k)); // true & true,输出true

// | “或”，或者的关系，只要表达式中有一个值为true，结果即为true 
System.out.println((i > j) || (i > k)); //false | false,输出false 
System.out.println((i < j) || (i > k)); //true | false,输出true 
System.out.println((i > j) || (i < k)); //false | true,输出true 
System.out.println((i < j) || (i < k)); //true | true,输出true 

7、三元运算符

三元运算符语法格式：
关系表达式 ? 表达式1 : 表达式2;

解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。

int a = 10; int b = 20; int c = a > b ? a : b; 
// 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

8、类型转换

在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换。

自动类型转换：
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。例如：

double num = 10; // 将int类型的10直接赋值给double类型 System.out.println(num); // 输出10.0

强制类型转换：
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;

double num1 = 5.5; int num2 = (int) num1; // 将double类型的num1强制转换为int类型 System.out.println(num2); // 输出5（小数位直接舍弃）

因为强制类型转换是通过截断小数部分将浮点值转换为整型。如果想要对浮点数进行舍入运算，以便得到最接近的整数，那就需要使用Math.round()方法。

double x = 9.997;
int n = (int)Math.round(x); //n的值为10
当调用round的时候，任然需要使用强制类型转换（int），因为round方法返回的结果为long类型，由于存在信息丢失的可能性，所以只有使用显示的强制类型转换才能够将long类型转换成int类型。

说明
1.char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a’对应97。

int a = ‘a’;
System.out.println(a); // 将输出97

---

七、字符串

1、字符的“+”操作

char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值：
‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加。
‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加。
‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加。

// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少 
char ch1 = 'a'; 
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98 
char ch2 = 'A'; 
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66 
char ch3 = '0'; 
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型。
等级顺序：byte,short,char --> int --> long --> float --> double

2、字符串

Java没有内置的字符串类型，而是在标准的Java类库中提供了一个预定义类，很自然的叫做String。每个用双引号括起来的字符串都是String类的一个实例。
例如：

String string = ""; //an empty string
String greet = "Hello";

子串

string类的substring方法可以从一个较大的字符串提取出一个子串。
例如：

String greetString = "Hello";
String s = greetString.substring(0, 3);
System.out.println(s);  //输出Hel

substring的第二个参数是不想复制的第一个位置。这里复制位置为0，1，2的字符，直到3为止，但不包括3。

字符串的“+”操作

当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。

System.out.println("itheima"+ 666); // 输出：itheima666

在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

System.out.println(1 + 99 + "Name"); // 输出：199Name 
System.out.println(1 + 2 + "Name" + 3 + 4); //输出：3Name34 
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 +"Name" + (3 + 4)); // 输出：3Name7

检测字符串是否相等

可以使用equals方法检测两个字符串是否相等。对于表达式：
s.equals(t)
如果字符串s与字符串t相等，则返回true；否则返回false。需要注意的是，s和t可以是字符串变量，也可以是字符串字面量。
例如：“hello”.equals(greeting)。

要想检测两个字符串是否相等，而不区分大小写可以使用equalsIgnoreCase方法。

一定不要使用==运算符检测两个字符是否相等！这个运算符只能够确定两个字符串是否放在同一个位置上。当然，如果两个字符串放在同一个位置上，他们必然相等。

3、构建字符串

如果需要许多小段的字符串来构建一个字符串，那么应该按照下列步骤进行。
首先构建一个空的字符串构建器：
StringBuilder builder = new StringBuilder();
当每次需要添加一部分内容时，就调用append方法。

String str = "jiayou";
builder.append("ch");
builder.append(str);

在字符串构建完成时就调用toString方法，将可以得到一个String对象，其中包含了构建器中的字符序列。

String comleteString = builder.toString();
System.out.println(comleteString);  //chjiayou
System.out.println(comleteString.length());  //8

---

总结

一步一个脚印，lyy加油！