Java标识符
标识符用来表示变量、方法或类等的名字。
定义的规则如下：
-
- 只能包含字母、数字、下划线和美元符号$。
- 不能以数字开头
- 严格区分大小写，如 a 和 A 是不同的标识符
- 没有长度限制
注意：标识符的命名应该有自明性（见名知意），看到名字就可以知道这个标识符表示的内容。
下面是一些合法的标识符（名称）：
myName，My_name，Points，$points,_sys_ta，OK，_23b，_3_
以下是一些非法的标识符：
2thupk，high-dig，Not/ok，#name
使用标识符进行命名的时候，我们会遵循下面的定义风格：
-
- 变量名：第一个单词的字母小写，后面每个单词的首字母大写。如person，personName。
- 方法名：第一个单词首字母小写，后面每个单词的首字母大写。如eat()，showName()。
- 类名：以大写字母开头。如Home，Hello。
- 常量：全部大写。如PI，NUMBER。
注意：定义风格与语法没有关系，但是一个优秀的程序员都会按照这个要求规范自己的代码。
关键字和保留字
正确识别Java语言的关键字（keyword）和保留字（reserved word）是十分重要的。
Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。
保留字是java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
所以我们在等一标识符的时候，不能与它们冲突，否则代码不能正常执行。
目前的保留字：const，goto
关键字如下：
| abstract | break | byte | boolean | catch |
| case | char | class | continue | default |
| do | double | else | extends | false |
| final | while | for | finally | if |
| import | implements | int | interface | instanceor |
| long | float | native | new | null |
| package | private | protected | public | return |
| switch | synchronized | short | static | super |
| try | true | this | throw | throws |
| threadsafe | transient | void | volatile | strictfp |
分隔符
空格、圆括号、花括号、分号等。
每条语句无论一行还是多行都以分号结束。
代码块（Block）是包含在{}里面的多条语句，块可以嵌套。
空白由一个或多个空格组成，也可以由一个或多个tab空格组成。
| 分隔符 | 名称 | 功能说明 |
| {} | 大括号（花括号） | 用来定义程序块、类、方法以及局部范围，也用来包括自动初始化的数组的值。 |
| [] | 中括号 | 用来进行数组的声明，也用来表示撤销对数组值的引用。 |
| () | 小括号（圆括号） | 在定义和强调方法时用来容纳参数表。在控制语句或强制类型转换组成的表达式中用来表示执行或计算的优先权。 |
| ; | 分号 | 用来表示一条语句的结束。 |
| , | 逗号 | 在变量声明中，用于分隔变量表中的哥哥变量。分隔函数中的参数。 |
| . | 点 | 用来将软件包的名字与它的子包或类分隔。也用来将引用变量与变量或方法分隔。 |
注释
Java支持单行及多行注释，注释中的内容会被编译器忽略。
单行注释：以换行符结束。语法：
//......
多行注释：可同时注释很多内容。语法：
/*...... ......*/
文档注释：可使用javadoc工具从源代码和文档注释中将信息取出，转换为html文件。语法：
/** .......... .......... */
Java数据类型划分
基本数据类型
| 类型名称 | 长度（bit） | 最大值 | 最小值 | 默认值 | 示例 |
| byte | 8 | 127 （2^7-1） | -128 (-2^7) | 0 | byte a=10; |
| short | 16 | 32767 (2^15-1) | -32768 (-2^15) | 0 | short b =10; |
| int | 32 | 2^31-1 | -2^31 | 0 | int c =10; |
| long | 64 | 2^63-1 | -2^63 | 0L | long d =10L; |
| float | 32 | 0.0f | float e =1.23f; | ||
| double | 64 | 0.0d | double f=1.23; | ||
| char | 16 | \\uffff | \\u0000 | \\u0000 | char g=‘a‘; |
| boolean | 1 | 只有两个取值：true，false | false | boolean h=true; | |
变量和常量
变量：用于标识数据的存储单元，可用于数据存储和运算。各种类型的变量创建后都有默认值。
变量的定义一般格式如下：
<数据类型><变量标识符>=<值>;
double x = 3.1415;
变量赋值后可以修改，格式如下：
<变量标识符>=<值>;
x = 1.2345;
注意：在Java中，所有的变量在使用之前必须声明。
常量有字面量和符号量两种。
字面量表示基本数据类型的源代码，如整型字面量：6
符号常量指用标识符表示的常量。
定义的一般格式如下：
<final><数据类型><符号常量标识符>=<常量值>;
例如：
final double PI = 3.1415926; final int COUNT=1000;
注意：常量一旦赋值不能修改。
实型数据
实型常量
用十进制数形式表示，由数字和小数点组成，例如：3.25。
用科学计数法形式表示，例如：123E-3。
数后加f或F为float，加d或D为double，没有后缀修饰的则缺省为double类型。
实型变量
实型变量按长度分为：float和double。
双精度浮点型double比单精度浮点型float的精度更高，表示的数据的范围更大。
三个特殊浮点值
正无穷大：Double.POSITIVE_INFINITY
负无穷大：Double.NEGATIVE_INFINITY
非数字：Double.NaN
注意：Double.NaN=Double.NaN的值为true。
字符型数据
字符常量是单引号括起来的一个字符，如：‘J‘、‘*‘。
Java中有以反斜杠（\\）开头的字符，反斜杠将其后的字符转变为另外的含义，称为转义字符。
| 转义字符 | 名称 | Unicode值 |
| \\b | 退格 | \\u0008 |
| \\t | 制表 | \\u0009 |
| \\n | 换行 | \\u000a |
| \\r | 回车 | \\u000d |
| \\" | 双引号 | \\u0022 |
| \\‘ | 单引号 | \\u0027 |
| \\\\ | 反斜杠 | \\u005c |
Java中的字符型数据是16位的Unicode字符，汉子和英文字母占的内存空间相同。
"Java你好"共12个字节。
字符变量的定义如下：
char ch=‘c’;
字符串常量数据
字符串常量是使用双引号括起来的字符序列。
例如：
"Let‘s learn Java!"; String str = "Hello world";
字符串变量作为对象来处理，通过String和StringBuffer类的构造方法来定义。
String s = new String();
布尔型数据
布尔型常量值只有：true和false。
布尔型变量为boolean类型，取值为true和false。例如：
boolean b =true;
示例代码
1 //java数据类型 2 public class DataType{ 3 public static void main(String args[]){ 4 //变量是用来存储和操作数据的 5 //数据类型 变量名称=值 6 //byte 大小8位 7 byte a = 1; //定义一个字节型（byte）变量并赋值为1 8 a=2; //变量值可以改变 9 //a=200 //数值过大 10 System.out.println("a="+a); //输出变量 11 12 //short 大小16位 13 short b =200; 14 System.out.println("b="+b); 15 16 //int 大小32位 17 int c =21543; 18 //c = 141343141341; //数值过大 19 System.out.println("c="+c); 20 21 //long 大小63位 最大表示2^63-1 22 long d = 12344444444L; 23 //注意：整型字面量默认是int 表示长整型字面量要在最后加l或者L 24 //d = 1431242342341242; 25 System.out.println("d="+d); 26 27 //float 32位 28 //注意：小数的字面量默认是double，表示float字面量后加f或者F 29 float e = 1.23f; 30 System.out.println("e="+e); 31 32 //double 64位 33 double f = 3.14; 34 System.out.println("f="+f); 35 36 //char 16位（unicode） 37 char aa=‘男‘; //将字符放在单引号中只能1个字符 38 aa = 10; 39 aa = ‘\\u0041‘; 40 //转义字符，用\\改变字符的含义，例如\\n表示换行，\\‘表示单引号等 41 System.out.println("aa="+aa); 42 43 //boolean 1位 44 //布尔值只有true和false两个取值 45 boolean bb=false; 46 System.out.println("bb="+bb); 47 48 //常量 final 49 //常量赋值后不可修改 50 final double PI=3.1415926; 51 //PI=3.14; 52 System.out.println("PI="+PI); 53 54 } 55 }
类型转换
自动类型转换：低优先级的数据自动会转换为高优先级的数据
byte->short->char->int->long->float->double
强制类型转换：优先级高的数据转换成优先级低的数据。例如：
double d =3.14159d; int a=(int)d;
如果下列两个条件都满足，那么将一种类型的数据赋给另一种类型变量时，讲执行自动类型转换。
- 两种类型兼容
- 目标数据类型的取值范围比源数据类型的取值范围大
当满足以上两个条件时，自动的“加宽转换”就可以进行。
例如：将一个byte值赋给int类型的变量
byte a =10; int x =a;
对于加宽转换，数字类型，包括整数和浮点类型都是彼此兼容的，但是数字类型和字符类型或布尔类型是不兼容的。字符类型和布尔类型也是互相不兼容的。
当需要将int型的值赋给一个byte型的变量时该怎么办？
此时，只有采用被称为“变窄转换”的转换方式。因为你肯定要将源数据的值变小才能适合目标数据类型。
在这种情况下，就必须进行强制类型转换。所谓的强制类型转换是一种显示的类型变换方式，其通用格式：(target-type) value
其中，目标类型(target-type)制定了要将指定值所转换成的类型。
例如，下面的程序段将int型强行转换成byte型。
int a; byte b; b = (byte)a;
当把一个浮点值赋给整数类型时，将发生一种不同的类型转换：截断
即当把浮点值赋给整数类型时，它的小数部分将被舍去。
例如，如果将值1.23赋给一个整数，其结果只是1,0.23被舍弃。
当然，如果浮点值太大而不能适合目标整数类型，那么它的值将会因为目标类型值域取模而减少。
下面的这个程序说明了强制类型转换过程。
public class Conversion {
public static void main(String args[]){
byte b;
int i = 258;
double d = 338.136;
System.out.println(“\\n将int类型数据转换为byte");
b = (byte) i;
System.out.println("i and b: " + i + “, " + b);
System.out.println(“\\n将double类型数据转换为int");
i = (int) d;
System.out.println("d and i :" + d + " ," + i);
System.out.println(“\\n将double类型数据转换为byte");
b = (byte) d;
System.out.println("d and b: " + d + “, " + b);
}
}
运行结果如下：
将int类型数据转换为byte
i and b: 258, 2
将double类型数据转换为int
d andi: 338.136 ,338
将double类型数据转换为byte
d and b :338.136, 82
下面让我们分析一下每个类型转换。
当值258被强制转换为byte变量时，取值它的低八位；
当把变量d转换为int型，它的小数部分被舍弃了；
当把变量d转换为byte型，它的小数部分被舍弃了，也是取它的低八位。
示例代码
1 //类型转换 2 public class TypeConvert{ 3 public static void main(String args[]){ 4 //1.自动类型转换 5 //低优先级数据类型自动转换成高精度的数据类型 6 //byte->short->char->int->long->float->double 7 8 byte b=1; 9 short s=b; 10 System.out.println("s="+s); 11 12 double d=b; 13 System.out.println("d="+d); 14 15 //2.强制转换 16 //强制转换可能会导致数据的丢失 17 //格式 （目标数据类型）值 18 float f=1.23F; 19 int i =(int)f; //小数转整数会直接将小数点后的数字直接舍去，不进行四舍五入 20 System.out.println("i="+i); 21 22 int x=250; 23 System.out.println("x="+x); 24 byte y =(byte)x; //取int的低8位存入byte，第8位是符号位 25 System.out.println("y="+y); 26 } 27 }
赋值运算符
包括：=，+=，-=，*=，/=，%=
int a=2; a =a*b; a*=b; a%b=b; a =a%b;
算术运算符
包括：+，-，*，/，%，++，--等
后缀++（--）：变量首先进行操作再自身进行加减。
int a=2; int b =a++; //a=3,b=2
前缀++（--）：变量首先加减后再进行操作。
int a=2; int b=++a; //a=3,b=3
关系运算符
包括：==，！=，<，<=，>，>=
完成操作数的比较运算，结果为布尔类型值。
int a=10; int b=3; boolean f=a>b; //比较a和b的值，结果为true，即f的值为true
逻辑运算符
包括：&，|，!，^，&&，||
注意区别:＆既是位运算符也是逻辑运算符，＆＆只是逻辑运算符，＆与＆＆同时作为逻辑运算符时＆＆是短路的(截断功能)，而＆并不短路。
int a=6;
int b=8;
int c=10;
int d=12;
boolean x=++a>b++&&c++>d--;
//上面代码的结果：
//a=7 b=9 c=10 d=12 x=flase
条件运算符
也称作三目运算符
一般形式为：
<表达式1>?<表达式2>:<表达式3>;
表达式1的数据类型为布尔值类型，如果为true，取表达式2的值为最终结果，否则取表达式3的值。
int x=2 ;i nt y=3; int salary=(x ==y)?2000:200; //上面代码中因为x==y不成立，所以salary的最终值为200。
位运算符
-
- 按位取反?，?01010101=10101010。 (1变0 0变1)
- 按位与&，11111001&10001111=10001001。 (同为1时为1 )
- 按位或|，11111001|10001111=11111111。 （只要有一个为1就为1）
- 按位异或^，11111001^10001111=01110110。 （相同为0 不同为1）
- 左移<<，10101011<<2=10101100。
- 带符号右移>>，10101011>>2=11101010。
- 无符号右移>>>
示例代码
1 //运算符 2 public class Operator{ 3 public static void main(String args[]){ 4 //1.算数运算符：+ — * / % ++ -- 5 /*int a =1; 6 int b =2; 7 int c =a/b; //两个整数相除结果仍为整数 8 System.out.println("c="+c); 9 10 //++自增 11 int i =1; 12 //i++; //后缀自增 13 //++i; //前缀自增 14 int i2=i++; //先其他操作后自加 15 System.out.println("i2="+i2+",i="+i); 16 int i3=++i; //先自加后其他操作 17 System.out.println("i3="+i3+",i="+i); 18 */ 19 20 //2.赋值运算符：= += -= *= /= %= 21 /*int a =2; 22 int b=3; 23 a+=b; //相当于a=a+b 24 System.out.println("a="+a); 25 */ 26 27 //3.关系运算符：== != > < >= <= 28 //关系运算符结果是布尔类型 29 /*int a =2; 30 int b =3; 31 boolean bl = a<b; 32 System.out.println("bl="+bl); 33 */ 34 35 //4.逻辑运算符 36 //专门针对布尔类型数据进行运算 37 //与 & && 两个同时为true，结果才为true 38 //或| || 只要有一个为true，结果就为true 39 //取反 ! 40 //异或 ^ 两个相同结果为false，不同为true 41 42 /*boolean b1 = true; 43 boolean b2 = false; 44 boolean b3 = b1^b2; 45 System.out.println("b3="+b3); 46 */ 47 48 //具有短路功能的与 && 或 || 在运算过程中已知结果便不再进行后面的运算 49 50 /*int a=2,b=4,c=10,d=11; 51 boolean c1 = ++a >= b-- && c-- ==--d; 52 System.out.println("a="+a+",b="+b+",c="+c+",d="+d+",c1="+c1); 53 */ 54 55 //5.条件运算符（三目运算符） 56 /* 57 条件?表达式1:表达式2 58 注意表达式1和表达式2 类型相同 59 如果条件为true 取表达式1的结果，否则取表达式2的结果 60 */ 61 /*int a=2; 62 int b=3; 63 int c = a>b?a:b; 64 System.out.println("c="+c); 65 */ 66 67 //6.位运算符 68 //按位与 & 69 //按位或 | 70 //按位取反 ~ 71 //异或 ^ 72 int a =2; //0...0 0010 73 int b =3; //0...0 0011 74 int c =a&b; //0010 75 System.out.println("c="+c); 76 77 //位移 78 //<<左移 79 int d =2; //0...0 0010 80 d =d<<2; 81 System.out.println("d="+d); 82 //右移>> 83 int e =-2; //1...1 1110 84 e =e>>2; //111...1 1111 -1 85 System.out.println("e="+e); 86 //无符号右移>>> 87 int f = -2; 88 f = f>>>2; 89 System.out.println("f="+f); 90 } 91 }
表达式
由操作数和运算符按照一定的语法格式组成表达式。
(a+b)*(c--d)
变量的作用域
-
- 所谓的作用域就是在变量在什么时候是可见在什么是不可见的！
- 作用域决定变量“可见性”与“存在时间”
- 作用域的范围：只作用于从声明开始到所在的{}结束。
示例代码
1 //变量的作用域指的是变量从定义开始到所在的花括号}结束 2 public class Scope{ 3 public static void main(String args[]){ 4 int x =10; 5 { 6 System.out.println("x="+x); 7 double y =1.23; 8 } 9 //System.out.println(y); //超出了y的作用域 10 } 11 }
简单的输入输出
输出：
使用System.out对象进行输出。
println()：输出文本并换行
print()：输出文本不换行
如：System.out.println(“hello world!”);
输入：
1、使用Scanner对象输入。
new Scanner(System.in)
import java.util.Scanner与next()或nextInt()方法
2、使用命令行参数main()方法的args[]。
示例代码
1 //简单的输入输出 2 import java.util.Scanner; //引入Scanner类 3 public class InOut{ 4 public static void main(String args[]){ 5 //输入1：通过main方法的args参数 6 /*String str =args[0]; 7 int a = Integer.parseInt(str); //将字符串转换成整数 8 System.out.println("a*10="+a*10); 9 */ 10 11 //输入2：通过Scanner对象（扫描器） 12 //使用new 创建Scanner对象 13 Scanner scan = new Scanner(System.in); //System.in表示从控制台读取数据 14 //调用功能next()，nextInt(),nextDouble(),nextLine() 15 System.out.print("请输入一个整数："); 16 int i = scan.nextInt(); 17 System.out.println("你输入的是:"+i); 18 19 //输入文本 20 System.out.print("请输入一句话："); 21 Scanner myscan = new Scanner(System.in); 22 String a =myscan.nextLine(); 23 System.out.println("你输入的是："+a); 24 } 25 }
练习
从屏幕上输入两个实数，计算他们的和，差，积，然后输出
1 //从屏幕上输入两个实数，计算他们的和，差，积，然后输出 2 3 import java.util.Scanner; 4 public class HWD1T1{ 5 public static void main(String args[]){ 6 /* 7 Scanner a =new Scanner(System.in); 8 System.out.print("请输入第一个数字："); 9 double x = a.nextDouble(); 10 11 Scanner b =new Scanner(System.in); 12 System.out.print("请输入第二个数字："); 13 double y = b.nextDouble(); 14 */ 15 16 /* 17 String str1 = args[0]; 18 String str2 = args[1]; 19 double x = Double.parseDouble(str1); 20 double y = Double.parseDouble(str2); 21 */ 22 23 double x =Double.valueOf(args[0]).doubleValue(); 24 double y =Double.valueOf(args[1]).doubleValue(); 25 26 double sum=x+y; 27 double diff=x-y; 28 double avg=x*y; 29 30 System.out.println("它们的和是"+sum); 31 System.out.println("它们的差是"+diff); 32 System.out.println("它们的积是"+avg); 33 } 34 }
用户从屏幕上输入圆的半径，然后计算并输出该圆的直径、周长和面积。 注意：∏的值可以使用预定义常量Math.PI。该常量要比3.14159精确。
1 //用户从屏幕上输入圆的半径，然后计算并输出该圆的直径、周长和面积。 2 //注意：∏的值可以使用预定义常量Math.PI。该常量要比3.14159精确。 3 import java.util.Scanner; 4 public class HWD1T2{ 5 public static void main(String args[]){ 6 Scanner scan = new Scanner(System.in); 7 System.out.print("请输入圆的半径："); 8 double r = scan.nextDouble(); 9 10 double d = r*2; 11 double C = Math.PI*r*2; 12 double S = Math.PI*r*r; 13 14 System.out.println("该圆的直径为"+d); 15 System.out.println("该圆的周长为"+C); 16 System.out.println("该圆的面积为"+S); 17 } 18 }
编写一个应用程序，读取用户输入的一个整数，判断该整数的奇偶性，并将结果显示在控制台上。
1 //编写一个应用程序，读取用户输入的一个整数，判断该整数的奇偶性，并将结果显示在控制台上。 2 //提示：使用求模和三目运算符。 3 import java.util.Scanner; 4 public class HWD1T3{ 5 public static void main(String args[]){ 6 Scanner scan =new Scanner(System.in); 7 System.out.print("请输入一个整数："); 8 int a = scan.nextInt(); 9 String b = a%2==0?"偶数":"奇数"; 10 System.out.println("该数字是："+b); 11 } 12 } 13
编写一个程序，输入一个5位数，将输入数分离成单个数字，然后打印出这些数字，个数字间间隔3个*符号。
1 //编写一个程序，输入一个5位数，将输入数分离成单个数字，然后打印出这些数字，个数字间间隔3个*符号。 2 //提示：使用整除除法和求模运算符。 3 //例如：如果用户输入：42933,那么输出是：4***2***9***3***3 4 5 import java.util.Scanner; 6 public class HWD1T4{ 7 public static void main(String args[]){ 8 Scanner scan = new Scanner(System.in); 9 System.out.print("请输入一个5位数："); 10 int a = scan.nextInt(); 11 12 int s5=a/10000; 13 int s4=(a/1000)%10; 14 int s3=(a/100)%10; 15 int s2=(a/10)%10; 16 int s1=a%10; 17 18 System.out.println(s5+"***"+s4+"***"+s3+"***"+s2+"***"+s1); 19 } 20 } 21
编写一个Java应用程序,用户从键盘输入一个浮点数据,将该浮点数保留两位小数位后输出。
1 //编写一个Java应用程序,用户从键盘输入一个浮点数据,将该浮点数保留两位小数位后输出。 2 import java.util.Scanner; 3 public class HWD1T5{ 4 public static void main(String args[]){ 5 Scanner scan =new Scanner(System.in); 6 System.out.print("请输入一个小数："); 7 double a = scan.nextDouble(); 8 9 //int b =(int)(a*100); 10 //a=(double)b/100; 11 //System.out.println(a); 12 13 System.out.println(String.format("%.2f",a)); 14 } 15 } 16
输入一个数，如果能被3、4、5中的任意一个数整除，则输出： i+“能被3或者4或者5整除” （i是输入的数字）。
1 //输入一个数，如果能被3、4、5中的任意一个数整除，则输出： i+“能被3或者4或者5整除” （i是输入的数字）。 2 //用||实现。 3 import java.util.Scanner; 4 public class HWD1E1{ 5 public static void main(String args[]){ 6 Scanner scan = new Scanner(System.in); 7 System.out.print("请输入一个整数："); 8 int a = scan.nextInt(); 9 String b=a%3==0||a%4==0||a%5==0?"能被3或4或5整除":"不能被3或4或5整除"; 10 System.out.println(a+b); 11 } 12 } 13
输入一个数，如果是能被2整除，且能被3整除，则输出：i+”能被2和3整除” （i是输入的数字）。
1 //输入一个数，如果是能被2整除，且能被3整除，则输出：i+”能被2和3整除” （i是输入的数字）。 2 //用&&实现。 3 import java.util.Scanner; 4 public class HWD1E2{ 5 public static void main(String args[]){ 6 Scanner scan =new Scanner(System.in); 7 System.out.print("请输入一个整数："); 8 int a = scan.nextInt(); 9 String b =a%2==0&&a%3==0?"能被2和3整除":"不能被2和3整除"; 10 System.out.println(a+b); 11 } 12 } 13