java基础语法详解
java基础语法
一，开发环境的搭建
jdk,jre,jvm的关系
JDK的下载、安装
下载：官网，github
安装：傻瓜式安装：JDK 、JRE
注意问题：安装软件的路径中不能包含中文、空格。
path环境变量的配置
为什么要配置path环境变量？
path环境变量：Windows操作系统执行命令时所需要搜寻的路径。
为什么要配置path环境变量：
希望java的开发工具（javac.exe，java.exe）在任何文件下都可以执行成功。
如何配置环境变量？
JAVA_HOME=D:\jdk1.8.0_131
path=%JAVA_HOME%\bin;
编写自己第一个java程序
创建一个java源文件为HelloWorld.java
class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
第一步
编译：javac HelloWorld.java
第二步
运行：java HelloWorld
总结自己的第一个java程序
- java程序编写–编译–运行的过程
编写：我们将编写的java代码保存在以“.java”结尾的源文件中
编译：使用javac.exe命令编译我们的java源文件。格式：javac 源文件名.java。
运行：使用java.exe命令解析运行我们的字节码文件。格式：java 类名 - 在一个java源文件中可以声明多个class。但是，只能最多有一个类声明为public的。而且要求声明为public的类的类名必须与源文件名相同。
- 程序的入口是main()方法。格式是固定的。
- 输出语句：
System.out.println();显示输出数据，然后换行。
System.out.print()；只输出数据。 - 每一行执行语句都以“;”结束。
- 编译过程：
编译之后会生成一个或多个字节码文件。字节码文件的文件名与java源文件中的类名相同。
java的基本语法
关键字与标识符
java关键字
定义：被java语言赋予了特殊含义，用作专门用途的字符串(单词)
特点：关键字中所有字母小写。
保留字
现Java版本尚未使用，但以后版本可能会作为关键字使用。
注意：自己命名标识符时要避免使用这些保留字。
标识符
定义：凡事自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：（必须遵守。否则编译不通过。）
- 由26个字母大小写，0~9,_或者$组成；
- 数字不能开头；
- 不能使用关键字和保留字，但能包含关键字和保留字；
- java中雅阁区分大小写长度无限制。
- 标识符不能包含空格。
规范：（可以不遵守，不影响编译和运行。但是要求遵守）
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母大写。多单词时每个单词之间用下划线连接：XXX_YYY_ZZZ
注意：在起名字是为了提高阅读性，要尽量“见名知意”。
变量的分类
按数据类型分类
基本数据类型
整数型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
- byte范围：-128 ~ 127
- 声明long型变量，必须以"l"或"L"结尾
- 通常，定义整型变量时，使用int型。
浮点型：float(4字节) \ double(8字节)
- 浮点型，表示带小数点的数值
- float表示数值的范围比long还大
- 定义float类型变量时，变量要以"f"或"F"结尾
- 通常，定义浮点型变量时，使用double型。
- 浮点型的常量，默认类型为：double
字符型：char (1字符=2字节)
- 定义char型变量，通常使用一对’’,内部只能写一个字符
- 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
布尔型：boolean
- 只能取两个值之一：true 、 false
- 常常在条件判断、循环结构中使用、
按声明位置分类
成员变量
- 实例变量（不以static修饰）
- 类变量（以static修饰）
局部变量
- 形参（方法、构造器中定义的变量）
- 方法局部变量（在方法中定义）
- 代码块局部变量（在代码块中定义）
定义变量的格式
数据类型 变量名 = 变量值;
或
数据类型 变量名;
变量名 = 变量值;
变量使用的注意点：
- 变量必须先声明，后使用
- 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
- 同一个作用域内，不可以声明两个同名的变量
基本数据类型变量间的运算规则
涉及到的基本数据类型：除boolean之外的其它七种数据类型。
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
当byte、char、short三种类型的变量做运算时，结果为int型。
强制类型转换
只涉及7种基本数据类型
自动类型提升运算的逆运算
需要使用强转符：()
强制类型转换，可能导致精度损失。
String与8种基本数据类型间的运算
- String属于引用数据类型,翻译为：字符串
- 声明String类型变量时，使用一对""
- String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
- 运算的结果仍然是String类型
运算符
算数运算符
注意
- 如果对负数取模，可以把模数负号忽略不记，如：7%-2=1。 但被模数是
负数则不可忽略。此外，取模运算的结果不一定总是整数。 - 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只
保留整数部分而舍弃小数部分。 - “+”除字符串相加功能外，还能把非字符串转换成字符串。
赋值运算符
符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。
扩展赋值运算符： +=, -=, *=, /=, %=
比较运算符
比较运算符的结果都是boolean型，也就是要么是true，要么是false。
逻辑运算符
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
位运算符
位运算细节
- << 空位补0，被移除的高位丢弃，空缺位补0。
- .>> 被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。 - .>>> 被移位二进制最高位无论是0或者是1，空缺位都用0补。
- & 二进制位进行&运算，只有1&1时结果是1，否则是0;
- 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;
- ^ 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1 - ~ 正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反
三元运算符
三元运算符：(条件表达式)? 表达式1 : 表达式2
根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
流程控制
分支结构
1. if-else条件判断结构
结构1
if（条件表达式）{
执行表达式
}
` 结构二：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
`
结构三：N选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
...
else{
执行表达式n
}
注意：
1.else 结构是可选的
2.针对于条件表达式：
–>如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
–>如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
–>如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
3.if else 结构是可以相互嵌套的。
4.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
。
2. switch-case选择结构
switch(表达式){
case 常量1:
执行语句1;
break;
case 常量2:
执行语句2;
break;
...
default:
执行语句n;
break;
}
注意
-
根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。 当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
-
break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
-
switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增) -
case 之后只能声明常量。不能声明范围。
-
break关键字是可选的。
-
default:相当于if-else结构中的else
default结构是可选的，而且位置是灵活的。
循环结构
循环结构的四要素
1.初始化条件 2.循环条件 3. 循环体 4.迭代条件
通常情况下，循环结束都是因为2中的循环条件返回false。
for循环
for(初始化条件;循环条件;迭代条件){
循环体
}
执行过程：1--2--3--4---2--3--4--...--2
while循环
初始化条件
while(循环条件){
循环体;
迭代条件;
}
执行过程：1--2--3--4---2--3--4--...--2
在while循环中丢失迭代条件会导致死循环
for循环和while循环的总结：
- 开发中，基本上我们都会从for、while中进行选择，实现循环结构。
- for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。 - 注意迭代条件不可丢失。
do-while循环
初始化条件
do{
循环体;
迭代条件;
}while(初始化条件);
执行过程：1--3--4--2--3--4--...--2
do-while循环至少会执行一次循环体
“无限循环”结构:
while(true) 或 for(;;)
总结：如何结束一个循环结构？
方式一：当循环条件是false时
方式二：在循环体中，执行break
嵌套循环
嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
内层循环：循环结构A
外层循环：循环结构B
//循环结构B
for(int i =0 ;i <= m;i++){
//循环结构A
for(int j = 0; j<=n;j++){
循环体A;
}
}
- 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
- 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
- 外层循环控制行数，内层循环控制列数。
break和continue关键字的使用
数组
一、数组的概述
1. 数组的理解
数组（array),是多个相同数据类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2. 数组的相关概念
数组名
元素
角标、下标、索引
数组的长度：元素的个数
3. 数组的特点
- 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
- 数组的长度一旦确定，就不能修改。
- 创建数组对象会在内存中开辟一整块连续的空间。
- 数组是有序排列的。
- 数组的分类
按照维数分类：一维数组，二维数组
按照数组元素的类型分类：基本数据类型的数组、引用数据类型的数组
一维数组
一维数组的初始化和声明
int num;//声明
num = 10;//初始化
int id = 1001;//声明 + 初始化
int[] ids;//声明
//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{
1001,1002,1003,1004};
//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
int[] arr4 = {
1,2,3,4,5};//类型推断
调用数组的指定位置的元素
通过角标的方式调用，数组的角标（或索引）从0开始，到数组的长度-1结束。
如何获取数组的长度：属性：length
int[] arr = new int[]{
1,2,3,5,6,7};
System.out.println(arr.length);
说明：
数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。
一维数组的遍历
for(int i = 0;i < narr.length;i++){
System.out.println(arr[i]);
}
二维数组
二维数组的初始化和声明
int[] arr = new int[]{
1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{
{
1,2,3},{
4,5},{
6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法：
int[] arr4[] = new int[][]{
{
1,2,3},{
4,5,9,10},{
6,7,8}};
int[] arr5[] = {
{
1,2,3},{
4,5},{
6,7,8}};//类型推断
调用二维数组的元素
System.out.println(arr1[0][1]);
System.out.println(arr2[1][1]);
arr3[1] = new String[4];
System.out.println(arr3[1][0]);
System.out.println(arr3[0]);
二维数组的属性
System.out.println(arr4.length);
System.out.println(arr4[0].length);
System.out.println(arr4[1].length);
遍历二维数组
for(int i = 0;i < arr4.length;i++){
for(int j = 0;j < arr4[i].length;j++){
System.out.print(arr4[i][j] + " ");
}
System.out.println();
}
数组的常见算法
数组的赋值与复制
int[] array1,array2;
array1 = new int[]{
1,2,3,4};
//数组的赋值
array2 = array1;
//如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
//数组的复制
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
//如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
数组元素的反转
方法一
for(int i = 0;i < arr.length / 2;i++){
String temp = arr[i];
arr[i] = arr[arr.length - i -1];
arr[arr.length - i -1] = temp;
}
方法二：
for(int i = 0,j = arr.length - 1;i < j;i++,j--){
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
数组的排序
冒泡排序
public class Order {
public static void main(String [] args){
//创建数组arr
int[] arr = new int[]{
1,22,33,21,45,63,66,22};
//循环遍历数组
for(int i = 0;i<arr.length;i++){
// System.out.println(arr[i]);
for(int j = 0;j<arr.length-1-i;j++){
if(arr[j]<arr[j+1]){
//创建中间变量
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//打印排序之后的数组
for (int i = 0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
直接排序
class Order2 {
public static void main(String[] args) {
//创建数组arr
int[] arr = new int[]{
1,22,33,21,45,63,66,22};
//遍历数组
for (int i = 0; i < arr.length-1; i++) {
//比较项
for (int j = i+1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
//给中间变量
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
//遍历排序之后的数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
选择排序
class Order3{
public static void main(String[] args) {
//创建数组
int[] arr = new int[]{
1,22,33,21,45,63,66,22};
//定义数组索引值
int index;
for(int i=1;i<arr.length;i++) {
//初始化数组索引值
index=0;
for(int j=1;j<=arr.length-i;j++) {
if(arr[index]<arr[j]) {
index=j;
}
}
int temp=arr[arr.length-i];
arr[arr.length-i]=arr[index];
arr[index]=temp;
}
for(int k : arr) {
System.out.print(k+" ");
}
}
}
Arrays工具类的使用
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{
1,2,3,4};
int[] arr2 = new int[]{
1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{
-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到");
}
数组常见的异常
数组角标越界异常：ArrayIndexOutOfBoundsException
int[] arr = new int[]{
1,2,3,4,5};
for(int i = 0;i <= arr.length;i++){
System.out.println(arr[i]);
}
System.out.println(arr[-2]);
System.out.println("hello");
空指针异常：NullPointerException
//情况一：
int[] arr1 = new int[]{
1,2,3};
arr1 = null;
System.out.println(arr1[0]);
//情况二：
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);
//情况：
String[] arr3 = new String[]{
"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());