语法规则

一、变量与数据类型

变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。由于该存储单元中的数据可以发生改变，因此得名为"变量"。

1、变量分类：

基本数据类型变量

引用数据类型变量。

按照位置分类：

局部变量：方法或语句块内部定义的变量

成员变量：方法外部、类的内部定义的变量

注意：类的外面不能有变量的声明

2、数据类型：

Java中的数据类型有四类八种。

3、标识符

Java 对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。

规则：

1. 由字母、数字、下划线（_）和美元符号（$）组成。
2. 不能以数字开头
3. 区分大小
4. 长度无限制
5. 不能是 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 正在执行”);
}

三、运算符

四、转义字符

所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。
而C中定义了一些字母前加"\"来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了

程序执行结构

任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本 结构组合而成。

顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作。

分支结构又被称为选择结构，根据条件成立与否来执行操作。

循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。

一、分支结构：

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;
}

注意：

1. 表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
2. case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；
3. default 子句是可选的；
4. break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；
5. 如果 case 后面没有写 break 则直接往下面执行！
6. Case 后面的执行体可写{ }也可以不写{ }

二、循环结构

1、while循环

符合条件，循环继续执行；否则，循环退出 特点：先判断，再执行

while(条件表达式){
    //语句块；
}

使用 while 循环的步骤

1. 分析循环条件和循环操作
2. 套用 while 语法写出代码
3. 检查循环是否能够退出

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;
        }
    }