语法规则
一、变量与数据类型
变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。由于该存储单元中的数据可以发生改变，因此得名为"变量"。
1、变量分类：
基本数据类型变量
引用数据类型变量。
按照位置分类：
局部变量：方法或语句块内部定义的变量
成员变量：方法外部、类的内部定义的变量
注意：类的外面不能有变量的声明
2、数据类型：
Java中的数据类型有四类八种。
3、标识符
Java 对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。
规则：
- 由字母、数字、下划线（_）和美元符号（$）组成。
- 不能以数字开头
- 区分大小
- 长度无限制
- 不能是 Java 中的保留关键字
需要见名知意，包名小驼峰，类名大驼峰，方法小驼峰，变量名全部小写，遵循《阿里巴巴Java手册规范》。
4、类型转换
自动类型转换：容量小的类型自动转换成容量大的数据类型
byte,short,int -> float ->long ->double
byte,short,int 不会互相转换，它们三者在计算时会转换成 int 类型
强制类型转换：容量大的类型转换成容量小的数据类型时，要加上强制转换符
long l = 100L;
int i = (int)l;
有可能造成精度降低或数据溢出，使用时要小心。
二、方法
方法用于封装一段特定的逻辑功能。方法的主要要素有：权限修饰符 方法名、参数列表和返回值。
1、格式：
权限修饰符 返回值类型声明 方法名称(参数列表){
方法中封装的逻辑功能;
return 返回值;
}
2、权限修饰符
3、返回值
方法调用结束后可以返回一个数据，称之为返回值。 方法在声明时必须指定返回值的类型。 通过 return 语句返回，return 语句的作用在于结束方法且将数据返回。 如果方法没有返回值（即方法不需要返回数据），需将返回值类型声明为 void，此时直接return会结束此方法。
4、参数列表
方法的参数列表：在调用时传递给方法，需要被方法处理的数据。 在方法定义时，需要声明该方法所需要的参数变量。 在方法调用时，会将实际参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。
public void say(int a,int b){
System.out.println(“方法 say 正在执行”);
}
三、运算符
| 算术运算符 | 赋值运算符 | 关系运算符 | 逻辑运算符 | 按位运算符 | 移位运算符 | 其他 |
|---|---|---|---|---|---|---|
| + | = | == | & | AND | >> 右移运算符 | 字符串连接重载+ |
| - | += | != | | | OR | << 左移运算符 | 三目运算符（分支语句简写） |
| * | -= | < | ^亦或 | XOR | ||
| / | *= | > | ! | NOT | ||
| % | /= | <= | &&短路与 | |||
| ++ | %= | >= | ||短路或 | |||
| -- |
四、转义字符
所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。
而C中定义了一些字母前加"\"来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了
| 转义字符 | 意义 | ASCII码值（十进制） |
|---|---|---|
| \n | 换行，将当前位置移到下一行开头 | 010 |
| \r | 回车 ，将当前位置移到本行开头 | 013 |
| \t | 水平制表(HT) （跳到下一个TAB位置） | 009 |
| \ | 代表一个反斜线字符''' | 092 |
| \' | 代表一个单引号（撇号）字符 | 039 |
| \" | 代表一个双引号字符 | 034 |
程序执行结构
任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本 结构组合而成。
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作。
分支结构又被称为选择结构，根据条件成立与否来执行操作。
循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
一、分支结构：
1、if-else、if-else if-else格式：
if(条件语句){…}
if (条件语句){…}else{…}
if (条件语句){…}else if(条件语句){…}
if (条件语句){…}else if(条件语句){…}else{…}
2、switch
switch(表达式){
case 取值1: 语句块 1;break;
case 取值n: 语句块 n;break;
default: 语句块 n+1;break;
}
注意：
- 表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
- case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；
- default 子句是可选的；
- break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；
- 如果 case 后面没有写 break 则直接往下面执行！
- Case 后面的执行体可写{ }也可以不写{ }
二、循环结构
1、while循环
符合条件，循环继续执行；否则，循环退出 特点：先判断，再执行
while(条件表达式){
//语句块；
}
使用 while 循环的步骤
- 分析循环条件和循环操作
- 套用 while 语法写出代码
- 检查循环是否能够退出
2、do-while循环
先执行一遍循环操作，符合条件，循环继续执行；否则，循环退出
特点：先执行，再判断
do {
循环操作
}while ( 条件表达式 );
while 循环和 do-while 循环的区别？
- while:先判断条件，如果条件满足，再执行循环操作
- do while:先执行一遍循环操作，然后再判读条件，如果条件满足，继续执行循环操作。
3、for循环
for(初始化参数;判断条件 ;更新循环变量){
循环体;
}
逗号运算符：
这里不可忽略的一个就是逗号操作符，Java里唯一用到逗号操作符的就是for循环控制语句。在表达式的初始化部分，可以使用一系列的逗号分隔的语句;通过逗号操作符，可以在 for语句内定义多个变量，但它们必须具有相同的类型
for(int i = 1, j = i + 10;i < 5;i++, j = j * 2){}
4、for-each语句
在Java JDK 1.5中还引入了一种更加简洁的、方便对数组和集合进行遍历的方法，即for-each 语句，例子如下：
int array[] = {7, 8, 9};
for (int arr : array) {
System.out.println(arr);
}
三、跳出语句
Java语言中，有三种跳转语句: break、continue 和return。
1、break语句：
break语句我们在 switch 中已经见到了，它是用于终止循环的操作，实际上break 语句在for、while、do…while循环语句中，用于强行退出当前循环，例如
for(int i = 0;i < 10;i++){
if(i == 5){
break;
}
}
还可以通过添加标签跳出多层循环：
p:for(int j = 0; j < 10 ; j++){
for(int i = 0;i < 10;i++){
if(i == 5){
break p;
}
}
}
2、continue语句：
continue也可以放在循环语句中，它与break 语句具有相反的效果，它的作用是用于直接执行下一次循环, 而不是退出当前循环，还以上面的例子为主：
for(int i = 0;i < 10;i++){
System.out.printl(" i = " + i );
if(i == 5){
System.out.printl("continue ... ");
continue;
}
}
3、return 语句
public void getName() {
return name;
}
数组
数组是相同数据类型的多个数据的容器，这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
1、创建格式：
//格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
//格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};
//格式 3. 数据类型[] 数组名;
//格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
//格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n};
int[] a = new int[5];
int[] a = {1,2,3,4,5};
int[] a;
int[] a = new int[]{1,2,3,4,5};
2、下标
数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。我们可以通过下标的方式访问数组中的每一个元素。
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
3、获取数组长度
int len = a.length;
注意：使用数组不当会出现数组未赋值、空指针异常的问题。超出长度的下标操作会导致数组越界异常。数组的长度在创建时就固定了，如果数组已经满了想增加元素只能动态扩容（申请新数组，旧数组拷贝，释放旧数组）。
4、数组常用算法：
冒泡排序：
原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
升序排列:
最后一个位置放最大值
外层 循环length-1
内层循环length-i-1
降序排序:
最后一个位置放最小值
外层 循环length-1
内层循环length-i-1
int[] nums = new int[]{1,3,9,5,6,7,15,4,8};
int target = 6;
//冒泡排序
for(int i = 0; i < nums.length; i++){
for(int j = 0; j < nums.length - i - 1; j++){
if(nums[j] > nums[j+1]){
//可以使用亦或运算避免引入额外变量来交换
int temp = nums[j+1];
nums[j+1] = nums[j];
nums[j] = temp;
}
}
}
System.out.println("排序后的数组为");
for(int i = 0; i < nums.length; i++){
System.out.print(nums[i]+" ");
}
System.out.println("");
二分查找：
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺 序存储结构有序排列。
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用 中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查 找后子数组。 重复以上过程，直到找到满足条件的数据，则表示查找成功， 直到子数组不存在为止，表示查找不成功。
//二分查找
int minIndex = 0;
int maxIndex = nums.length - 1;
int midInex = (minIndex + maxIndex)/2;
while (minIndex <= maxIndex){
if(nums[midInex] == target) return midInex;
else if(nums[midInex] < target){
minIndex = midInex + 1;
}
else if(nums[midInex] > target){
maxIndex = midInex - 1;
}
midInex = (minIndex + maxIndex)/2;
}
System.out.println("不存在该目标数字");
return -1;
动态扩容：选取模拟实现数组的myList类中的add方法
public void add(Object...elements){
if(this.length == 0){
this.element = elements;
this.length = elements.length; // 一共有多少位置
this.size = this.length; //当前使用了多少位置
return;
}
if(this.size <= this.size + elements.length){//原本已经有内容了，但是要扩容添加
this.length = this.size + elements.length;
Object[] newElement = new Object[this.length];
int i = 0;
for( ; i < this.size; i++){
newElement[i] = element[i];
}
System.out.println("i = " + i);
for(int j = 0; j < elements.length;j++){
newElement[i] = elements[j];
i++;
}
this.element = newElement;
this.size = this.length;
}
}
网友评论