文章目录
- 第一章、语法入门
- 一、Java简介
- 1、JVM
- 2、Java程序执行过程
- 3、JDK
- 4、JRE
- 5、JDK、JRE和JVM三者关系
- 二、Java常量与变量
- 1、标识符
- 2、关键字
- 3、保留字
- 4、变量
- 5、数据类型
- 6、常量
- 三、运算符
- 1、算术运算符
- 2、赋值运算符
- 3、关系运算符
- 4、逻辑运算符
- 5、条件运算符
- 6、运算符的优先级
- 四、流程控制语句
- 1、选择结构
- 1）if-else语句：
- 2）switch结构
- 2、循环结构
- 1）while循环
- 2）do-while循环
- 3）for循环
- 4）循环嵌套
- 5）break语句和continue语句
- 五、数组
- 1、一维数组
- 2、增强型for循环
- 3、冒泡排序
- 4、二维数组
- 六、方法
- 1、方法声明
- 2、方法分类
- 3、方法重载
- 4、方法参数传递问题
- 5、可变参数列表
第一章、语法入门
一、Java简介
Java是一门面向对象的程序设计语言。
1995年由sun公司发布。
2010年sun公司被Oracle公司收购，然后发布了java8版本。
1、JVM
JVM（Java Virtual Machine）Java虚拟机。
JVM是Java平台无关性实现的关键所在。
2、Java程序执行过程
3、JDK
JDK（Java Development Kit）Java语言的软件开发包。
两个主要组件：
- javac --编译器，将源程序转成字节码
- java --运行编译后的java程序（.class文件）
4、JRE
JRE（Java Runtime Environment）
包括Java虚拟机（JVM）、Java核心类库和支持文件。
如果只需要运行Java程序，下载并安装JRE即可
如果开发Java软件，需要下载JDK
在JDK中附带有JRE
5、JDK、JRE和JVM三者关系
二、Java常量与变量
1、标识符
Java 中标识符是为方法、变量或其他用户定义项所定义的名称。
标识符命名规则
标识符可以由字母、数字、下划线（_）和美元符($）组成，不 能以数字开头。
标识符严格区分大小写。
标识符不能是Java关键字和保留字。
标识符的命名最好能反映出其作用。
2、关键字
Java中的关键字是有对编译器有特殊意义的词，比如class是用来定义类的关键字，编译器遇到class就知道这是定义了一个类。
| abstract | boolean | break | byte | case | catch |
|---|---|---|---|---|---|
| char | class | continue | default | do | double |
| else | extends | false | final | finally | float |
| for | if | implements | import | native | int |
| interface | long | instanceof | new | null | package |
| private | protected | public | return | short | static |
| super | switch | synchronized | this | throw | throws |
| transient | true | try | void | volatile | while |
3、保留字
Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。
如：goto、const
4、变量
变量是程序当中数据的临时存放场所，变量存储在内存当中。
变量的三个元素：变量类型（数据类型）、变量名和变量值。
变量声明格式：数据类型 变量名 = 变量值；
如：int n = 10;
变量名的命名规则
满足标识符命名规则。
符合驼峰法命名规范。
尽量简单，做到见名知意。
变量名的长度没有限制。
类的命名规则
满足Pascal命名法规范，单词首字母大写，如果是多个单词拼接而成的，每个单词首字母都大写。
5、数据类型
- 数据类型
- 基本数据类型
- 数值型
- 整数类型
- byte（1字节，8位）--字节型
- short（2字节）--短整型
- int（4字节）--整型，整数默认情况是int类型
- long（8字节）--长整型，整数值后面加 L 或 l 表示长整型，如456L
- 浮点类型
- float（4字节）--单精度浮点型，浮点数值后面加 f 或 F ，如：23.3f
- double（8字节）--双精度浮点型，浮点数默认情况下是double类型，也可以在值后面加 d 或 D ，如：123.45d
- 字符型
- char（2字节）--字符型字面值用单引号内的单个字符表示，如：char a = 'a'
- 布尔型
- boolean（1字节）--布尔值只能定义为 true 和 false
- 引用数据类型
- 类
- class
- 接口
- interface
- 数组
转义字符
\uxxxx --四位16进制数所表示的字符
’ --单引号字符
‘’ --双引号字符
\ --反斜杠字符
\r --回车
\n --换行
\t --横向跳格
\b --退格
类型转换
类型转换分为自动类型转换和强制类型转换。
自动类型转换顺序：
强制类型转换：如果A类型的数据表示范围比B类型大，则将A类型的值赋值给 B类型，需要强制类型转换。如：
double d＝123.4;
float f=(float)d;
6、常量
在变量定义的前面加final 关键字，常量名一般大写，且值不可更改。如：
final double PI = 3.14;
三、运算符
1、算术运算符
| 算术运算符 | 名称 | 举例 |
|---|---|---|
| + | 加法 | 5+10=15 |
| - | 减法 | 10-5=5 |
| * | 乘法 | 3*6=18 |
| / | 除法 | 36/4=9 |
| % | 求余数 | 13%3=1 |
| ++ | 自增1 | int n=3;n++ |
| - - | 自减1 | int n=3;n- - |
自增自减运算符
n1 = 1
| 表达式 | 执行方式 | 结果 |
|---|---|---|
| n2 = ++n1; | n1 = n1 + 1; n2 = n1; | n1 = 2; n2 = 2; |
| n2 = n1++; | n2 = n1; n1 = n1 + 1; | n1 = 2; n2 = 1; |
| n2 = - -n1; | n1 = n1 - 1; n2 = n1; | n1 = 0; n2 = 0; |
| n2 = n1- -; | n2 = n1; n1 = n1 - 1; | n1 = 0; n2 = 1; |
2、赋值运算符
格式：变量＝表达式；
例：int n＝3; //将3赋值给变量n
注意：赋值运算符是从右往左运算，赋值运算符的左边不能是常量。
复合赋值运算符
| 运算符 | 表达式 | 结果（假设x=15） |
|---|---|---|
| += | x+=5 | 20 |
| -= | x-=5 | 10 |
| *= | x*=5 | 75 |
| /= | x/=5 | 3 |
| %= | x%=5 | 0 |
3、关系运算符
比较运算符用于判断两个数据的大小，如大于
比较的结果是一个布尔值
| 运算符 | 名称 | 表达式 | 结果 |
|---|---|---|---|
| ＞ | 大于 | ５＞３ | true |
| < | 小于 | 5 < 3 | false |
| >= | 大于等于 | 5>=3 | true |
| <= | 小于等于 | 5<=3 | false |
| == | 等于 | 5==3 | false |
| != | 不等于 | 5!=3 | true |
4、逻辑运算符
逻辑“与”运算符
表达式1 &&（或&）表达式2
| 表达式1 | 表达式2 | 结果 |
|---|---|---|
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |
注：&&运算符又叫短路运算符，如果第一个表达式的值就能决定表达式最后的结果，运算符右边的表达式就不再计算了。
逻辑“或”运算符
表达式1 ||（或|）表达式2
| 表达式1 | 表达式2 | 结果 |
|---|---|---|
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |
注：||运算符又叫短路运算符，如果第一个表达式的值就能决定表达式最后的结果，运算符右边的表达式就不再计算了。
逻辑“非”运算符
!运算符
对原条件进行取反
例：!(3<5)，结果为false
5、条件运算符
Java中的条件运算符是三目运算符。
语法：
布尔表达式？表达式1:表达式2
当布尔表达式的值为true，则返回表达式1的值，否则返回表达式2的值。
6、运算符的优先级
从上到下优先级从高到低：
| 运算符 | 描述 |
|---|---|
| () | 圆括号 |
| !,++,– | 逻辑非，自增，自减 |
| *,/,% | 乘法，除法，取余 |
| +,- | 加法，减法 |
| <,<=,>,>= | 小于，小于等于，大于，大于等于 |
| ==,!= | 等于，不等于 |
| && | 逻辑与 |
| || | 逻辑或 |
| =,+=,*=,/=,%=,-= | 赋值运算符，复合赋值运算符 |
四、流程控制语句
三大流程控制语句：顺序、选择、循环
1、选择结构
1）if-else语句：
if(条件)
语句; //单行语句可不加大括号
if(条件){
语句;
}
if(条件)
语句1;
else
语句2
if(条件){
语句1;
}else{
语句2;
｝
多重if结构
if(表达式1)
语句1;
else if(表达式2)
语句2;
else if(表达式3)
语句3;
…
else
语句n;
嵌套if结构
if(表达式1)
if(表达式2)
if(表达式3)
语句;
else
语句;
2）switch结构
switch(表达式){
case 常量表达式1:
语句1;break;
case 常量表达式2:
语句2;break;
case 常量表达式3:
语句3;break;
...
default:
语句n;
}
if和switch的区别
if结构：
－判断条件是布尔类型
－判断条件是一个范围
switch结构：
－判断条件是常量值
2、循环结构
1）while循环
语法格式：
while(循环条件) ｛
语句;
｝
举例：
int n=1; // n的值必须先进行初始化
while(n<5)｛
//输出n的值
n++; // 循环变量n的值必须被改变
｝
注：
为了避免死循环，小括号后面不要加分号。
2）do-while循环
语法格式：
do ｛
语句;
｝while(循环条件);
举例：
int n=1;
do ｛
//输出n的值
n++;
｝while(n<5);
注意：
do-while循环至少执行一次。
循环条件后的分号不能丢。
3）for循环
语法格式：
for(表达式1;表达式2；表达式3) ｛
语句;
｝
举例：
for(int n=1;n<5;n++)｛
//输出语句;
｝
注：
三个表达式都是可以省略的，如：
int n=1;
for(;;)｛
if(n==5)break;
//输出语句;
n++;
｝
4）循环嵌套
while(循环条件) ｛
…….
while(循环条件){
…….
}
…….
｝
do ｛
…….
while(循环条件){
…….
}
…….
｝ while(循环条件);
for(表达式1;表达式2；表达式3) ｛
…….
for(表达式1;表达式2；表达式3){
…….
}
…….
｝
5）break语句和continue语句
break语句：
break语句可以结束当前循环的执行。
执行完break语句后，循环体体中位于break语句后面的语句就不会被执行。
在多重循环中，break语句只会向外跳一层。
continue语句：
continue语句只能用在循环里。
continue语句可以结束当前循环的执行，但是要继续下一次循环的执行。
五、数组
1、一维数组
什么是数组
数组是相同类型的数据按顺序组成的一种引用数据类型。
数组声明
语法格式：
数据类型[] 数组名;
数据类型 数组名[];
如：
int[] array1;
int array2[];
数组创建
语法格式一：先声明后创建
数据类型[] 数组名;
数组名 = new 数据类型[数组长度];
如：
int[] arr;
arr=new int[10];
创建一个长度为10的整型数组。
语法格式二：声明的同时创建数组
数据类型[] 数组名 = new 数据类型[数组长度];
如：
int[] arr=new int[10];
创建长度为10的整型数组arr。
注意：数组长度必须指定。
数组的初始化
声明数组的同时给数组赋值，叫做数组的初始化。
如：
int[] arr={1,2,3,4,5,6,7,8,9,10};
数组的长度就是初始化时所给数组元素的个数。
数组元素及长度
语法格式：
数组名[下标];
注意：下标从0开始。
属性length表示数组的长度，如a.length。
2、增强型for循环
又叫foreach循环。
foreach循环应用：
int[] arr={1,2,3,4,5};
for(int n:arr) {
System.out.println(n);
}
3、冒泡排序
思路：
比较相邻的元素，如果前一个比后一个大，交换之。
第一趟排序第1个和第2个一对，比较与交换，随后第2个和第3个一对比较交换，这样直到倒数第2个和最后1个，将最大的数移动到最后一位。
第二趟将第二大的数移动至倒数第二位
…
因此需要n-1趟
代码：
int[] ages= {21,27,31,19,50,32,16,25};
//控制比较轮数
for(int i=0;i<ages.length-1;i++) {
//每轮比较多少
for(int j=0;j<ages.length-i-1;j++) {
if(ages[j]>ages[j+1]) {
int tmp=0;
tmp=ages[j];
ages[j]=ages[j+1];
ages[j+1]=tmp;
}
}
}
4、二维数组
二维数组也是存放相同数据类型的数据，可以看成是由多个一维数组组
成。
比如，我们可以把几个学生的成绩存放到二维数组中。学生成绩如表所示。成绩就可以存储到二维数组中。因此，二维数组可以包含行和列，和表格很相似。而每一行就是一个一维数组。
| 数学 | 语文 | 英语 | |
|---|---|---|---|
| 张三 | 89 | 92 | 93 |
| 李四 | 85 | 90 | 96 |
| 王五 | 95 | 93 | 98 |
二维数组的声明
二维数组的声明有三种形式，格式如下：
数据类型[][] 数组名；
数据类型 数组名[][];
数据类型[] 数组名[];
如：
int[][] intArray;
float floatArray[][];
double[] doubleArray[];
二维数组的创建
数组名=new 数据类型[行][列];
如：
先声明，后创建：
int[][] intArray;
intArray=new int[3][3];
声明数组的同时创建：
int[][] intArray=intArray=new int[3][3];
创建数组的时候，可以只指定行数：
float[][] floatArray=new float[3][];
这时候列数并没有指定，每行相当于一个一维数组，需要分别创建。
floatArray[0]=new float[3];//第一行有三列
floatArray[1]=new float[4];//第二行有四列
floatArray[2]=new float[5];//第三行有5列
每一行的数据数量是可以不相同的。
数组元素的引用
与一维数组相似，行列的index值均从0开始。
如：
已知一个三行三列的整型二维数组intArray，它的第三行第二列元素
表示为intArray[2][1]。
二维数组的初始化
与一维数组类似，创建的同时为数组元素赋值，即为数组的初始化。
如：
int[][] num={{1,2,3},{4,5,6},{7,8,9}};
num[1][2]的值为6。
数组的遍历
循环输出二维数组的内容，代码如下：
//初始化一个二维数组
int[][] num1={{78,98},{65,75,63},{98}};
//循环输出二维数组的内容
for(int i=0;i<num1.length;i++){
for(int j=0;j<num1[i].length;j++){
System.out.print(num1[i][j]+" ");
}
System.out.println();
}
六、方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
1、方法声明
语法格式：
访问修饰符 返回类型 方法名(参数列表){
方法体
}
2、方法分类
根据方法是否带参数、是否返回值，可分为四类：
- 无参无返回值方法
- 无参带返回值方法
- 带参无返回值方法
- 带参带返回值方法
3、方法重载
方法名相同，参数列表不同。
参数列表不同包括，参数的个数和类型不同。如果只有参数名不同，不能算作方法重载。
如下三个方法是重载方法，它们的参数列表都是不同的。
public void display(){}
public void display(int n){}
public void display(float n){}
如下两个方法不是重载方法，两个方法只是参数名不同，不满足方法重载条件。
public void display(int n){}
public void display(int d){}
4、方法参数传递问题
基本数据类型变量传递的是值，实际参数变量的值是不会跟方法内部形式参数的值改变而改变的。
引用类型变量传递的是引用，实际参数变量的值会跟着方法内部形式参数的值变化而变化，因为引用指向的内存都是一样的。
5、可变参数列表
如：
public void sum(int... n){}
- 可变参数列表作为参数，方法调用时可以传入0个或多个参数，传入数组也可以。数组作为方法参数，方法调用时只能传入数组。
- 可变参数列表作为方法参数时，如果有多个参数，可变参数列表只能放到最后一个位置，而且不能有多个可变参数列表作为方法参数。而数组没有这个限制。
- 可变参数的底层实现就是数组。
- 可变参数列表所在方法被重载时是最后被访问的。
- 当传入方法的参数数量不确定的时候，可以考虑使用可变参数列表。
