Java基础语法

一、关键字 、保留字、标识符

1.1关键字

• 关键字（keyword）定义：被Java 语言赋予了一些特殊的含义，有自己专门的用途
• 特点：全为小写
• ▪ abstract 抽象，抽象类
  ▪ boolean 布尔类型
  ▪ break 终止
  ▪ byte 字节类型
  ▪ catch 捕捉异常
  ▪ char 字符类型
  ▪ class 类，clazz表名 ==》class public class clazz
  ▪ continue 继续
  ▪ default 默认
  ▪ do 执行
  ▪ double 小数
  ▪ else 选择
  ▪ extends 继承，java 三大的特性之一
  ▪ false boolean
  ▪ final 最终的 修饰符 final修饰的类不能被继承，final修饰的方法不能被重写，final修饰的变量就是一个常量
  ▪ finally 最终的 捕捉异常，最后一定会执行的代码
  ▪ float 小数
  ▪ for 循环
  ▪ if 判断
  ▪ implements 实现 接口
  ▪ import 导包
  ▪ instanceof ？是？的实例
  ▪ int 整数类型
  ▪ interface 接口
  ▪ long 长整型
  ▪ native 本地的
  ▪ new 创建对象
  ▪ null 空对象
  ▪ package 包
  ▪ private 私有的，封装
  ▪ protected 保护的
  ▪ public 公开的
  ▪ short 短整型
  ▪ static 静态的
  ▪ super 超类 父类
  ▪ switch 选择
  ▪ synchronized 锁 同步锁 保证线程安全
  ▪ this 指向当前对象的实例
  ▪ throw 抛出异常
  ▪ throws 抛出异常
  ▪ transient
  ▪ try 尝试 try catch
  ▪ true 真
  ▪ void 空
  ▪ volatile
  ▪ while 当 循环

1.2保留字

• reserver word:现在java版本还没有用这些词，但是未来的版本可能会用，所有暂时保留，程序开发人员就别用了
• goto，const

1.3标识符

• 由自己命名的都叫标识符
• 规则
• 1.由26个英文字母带小写，0-9，_或$组成
• 2.数字不可以开头
• 3.不可以使用关键字和保留字，但可以包含关键字和保留字
• 4.Java中严格区分大小写，长度无限制
• 5.不能有空格
• 具体名称注意事项：
• 包名：全小写
• 类名，接口名：大驼峰，每一个单词的首字母大写
• 变量名，方法名：小驼峰，第一个单词的首字母小写，其它的首字母大写
• 常量名：所有字母都大写，多单词用_连接：PI

二、数据类型(变量)

2.1变量

2.1.1变量的概念

• 变量是程序中最基本的存储单元
• 包含：变量类型，变量名和存储值

2.1.2变量的作用

• 在内存中存储数据

2.1.3变量的注意事项

• 先声明，（后赋值），再使用
• 作用域，变量只有在作用域中才能使用{}
• 在同一个作用域中，不能声明相同的变量名

2.1.4数据类型分类

• 2.1.4.1基本数据类型

• 2.1.4.1.1数值型

• • 整数类型（byte,short,int,long）
  • 浮点类型（float,double）

• 2.1.4.1.2字符型（char）

• 2.1.4.1.3布尔型（boolean）

• 2.1.4.2引用数据类型

• 2.1.4.2.1类（class）(String)

• 2.1.4.2.2接口（interface）

• 2.1.4.2.3数组（[ ]）

2.1.5成员变量、局部变量

• 成员变量：在方法体外，类体内的变量。
• 局部变量：方法体内声明的变量，需要显示初始化
• 都有生命周期，

2.2基本数据类型

2.2.1整数类型

• byte：1字节，-128~127

• short：2字节，-2e15~2E15-1

• int：4字节，-2e31~2E31-1

• long：8字节，-2e63~2E63-1

• 整形常量默认为int,声明long型常量需在后加‘l’或‘L’

2.2.2浮点类型

• float：单精度，4字节，-3.403e38~3.403e38
• double：双精度，8字节，-1.798e308~1.798E308
• float尾数可以精确到7位有效数字，后面加‘F’或‘f’

2.2.3字符类型

• char：2字节，char c = ‘a’;只能写一个字符

• 转移字符：\b:退格 \n:换行 \r:回车 \t:制表 \ "双引号 \ '单引号 \ \反斜线

• ASCII码：Unicode编码，容纳所有的符号，

• System.out.println((int)‘a’);直接输出ASCII码

• a:97 A:65 0:48

2.2.4布尔类型

• Boolean：只取值：true和false

2.3数据类型变量间转换

2.3.1自动类型转换

• 范围（容量）从小的数据类型转换为大的数据类型
• byte /short/char < int < long < float < double
• 当多种类型的数据混合运算时，系统会自动将所有的数据类型转换为容量大的数据类型，然后再进行运算
• byte short char 之间不进行转换，如果这些数据类型要进行计算，先转换为int类型，再运算
• boolean类型不能参与运算
• 当把任何基本数据类型的值和字符串进行连接运算时+，基本数据类型的值将自动转换为字符串类型

2.3.2强制类型转换

• 自动类型转换的逆向过程：容量从大到小加上(),
• 会出现的问题：精度损失，溢出的问题
• 可以通过包装类将字符串换成基本数据类型
• String a=“43”;int i = Integer.parselnt(a);
• boolean类型不可以转换为其他数据类型
• Integer int/double Double/float Float/char Character/byte Byte/short Short/long Long/boolean Boolean

2.4字符串类型

• String：引用数据类型
• 直接加+，可以连接任何数据类型

2.5进制与进制间的转换

• 二进制：0B/0b
• 十进制：
• 八进制：0
• 十六进制：0X/0x
• int num = 0127:

三、运算符

3.1算术运算符

• ±*/%(取余)+±-(自增，自减)
• +±- 不管在前在后，结果一定要变
• ++在后，先运算，后自增，++在前，先自增，后运算
• %:余数和被除数符号一致

3.2赋值运算符

• = += -= *= /= %=
• +=不会改变变量的类型（byte,short,char）

3.3比较运算符（关系运算符）

• == != > < >= <=
• instanceof检查谁是否是类的对象"java" instanceof String：true
• 比较运算符的结果是Boolean类型

3.4逻辑运算符

• &:逻辑与 &&:短路与 |:逻辑或 ||:短路或 !:逻辑非 ^:逻辑异或

• &/|:左边无论真假，右边都参与运算

• &&：左边为真，右边参与运算，左边为假，右边不参与运算

• ||：左边为真，右边不参与运算 ++z运算级高于||

3.5位运算符

3.6三元运算符

• 格式：（条件表达式）？表达式1：表达式2；
• 如果条件表达式为true，运算结果为表达式1
• 如果条件表达式为false，运算结果为表达式2
• 必须有一种类型可以同时接受表达式1和表达式2的值

3.7运算符的优先级

四、流程控制

4.1顺序结构

• 从上到下依次执行

4.2分支结构

• if…else和switch…case俩种
• switch…case…default…break
• switch表达式支持的数量类型：byte,short,char,int,String(jdk7),enum(枚举类型)
• case句中的值必须是常量，不能是变量名或者不确定的表达式值
• break语句用来在执行完一个case分支后使程序跳出switch语句块，如果没有brake，会顺序执行到switch结尾
• continue:(关键字)，跳过本次循环，继续执行下次循环
• 当多个条件是“互斥”关系时，顺序不变，当多个条件是“包含”关系时，“小上大下/子上父下”

4.3循环结构

• while，do…while，for三种

• foreach

• return：直接结束整个方法，无论return处于多少层循环

• **continue终止本次循环，break终止本层循环**关键字后面不能声明执行语句

• break默认调出最近的一层循环，循环添加label标签，可以指定退出循环break;continue

label:for(int j =1;j<=10;j++) {//内层控制列数
		if(j%4==0) {
			//break label;//break默认退出内层循环

for(1初始化变量;2循环条件;3迭代部分){//1->2->4->3->2->4->3.....
    4循环体;//123可以不再for后面，但是分号必须要有
}
1.初始化变量
while(2.循环条件){//1->2->3->4->2->3->4
    3.循环体；
    4.迭代部分;//不要忘记迭代部分
}
1.初始化变量
do{//至少循环一次循环体
	3.循环体；
    4.迭代部分;
}while(2.循环条件)
1->3->4->2->3->4->2

五、数组

5.1数组基础语法

package practicearrays;
import java.util.Arrays;
public class ArraysPractice {
	public static void main(String[] args) {
		String[] arr = new String[]{"aa","bb","cc","dd"};
		//数组的复制 
		String[] arr1 = new String[arr.length];
		for(int i=0;i<arr.length;i++) {
			arr1[i]=arr[i];
		}
		//数组的反转
//		String[] arr2 = new String[arr.length];
//		for(int i=0;i<arr.length;i++) {
//			arr2[i] = arr[arr.length-i-1];
//		}
		//方法一
//		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;
		}
		//线性查找
		String dest = "bb";
		boolean isFlag = true;
		for(int i=0;i<arr.length;i++) {
			if(dest.equals(arr[i])) {//字符串的比较，一样返回true
				System.out.println("找到了");
				isFlag = false;
				break;
			}
		}
		if(isFlag) {
			System.out.println("没找到");
		}
		//二分查找,数组必须有序
		int[] arr3 = new int[] {-98,5,3,89,2,6,1,0,-55,-66,56};
		//排序
		Arrays.sort(arr3);
		int dest1 = -66;
		boolean isFlag1 = true;
		int head = 0;//初始的首索引下标
		int end = arr3.length-1;//初始的末索引下标
		while(head<=end) {
			int middle = (head+end)/2;
			if(dest1 == arr3[middle]) {
				System.out.println("找到了，位置为："+middle);
				isFlag1 = false;
				break;
			}else if(dest1<arr3[middle]) {
				end = middle-1;
			}else {
				head = head+1;
			}
			
		}
		if(isFlag1) {
			System.out.println("没找到");
		}
		System.out.println(Arrays.toString(arr));
	}
}

5.1.1数组概念

• 多个相同类型的数据按一定的顺序排列存储
• 数组名称，通过索引（下标）的方式，管理数据
• 关键词（数组的组成）：数组名称，数组的长度，下标，数据，
• 数组属于引用类型（new）的变量，数组的元素可以是基本类型，也可以是引用类型
• 数组的长度一旦确定，不能改变（Array.copyof(sa,sa.length*2）
• 数组的元素是有序排序的
• 数组的分类：1.按照维数，一维，二维；2.按照数组的元素类型，可以分为基本类型元素数组，引用类型元素数组
• Ctrl + shift + f : 格式化代码

5.1.2一维数组

//初始化
int[] arr1 = new int[] {10001,10002}; 
int[] arr2 = new int[3] ;
int[] arr3 = {10001,10002,10003};
int arr4[] = new int[3] ;

5.1.3二维数组

• 每个一维数组的默认初始值都是null
• 每个前面的默认初始值是后一个的地址

//二维数组初始化
int[][] arr=new int[][]{{3,2},{5,9,7},{5,6}};
int[][] arr=new int[3][2];
int[][] arr=new int[3][];
int[][] arr=new int[][3];//非法
int[] x,y[]:x是一维，y是二维
//遍历
for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr[i].length;j++){
        System.out.print(arr[i][j]+" ");
    }
    System.out.println();
}
//内存解析
System.out.println(arr[0]);//地址，初始化为null
System.out.println(arr[0][0]);//数值，未定义为初始化

5.1.4二分查找

//二分查找，要求数组必须是有序的
int[] arr = new int[]{-99,-54,-2,0,2,33,43,56,99};
boolean isFlag = true;
int number = 56;
int head = 0;
int end = arr.length-1;
while(head<=end) {
	int mid = (head+end)/2;
	if(arr[mid] == number) {
		System.out.println("找到了，索引为："+mid);
		isFlag = false;
		break;
	}else if(arr[mid]>number) {
		end= mid-1;
	}else {
		head = mid+1;
	}
}
if(isFlag) {
	System.out.println("没找到");
}

5.2排序算法

5.2.1排序算法因素

• 时间复杂度：分析关键字的比较次数和记录的移动次数
• 空间复杂度：分析排序算法中需要多少辅助内存
• 稳定性：若俩个记录A和B的关键字值相等，但排序后A，B的先后次序保持不变，则称这种排序算法是稳定的

5.2.2排序算法分类

• 内部排序：整个排序过程不需要借助于外部存储器，所有排序操作都在内存中完成
• 参数排序的数据非常多，数据量非常大，计算机无法把整个排序火车放在内存中完成，必须借助于外部存储器，外部排序最常见的是多路归并排序，可以认为外部排序是由多次内部排序组成。

5.2.3十大排序算法

选择排序

1直接选择排序

2堆排序

交换排序

3冒泡排序

4快速排序

插入排序

5直接插入排序

6折半插入排序

7Shell排序

8归并排序

9桶式排序

10基数排序

5.3算法五大特征

5.4数据结构

5.3.1逻辑关系

• 数据与数据之间的逻辑关系，集合，一对一，一对多，多对多

5.3.2数据存储结构

• 线性表（一对一）：顺序表（比如：数组），链表，栈，队列
• 树形结构：二叉树
• 图形结构

5.5Arrays工具使用

5.6数组常见异常

• ArrayIndexOutOfBoundsException数组脚表越界异常
• NUllPointerException 空指针异常，没有指向实体