1.java关键字的使用 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词） 特点：关键字中所字母都为小写 具体哪些关键字： 2.保留字：现Java版本尚未使用，但以后版本可能会作为关键字使用。 具体哪些保留字：goto 、const 注意：自己命名标识符时要避免使用这些保留字
3.标识符的使用 定义：凡是自己可以起名字的地方都叫标识符。 涉及到的结构： 包名、类名、接口名、变量名、方法名、常量名 规则：(必须要遵守。否则，编译不通过)
规范：（可以不遵守，不影响编译和运行。但是要求大家遵守） 注意点： 在起名字时，为了提高阅读性，要尽量意义，“见名知意”。
1.1 按数据类型分类 详细说明： //1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节) //① byte范围：-128 ~ 127 // ② 声明long型变量，必须以"l"或"L"结尾 // ③ 通常，定义整型变量时，使用int型。 //④整型的常量，默认类型是：int型 //2. 浮点型：float(4字节) \ double(8字节) //① 浮点型，表示带小数点的数值 //② float表示数值的范围比long还大 //③ 定义float类型变量时，变量要以"f"或"F"结尾 //④ 通常，定义浮点型变量时，使用double型。 //⑤ 浮点型的常量，默认类型为：double //3. 字符型：char (1字符=2字节) //① 定义char型变量，通常使用一对’’,内部只能写一个字符 //② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量 //4.布尔型：boolean //① 只能取两个值之一：true 、 false //② 常常在条件判断、循环结构中使用 1.2 按声明的位置分类(了解)
2.定义变量的格式： 数据类型 变量名 = 变量值; 或 数据类型 变量名; 变量名 = 变量值;
3.变量使用的注意点： ① 变量必须先声明，后使用 ② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了 ③ 同一个作用域内，不可以声明两个同名的变量 4.基本数据类型变量间运算规则 4.1 涉及到的基本数据类型：除了boolean之外的其他7种 4.2 自动类型转换(只涉及7种基本数据类型） 结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。 byte 、char 、short --> int --> long --> float --> double 特别的：当byte、char、short三种类型的变量做运算时，结果为int型 说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
4.3 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。 1.需要使用强转符：() 2.注意点：强制类型转换，可能导致精度损失。 4.4 String与8种基本数据类型间的运算
String属于引用数据类型,翻译为：字符串声明String类型变量时，使用一对""String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+运算的结果仍然是String类型 避免： String s = 123;//编译错误 String s1 = "123"; int i = (int)s1;//编译错误一、分支结构 1.if-else条件判断结构 1.1. 结构一：
if(条件表达式){ 执行表达式 }结构二：二选一
if(条件表达式){ 执行表达式1 }else{ 执行表达式2 }结构三：n选一
if(条件表达式){ 执行表达式1 }else if(条件表达式){ 执行表达式2 }else if(条件表达式){ 执行表达式3 } ... else{ 执行表达式n }1.2.说明：
else 结构是可选的。针对于条件表达式：如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
if-else结构是可以相互嵌套的。如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。2.switch-case选择结构
switch(表达式){ case 常量1: 执行语句1; //break; case 常量2: 执行语句2; //break; ... default: 执行语句n; //break; }2.说明： ① 根据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结构是可选的，而且位置是灵活的。 3.如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。 4.break在switch-case中是可选的 二、循环结构 1.循环结构的四要素 ① 初始化条件 ② 循环条件 —>是boolean类型 ③ 循环体 ④ 迭代条件 说明：通常情况下，循环结束都是因为②中循环条件返回false了。
2.三种循环结构： 2.1 for循环结构
for(①;②;④){ ③ } 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②2.2 while循环结构 ①
while(②){ ③; ④; } 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②说明： 写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
for和while循环总结：
开发中，基本上我们都会从for、while中进行选择，实现循环结构。for循环和while循环是可以相互转换的！ 区别：for循环和while循环的初始化条件部分的作用范围不同。我们写程序，要避免出现死循环。 2.3 do-while循环结构 ① do{ ③; ④; }while(②); 执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②说明： 1.do-while循环至少会执行一次循环体！ 2.开发中，使用for和while更多一些。较少使用do-while
3.“无限循环”结构: while(true) 或 for(;😉 总结：如何结束一个循环结构？ 方式一：当循环条件是false时 方式二：在循环体中，执行break
4.嵌套循环 1.嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环 内层循环：循环结构A 外层循环：循环结构B 2.说明： ① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次 ② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次 ③ 外层循环控制行数，内层循环控制列数 【典型练习】 //练习一： /* ****** ****** ****** ****** */
for(int j = 1;j <= 4;j++ ){ for(int i = 1;i <= 6;i++){ System.out.print('*'); } System.out.println(); } //练习二： /* i(行号) j(*的个数) * 1 1 ** 2 2 *** 3 3 **** 4 4 ***** 5 5 */ for(int i = 1;i <= 5;i++){//控制行数 for(int j = 1;j <= i;j++){//控制列数 System.out.print("*"); } System.out.println(); } //练习三：九九乘法表 //练习四：100以内的质数补充:衡量一个功能代码的优劣： 1.正确性 2.可读性 3.健壮性 4.高效率与低存储：时间复杂度 、空间复杂度 （衡量算法的好坏）
如何理解流程控制的练习： 流程控制结构的使用 + 算法逻辑 三、关键字break和continue 使用范围 循环中使用的作用(不同点) 相同点 break: switch-case 循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
补充：带标签的break和continue的使用
return在方法中讲。
四、Scanner类的使用 如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤： 1.导包：import java.util.Scanner; 2.Scanner的实例化:Scanner scan = new Scanner(System.in); 3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量
注意： 需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException 导致程序终止。 */
在这里插入代码片//1.导包：import java.util.Scanner; import java.util.Scanner; class ScannerTest{ public static void main(String[] args){ //2.Scanner的实例化 Scanner scan = new Scanner(System.in); //3.调用Scanner类的相关方法 System.out.println("请输入你的姓名："); String name = scan.next(); System.out.println(name); System.out.println("请输入你的芳龄："); int age = scan.nextInt(); System.out.println(age); System.out.println("请输入你的体重："); double weight = scan.nextDouble(); System.out.println(weight); System.out.println("你是否相中我了呢？(true/false)"); boolean isLove = scan.nextBoolean(); System.out.println(isLove); //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串 System.out.println("请输入你的性别：(男/女)"); String gender = scan.next();//"男" char genderChar = gender.charAt(0);//获取索引为0位置上的字符 System.out.println(genderChar); } }数组名
元素
角标、下标、索引
数组的长度：元素的个数
3.数组的特点：1数组是序排列的2数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型3创建数组对象会在内存中开辟一整块连续的空间4数组的长度一旦确定，就不能修改。 数组的分类： ① 照维数：一维数组、二维数组、。。。② 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组数据结构： 1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多 2.数据的存储结构： 线性表：顺序表（比如：数组）、链表、栈、队列 树形结构：二叉树 图形结构：
算法： 排序算法： 搜索算法：
1.一维数组的声明与初始化 正确的方式：
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};//类型推断错误的方式： // int[] arr1 = new int[]; // int[5] arr2 = new int[5]; // int[] arr3 = new int[3]{1,2,3};
2.一维数组元素的引用：通过角标的方式调用。 //数组的角标（或索引从0开始的，到数组的长度-1结束。
names[0] = "王铭"; names[1] = "王赫"; names[2] = "张学良"; names[3] = "孙居龙"; names[4] = "王宏志";//charAt(0)3.数组的属性：length System.out.println(names.length);//5 System.out.println(ids.length);
说明： 数组一旦初始化，其长度就是确定的。arr.length 数组长度一旦确定，就不可修改。 4.一维数组的遍历
for(int i = 0;i < names.length;i++){ System.out.println(names[i]); }5.一维数组元素的默认初始化值 > 数组元素是整型：0
> 数组元素是浮点型：0.0 > 数组元素是char型：0或'\u0000'，而非'0' > 数组元素是boolean型：false > 数组元素是引用数据类型：null1.如何理解二维数组？ 数组属于引用数据类型 数组的元素也可以是引用数据类型 一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。
2.二维数组的声明与初始化 正确的方式：
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}};//类型推断错误的方式： // String[][] arr4 = new String[][4]; // String[4][3] arr5 = new String[][]; // int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}}; 3.如何调用二维数组元素:
System.out.println(arr1[0][1]);//2 System.out.println(arr2[1][1]);//null arr3[1] = new String[4]; System.out.println(arr3[1][0]); System.out.println(arr3[0]);//4.二维数组的属性：
System.out.println(arr4.length);//3 System.out.println(arr4[0].length);//3 System.out.println(arr4[1].length);//45.遍历二维数组元素
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(); }6.二维数组元素的默认初始化值
规定：二维数组分为外层数组的元素，内层数组的元素 int[][] arr = new int[4][3]; 外层元素：arr[0],arr[1]等 内层元素：arr[0][0],arr[1][2]等 ⑤ 数组元素的默认初始化值针对于初始化方式一：比如：int[][] arr = new int[4][3]; 外层元素的初始化值为：地址值 内层元素的初始化值为：与一维数组初始化情况相同 针对于初始化方式二：比如：int[][] arr = new int[4][]; 外层元素的初始化值为：null 内层元素的初始化值为：不能调用，否则报错。 数组的常见算法1.数组的创建与元素赋值： 2.针对于数值型的数组： 最大值、最小值、总和、平均数等 3.数组的赋值与复制 int[] array1,array2; array1 = new int[]{1,2,3,4};3.2 复制：
array2 = new int[array1.length]; for(int i = 0;i < array2.length;i++){ array2[i] = array1[i]; }如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。 4.数组元素的反转
//方法一： // 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; // }6.数组的排序算法
4）手写冒泡排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99}; //冒泡排序 for(int i = 0;i < arr.length - 1;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; } } }Arrats工具类的使用 1.理解： ① 定义在java.util包下。 ② Arrays:提供了很多操作数组的方法。
2.使用：
//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("未找到"); }数组的常见异常 1.数组角标越界异常：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"); 2.空指针异常：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());小知识：一旦程序出现异常，未处理时，就终止执行。
1.面向对象学习的三条主线：
1.Java类及类的成员：属性、方法、构造器；代码块、内部类2.面向对象的大特征：封装性、继承性、多态性、(抽象性)3.其它关键字：this、super、static、final、abstract、interface、package、import等类与对象
面向对象中两个重要的概念： 类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
面向对象程序设计的重点是类的设计 设计类，就是设计类的成员。
二者的关系： 对象，是由类new出来的，派生出来的。 对象的创建与对象的内存解析 典型代码：
Person p1 = new Person(); Person p2 = new Person(); Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象 特点：匿名对象只能调用一次。 举例：
new Phone().sendEmail(); new Phone().playGame(); new Phone().price = 1999; new Phone().showPrice();//0.0应用场景：
PhoneMall mall = new PhoneMall(); //匿名对象的使用 mall.show(new Phone()); 其中， class PhoneMall{ public void show(Phone phone){ phone.sendEmail(); phone.playGame(); } }类的设计中，两个重要结构之一：属性 对比：属性 vs 局部变量
1.相同点：
1.1 定义变量的格式：数据类型 变量名 = 变量值 1.2 先声明，后使用 1.3 变量都其对应的作用域2.不同点： 2.1 在类中声明的位置的不同
属性：直接定义在类的一对{}内 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量 2.2 关于权限修饰符的不同 属性：可以在声明属性时，指明其权限，使用权限修饰符。 常用的权限修饰符：private、public、缺省、protected --->封装性 目前，大家声明属性时，都使用缺省就可以了。 局部变量：不可以使用权限修饰符。 2.3 默认初始化值的情况： 属性：类的属性，根据其类型，都默认初始化值。 整型（byte、short、int、long：0） 浮点型（float、double：0.0） 字符型（char：0 （或'\u0000'）） 布尔型（boolean：false） 引用数据类型（类、数组、接口：null） 局部变量：没默认初始化值。 意味着，我们在调用局部变量之前，一定要显式赋值。 特别地：形参在调用时，我们赋值即可。 2.4 在内存中加载的位置： 属性：加载到堆空间中 （非static） 局部变量：加载到栈空间类的设计中，两个重要结构之二：方法
方法的声明：权限修饰符 返回值类型 方法名(形参列表){ * 方法体 * }方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。 方法中，不可以定义方法。return关键字： 1.使用范围：使用在方法体中 2.作用：① 结束方法
② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。3.注意点：return关键字后面不可以声明执行语句。 方法的重载 方法的重载的概念 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 * 总结：“两同一不同”:同一个类、相同方法名 参数列表不同：参数个数不同，参数类型不同 构成重载的举例：
//如下的4个方法构成了重载 public void getSum(int i,int j){ System.out.println("1"); } public void getSum(double d1,double d2){ System.out.println("2"); } public void getSum(String s ,int i){ System.out.println("3"); } public void getSum(int i,String s){ System.out.println("4"); }方法的重写 什么是方法的重写(override 或 overwrite)？ 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作 重写的规则：
方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{ * //方法体重载和重写的概念： 重载：不表现为多态性。 重写：表现为多态性。 递归方法 定义： 递归方法：一个方法体内调用它自身。 如何理解递归方法？
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。 举例： // 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3 if (n == 1) { return 1; } else { return n + getSum(n - 1); } } // 例2：计算1-n之间所自然数的乘积:n! public int getSum1(int n) { if (n == 1) { return 1; } else { return n * getSum1(n - 1); } } //例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n), //其中n是大于0的整数，求f(10)的值。 public int f(int n){ if(n == 0){ return 1; }else if(n == 1){ return 4; }else{ // return f(n + 2) - 2 * f(n + 1); return 2*f(n - 1) + f(n - 2); } }面向对象的特征一：封装与隐藏 封装性 封装性思想具体的代码体现： 体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius; public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; }体现二：不对外暴露的私有的方法 体现三：单例模式（将构造器私有化） 体现四：如果不希望类在包外被调用，可以将类设置为缺省的。 Java规定的四种权限修饰符： 权限从小到大顺序为：private < 缺省 < protected < public 具体的修饰范围： 权限修饰符可用来修饰的结构说明： 4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类 修饰类的话，只能使用：缺省、public 类的结构之三：构造器 构造器（或构造方法）：Constructor 构造器的作用：
1.创建对象2.初始化对象的信息 使用说明：1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器2.定义构造器的格式：权限修饰符 类名(形参列表){}3.一个类中定义的多个构造器，彼此构成重载4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器5.一个类中，至少会有一个构造器。 举例： //构造器 public Person(){ System.out.println("Person()....."); } public Person(String n){ name = n; } public Person(String n,int a){ name = n; age = a; }关键字this： 可以调用的结构：属性、方法；构造器 this调用属性、方法： this理解为：当前对象 或 当前正在创建的对象 面向对象的特征二：继承性 继承性的格式：
class A extends B{} * A:子类、派生类、subclass * B:父类、超类、基类、superclassJava中继承性的说明 1.一个类可以被多个子类继承。 2.Java中类的单继承性：一个类只能有一个父类 3.子父类是相对的概念。 4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类 5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法 关键字： super super 关键字可以理解为：父类的 可以用来调用的结构： 属性、方法、构造器 面向对象的特征三：多态性 多态性的理解：可以理解为一个事物的多种形态。 何为多态性： 对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用） 举例：
Person p = new Man(); Object obj = new Date();多态性使用的注意点： 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边） Object类的使用 Object类是所Java类的根父类 equals()方法 equals()的使用：
是一个方法，而非运算符 只能适用于引用数据类型 Object类中equals()的定义： public boolean equals(Object obj) { return (this == obj); } * 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体 如何重写equals() 手动重写举例： class User{ String name; int age; //重写其equals()方法
public boolean equals(Object obj){ if(obj == this){ return true; } if(obj instanceof User){ User u = (User)obj; return this.age == u.age && this.name.equals(u.name); } return false; } }开发中如何实现：自动生成的 toString()方法 toString()的使用： . 当我们输出一个对象的引用时，实际上就是调用当前对象的toString() 包装类的使用 为什么要有包装类(或封装类） 为了使基本数据类型的变量具有类的特征，引入包装类。
关键字：static static:静态的 可以用来修饰的结构：主要用来修饰类的内部结构 static修饰属性：静态变量（或类变量） static修饰方法：静态方法、类方法 static的注意点： 在静态的方法内，不能使用this关键字、super关键字 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。 单例模式 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。 具体代码的实现： 饿汉式1：
class Bank{ //1.私化类的构造器 private Bank(){ } //2.内部创建类的对象 //4.要求此对象也必须声明为静态的 private static Bank instance = new Bank(); //3.提供公共的静态的方法，返回类的对象 public static Bank getInstance(){ return instance; } }饿汉式2：使用了静态代码块
class Order{ //1.私化类的构造器 private Order(){ } //2.声明当前类对象，没初始化 //4.此对象也必须声明为static的 private static Order instance = null; static{ instance = new Order(); } //3.声明public、static的返回当前类对象的方法 public static Order getInstance(){ return instance; } }懒汉式：
class Order{ //1.私化类的构造器 private Order(){ } //2.声明当前类对象，没初始化 //4.此对象也必须声明为static的 private static Order instance = null; //3.声明public、static的返回当前类对象的方法 public static Order getInstance(){ if(instance == null){ instance = new Order(); } return instance; } }2.3 两种方式的对比：
饿汉式： 坏处：对象加载时间过长。 好处：饿汉式是线程安全的 懒汉式：好处：延迟对象的创建。 目前的写法坏处：线程不安全。--->到多线程内容时，再修改类的结构：代码块 静态代码块：
内部可以输出语句 随着类的加载而执行,而且只执行一次 作用：初始化类的信息 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行 静态代码块的执行要优先于非静态代码块的执行 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
非静态代码块：
内部可以输出语句 随着对象的创建而执行 每创建一个对象，就执行一次非静态代码块 作用：可以在创建对象时，对对象的属性等进行初始化 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
关键字：final final：最终的 .可以用来修饰：类、方法、变量 final 用来修饰一个类:此类不能被其他类所继承。
比如：String类、System类、StringBuffer类final 用来修饰方法：表明此方法不可以被重写
比如：Object类中getClass();final 用来修饰变量：此时的"变量"就称为是一个常量
1. final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化 2. final修饰局部变量： 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。 static final 用来修饰属性：全局常量关键字：abstract abstract: 抽象的 .可以用来修饰：类、方法 abstract修饰类：抽象类
> 此类不能实例化 > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程） > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性abstract修饰方法：抽象方法
> 抽象方法只方法的声明，没方法体 > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。 > 若子类重写了父类中的所的抽象方法后，此子类方可实例化 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰关键字：interface interface:接口 接口使用interface来定义 *.Java中，接口和类是并列的两个结构
如何定义接口：定义接口中的成员 Java开发中，接口通过让类去实现(implements)的方式来使用.如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类Java类可以实现多个接口 —>弥补了Java单继承性的局限性格式：class AA extends BB implements CC,DD,EE. 接口与接口之间可以继承，而且可以多继承代理模式： 代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。 举例
interface NetWork{ public void browse(); } //被代理类 class Server implements NetWork{ @Override public void browse() { System.out.println("真实的服务器访问网络"); } } //代理类 class ProxyServer implements NetWork{ private NetWork work; public ProxyServer(NetWork work){ this.work = work; } public void check(){ System.out.println("联网之前的检查工作"); } @Override public void browse() { check(); work.browse(); } }工厂的设计模式 实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 类的结构：内部类 内部类：类的第五个成员 定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类 成员内部类： 如何创建成员内部类的对象？(静态的，非静态的) //创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();如何在成员内部类中调用外部类的结构？
class Person{ String name = "小明"; public void eat(){ } //非静态成员内部类 class Bird{ String name = "杜鹃"; public void display(String name){ System.out.println(name);//方法的形参 System.out.println(this.name);//内部类的属性 System.out.println(Person.this.name);//外部类的属性 //Person.this.eat(); } } }5.局部内部类的使用： //返回一个实现了Comparable接口的类的对象
public Comparable getComparable(){ //创建一个实现了Comparable接口的类:局部内部类 //方式一： // class MyComparable implements Comparable{ // // @Override // public int compareTo(Object o) { // return 0; // } // // } // // return new MyComparable(); //方式二： return new Comparable(){ @Override public int compareTo(Object o) { return 0; } }; }异常的处理 异常处理方式一：try-catch-finally
try{ * //可能出现异常的代码 * * }catch(异常类型1 变量名1){ * //处理异常的方式1 * }catch(异常类型2 变量名2){ * //处理异常的方式2 * }catch(异常类型3 变量名3){ * //处理异常的方式3 * } * .... * finally{ * //一定会执行的代码 * } *