javase语法讲解 javase内容有哪些

javase基础部分

• 第一章、标识符

• 什么是标识符？
• 标识符的定义规则

• 常量

• 什么是常量

• 变量

• 什么是变量
• 变量的声明格式
• 变量的声明

• 第二章、基本数据类型

• 基本数据类型概述
• 整数类型
• 浮点数类型
• 编码和字符集

• 什么是编码

• 转义字符
• 字符类型
• 布尔类型

• 数据类型转换问题
• final关键字
• 第三章、运算符

• java中的运算符
• 算数运算符

• / 和 % 的作用
• +的作用
• ++ 的作用

• 赋值运算符
• 扩展赋值运算符
• 关系运算符
• 逻辑运算符
• 条件运算符：三元运算符

• 第四章、流程控制

• 引入
• if 语句 分支结构

• 单分支
• 双分支
• 多分支
• 随机数
• switch

• 循环结构

• while循环和do while 循环 不常用，暂时略过
• for循环 最常用
• 循环终止关键字

• break、continue、return
• break
• continue
• retrun

• 循环嵌套

• 第五章、方法的定义，调用和重载

• 方法的定义，调用
• 方法的重载

• 第六章、数组

• 数组概念
• for循环和增强for循环的区别
• 数组的三种初始化方式

• 一、静态初始化
• 二、动态初始化
• 三、默认初始化
• 重要一点
• 求最值练练
• 找到具体索引练练
• 数组不能添加元素

• main 方法讲述
• 数组工具类
• 二维数组的定义与遍历
• 数组的三种初始化方式、静态初始化、动态初始化、默认初始化。

• 静态初始化
• 动态初始化
• 默认初始化

• 第七章、idea的使用
• 第八章、面向对象
• 断点
• 第九章、异常

• throw和throws的区别

• 第十章、常用类

• 包装类

第一章、标识符

什么是标识符？

包，类、变量、方法…等等，只要起名字的地方，那个名字就叫标识符

标识符的定义规则

1、四个可以（组成部分）：数字，字母，下划线_，美元符号$
注意：字母概念比较宽泛，指的是英文字母，汉字，日语，俄语…
但是我们一般起名字尽量使用英文字母
2、两个不可以：不可以以数字开头，不可以使用java中的关键字
3、见名知意：增加可读性
4、大小写敏感： int a ; int A;
5、遵照驼峰命名：HelloWord，这就是驼峰命名的意思。
类名：首字母大写，其余遵循驼峰命名
方法名，变量名：首字母小写，其余遵循驼峰命名
包名：全部小写，不遵循驼峰命名
6、长度无限制，但是不建议太长 asdfasdfasdfasdfasdfasdfasdfasdfasdfasdfasfd

常量

什么是常量

常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。

变量

什么是变量

可以发生改变的量称为变量

变量的声明格式

数据类型 变量名 = 初始值;

int  a  =  10;

变量的声明

1）如果你只定义一个变量，没有给变量进行赋值的话，那么其实这个变量相当于没有定义：
2）变量如果没有进行赋值的话，那么使用的时候会出错，告诉你：尚未初始化变量：
3） 变量的赋值：

int   a  =  10;
      a  =  20;

最后结果是20
结论：重复赋值会被覆盖
4）变量不可以重复定义

int a  = 10;
int a =  10;

程序会报错

第二章、基本数据类型

基本数据类型概述

Java是一种强类型语言，每个变量都必须声明其数据类型。

Java的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

PS:巧妙记忆：除了基本数据类型以外的所有类型都属于引用数据类型，本章重点：基本数据类型

整数类型

1） 定义byte类型的变量：

byte b = 126;//定义了一个byte类型的变量，名字叫b，赋值为12

System.out.println(b);

注意：超范围的赋值会报错。

2）定义一个short类型变量

short s = 30000;

3）定义一个int类型变量

int i = 1234;

4）定义一个long类型变量

long num5 = 12345678910L;

注意：只有这个数超出int类型的范围了后面才需要加上L，否则无需加L也可以赋值给long类型：

浮点数类型

浮点数概述：

单精度浮点数 : float

双精度浮点数 ：double

PS：有效数字指的是从左开始第一个不为0的数到最后一个数

例如 ： 0.00323 有效数字为323

3.2123 有效数字为3.2123

//浮点类型的变量：

//注意：浮点型默认是double类型的，要想将一个double类型的数赋给float类型，必须后面加上F或者f

float f1 = 3.14234567898623F;

//注意：double类型后面可以加D或者d，但是一般我们都省略不写

double d1 = 3.14234567898623D;

//注意：我们最好不要进行浮点类型的比较：

float f2 = 0.3F;

double d2 = 0.3;

System.out.println(f2d2);
区别：
= 赋值运算： 将等号右侧的值赋给等号左侧
== 判断左右两侧的值是否相等 ：结果要么相等 要么不相等

==运算符的结果就是要么是true，要么是false

编码和字符集

什么是编码

实际上编码就是字符集

以后我们用的最多的就是UTF-8

转义字符

字符串就是用多个字符组成的

“abcdefr” 其实就是 ‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ 组成的

1）Java中使用单引号来表示字符常量，字符型在内存中占2个字节。

2）转义字符 \

\ 将后面的普通字符转换为特殊含义

\"		就是相当于一个   "

字符类型

定义一个字符

char  a  =  'A';

打印a的时候会正常输出a
如果a+10;会打印出其他数字，这个数字的来源是对应a的哈希码表值进行运算的
用记事本选择编码方法的时候一般要选择为ANSI—》获取当前操作系统的编码格式：GBK
idea编码是UTF-8

布尔类型

boolean类型有两个常量值，true和false，在内存中占一位**（不是一个字节）**，不可以使用 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。 boolean 类型用来判断逻辑条件，一般用于程序流程控制 。
//创建一个布尔类型的变量：

boolean flag1 = true;
    System.out.println(flag1);
    boolean flag2 = false;
    System.out.println(flag2);

数据类型转换问题

基本数据类型从小到大排序
byte、short、int 、long 、float 、 double
小类型转大类型时自动转换
double d = 12; 将int类型的12转成double类型的12.0
将大类型转换成小类型（需要强制类型转换）如果不强转程序会报错
语法格式： 数据类型 变量名称 = （需要转化成的数据类型）大类型
int i = （int）2.2； 此时的程序是 2 ，因为大类型转小类型，容易损失一些
注意：
1）boolean类型不能加入到运算中
2）在一个等式中同时有多重类型运算时，用最大的类型做接收

final关键字

提取变量，提取变量，就是为了一劳永逸，以后只要改变变量的值，下面只要用到这个变量的地方，取值也都发生变化了
一个变量被final修饰，这个变量就变成了一个常量，这个常量的值就不可变了
约定俗成的规定：字符常量的名字全部大写

第三章、运算符

java中的运算符

【1】Java 语言支持如下运算符：
算术运算符
+，-，，/，%，++（自增），–（自减）
赋值运算符
=
扩展赋值运算符
+=，-=，=，/=
关系运算符

，<，>=，<=，==，!=
逻辑运算符
&，|， &&，||，!，^
位运算符
&，|，^，~ ， >>，<<，>>> (了解！！！)
条件运算符
？：

算数运算符

/ 和 % 的作用

一、/ 除法运算符 ： 表示两个数相除运算
例子：int i = 10 / 2 结果等于5 二、 % 取余运算符： 用来求余数的
int i = 12%5 结果等会 2
总结：运算只要有浮点数参与，结果就是浮点数类型，按最大类型算

+的作用

总结：
一、表示正数
二、表示两个数相加操作
三、字符串拼接：规则：+左右两侧的任意一侧有字符串，那么这个加号就是字符串拼接的作用，结果一定是字符串

++ 的作用

int a = 5;
				a++;//理解为：相当于  a=a+1 操作  
                System.out.println(a);//6
				a = 5;
                ++a;//理解为：相当于  a=a+1 操作  
                System.out.println(a); //6

总结：无论这个变量是否参与到运算中去，只要用++运算符，这个变量本身就加1操作
只是说如果变量参与到运算中去的话，对运算结果是产生影响：
看++在前还是在后，如果++在后：先运算，后加1 如果++在前，先加1，后运算

赋值运算符

结论： = 的作用： 将等号右侧的值赋给等号左侧：

扩展赋值运算符

+= ：例子
int a = 1;
a  +=  2;  相当于	a = a + 2  结果等于 3

关系运算符

>，<，>=，<=，==，!=		见符号知其意思

结论：！代表着相反的意思。

逻辑运算符

只需要记住 && 和 || 就ok了
&& 代表着 并且 的意思
|| 代表着或者的意思
结论：进行逻辑运算的，运算符左右连接的都是 布尔类型的操作数，最终表达式的结果是布尔值：要么是true，要么false

条件运算符：三元运算符

语法：a > b ? 1 : 0
结论：当a>b是结果是1，当不大于b时结果是0

第四章、流程控制

引入

【1】流程控制的作用：

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

【2】控制语句的分类：

控制语句分为三类：顺序、选择和循环。

“顺序结构”代表“先执行a，再执行b”的逻辑。

“条件判断结构”代表“如果…，则…”的逻辑。

“循环结构”代表“如果…，则再继续…”的逻辑。

三种流程控制语句就能表示所有的事情！不信，你可以试试拆分你遇到的各种事情。这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。

本章是大家真正进入编程界的“门票”。

【3】流程控制的流程：

if 语句 分支结构

单分支

if 语法 ：
if(布尔表达式){
语句块
}
结论：() 中一定是true或者false，如果是true执行语句块，否则不执行

双分支

语法 ：

if (布尔表达式) {

语句块

} else {

语句块

}

结论：当布尔表达式为真时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示：

多分支

语法 ：
if(布尔表达式1) {
语句块1;
} else if(布尔表达式2) {
语句块2;
}……
else if(布尔表达式n){
语句块n;
} else {
语句块n+1;
}
结论：
【1】else:隐藏了一个条件，跟上面分支条件表达式相反的功能
【2】多分支：好处：只要满足一个 分支以后，后面的分支就不需要判断了 --》效率高
【3】我们写代码的时候，尽量保证else的存在–》else分支相当于“兜底”“备胎”的作用，别的分支都不走，就会走这个分支了

随机数

随机数：这个数在生成之前我们不确定这个数是多少，不可知

在java中依靠一个类：Math类帮助我们生成，这个类中有一个方法专门用来生成随机数：

Math.random() -------> [0.0,1.0)

Math.random()*6 ----->[0.0,6.0)

(int)(Math.random()*6) ----->[0,5]

(int)(Math.random()*6) +1 ----->[1,6]

结论：生成是一个double类型需要强转成int类型

switch

语法：
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:默认语句;]
}
结论：满足下列任意一个case值时执行，如果不满足执行default中语句

循环结构

while循环和do while 循环 不常用，暂时略过

for循环 最常用

一、语法格式：遍历就是循环的意思
for (初始表达式; 布尔表达式; 迭代因子) {
循环体;
}
for （int i = 0；i<=100；i++） {
sout(i);
}
结果为：0 到 100
二、死循环语法：
for （; ;） {
语句块
}
三、do-while,while,for循环谁的效率高？ 一样高
总结：先执行初始表达式，然后布尔表达式，循环体，最后步进语句（迭代因子）

循环终止关键字

break、continue、return

关键字概念：

在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出当前最近循环，不执行循环中剩余的语句。
continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
return的作用,结束当前所在方法的执行.

break

public class TestFor02{
        public static void main(String[] args){
                //功能：求1-100的和，当和第一次超过300的时候，停止程序
                int sum = 0;
                for(int i=1;i<=100;i++){	
                        sum += i;	
                        if(sum>300){//当和第一次超过300的时候
                                //停止循环
                                break;//停止循环
                        }
                        System.out.println(sum);
                }
                
        }
}

结论：循环结束，后面代码不会执行

public class TestFor03{
        public static void main(String[] args){
                //break的作用：停止最近的循环
                /*
                for(int i=1;i<=100;i++){
                        System.out.println(i);
                        if(i==36){
                                break;//1-36
                        }
                }
                */
                for(int i=1;i<=100;i++){
                        System.out.println(i);
                        while(i==36){
                                break; //1-100  ---》break停止的是while循环，而不是外面的for循环
                        }
                }
        }
}

结论：结束最近的一次循环，对外层循环没有影响

break带标签的使用：

public class TestFor04{
        public static void main(String[] args){
                outer:     ----》定义标签结束的位置
                for(int i=1;i<=100;i++){
                        System.out.println(i);
                        while(i==36){
                                break outer;    ----》根据标签来结束循环 
                        }
                }
        }
}

continue

作用：结束本次循环，进去到下一次循环
例子：

for（int i = 1 ； i < 50；i++）{
	if （i ==20） {
		continue；
	}
	sout(i);
}

总结：打印的结果 中 从 1 到 49 不包括 20 ，同样可以使用标号，和break一样

retrun

return的作用：跟循环无关，就是程序中遇到return那么return所在的那个方法就停止执行了：
总结：使用break关键字，无论你套了多少层循环都不需要标号，直接结束本方法，非常霸道

循环嵌套

结论：双层循环时，最外层循环一遍，内层循环一整次

第五章、方法的定义，调用和重载

结论：非静态方法可以调用静态方法，静态方法不能调用非静态方法

方法的定义，调用

1）方法的定义，调用

方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

2）方法声明格式：

[修饰符1  修饰符2  …]  返回值类型    方法名(形式参数列表){
        Java语句；… … …
}

3）方法声明格式：

对象名.方法名(实参列表)
总结：在本类中可以直接调用方法名，如果是static修饰的方法，可以通过类名.方法名调用，否则只能通过对象的方式调用
4）方法的详细说明
形式参数：在方法声明时用于接收外界传入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void。
5）总结
1.方法是：对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的方法
2.方法和方法是并列的关系，所以我们定义的方法不能写到main方法中
3.方法的定义–》格式：

修饰符 方法返回值类型 方法名(形参列表){
            方法体;
            return 方法返回值;
    }

4.方法的作用：提高代码的复用性
5.总结方法定义的格式：
1、修饰符: 暂时使用public static —>面向对象一章讲解
2、方法返回值类型 : 方法的返回值对应的数据类型
数据类型： 可以是基本数据类型（byte,short,int,long,float,double,char,boolean） 也可以是引用数据类型
3、方法名 :见名知意，首字母小写，其余遵循驼峰命名， eg: addNum ,一般尽量使用英文来命名
4、形参列表 :方法定义的时候需要的形式参数 ： int num1, int num2 -->相当于告诉方法的调用者：需要传入几个参数，需要传入的参数的类型
实际参数：方法调用的时候传入的具体的参数： 10,20 -->根据形式参数的需要传入的
5、方法体：具体的业务逻辑代码
6、return 方法返回值;
方法如果有返回值的话： return+方法返回值，将返回值返回到方法的调用处
方法没有返回值的话：return可以省略不写了，并且方法的返回值类型为：void
什么时候有返回值，什么时候没有返回值？ 看心情–》看需求
6.方法的定义需要注意什么？
1）形参列表要怎么写：定义几个参数，分别是什么类型的 —》不确定因素我们会当做方法的形参
2) 方法到底是否需要返回值 ，如果需要的话，返回值的类型是什么
7.方法的调用需要注意什么？
1）实际参数要怎么传入：传入几个参数，传入什么类型的
2） 方法是否有返回值需要接受**

方法的重载

【1】什么是方法的重载：
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！

【2】构成方法重载的条件：
❀不同的含义：形参类型、形参个数、形参顺序不同
❀ 只有返回值不同不构成方法的重载
如：int a(String str){}与 void a(String str){}不构成方法重载
❀ 只有形参的名称不同，不构成方法的重载
如：int a(String str){}与int a(String s){}不构成方法重载
总结：
1.方法的重载：在同一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。
2.方法的重载只跟：方法名和形参列表有关，与修饰符，返回值类型无关。
3.注意：形参列表不同指的是什么？
（1）个数不同
add() add(int num1) add(int num1,int num2)
（2）顺序不同
add(int num1,double num2) add(double num1,int num2)
（3）类型不同
add(int num1) add(double num1)
4.请问下面的方法是否构成了方法的重载？
(1)add(int a) 和 add(int b) —>不构成,相当于方法的重复定义
(2)public static int add(int a) 和 public static void add(int b) —>不构成

第六章、数组

数组概念

【1】数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

【2】数组的学习：

public static void main(String[] args){
                //数组的作用：用来存储相同类型的数据
                //以int类型数据为案例：数组用来存储int类型数据
                //1.声明(定义数组)
                int[] arr; //定义一个int类型的数组，名字叫arr
                //int arr2[];
                //如果数组只声明，没有后续操作，那么这个数组相当于没定义
                //int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值  不一样的效果 
                
                //2.创建
                arr = new int[4];//给数组开辟了一个长度为4的空间
                //编译期声明和创建会被合为一句话: int[] arr = new int[4];
                
                //3.赋值
                arr[0] = 12;
                arr[3] = 47;
                arr[2] = 98;
                arr[1] = 56;
                arr[2] = 66;
                /*
                arr[4] = 93;
                出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
                Array 数组
                Index 索引
                OutOf 超出
                Bounds 界限
                Exception 异常
                ---》数组索引越界异常  
                */
                 //4.使用
                System.out.println(arr[2]);
                System.out.println(arr[0]+100);
                //通过数组一个属性来获取  length 长度
                System.out.println("数组的长度是："+arr.length);
        }

for循环和增强for循环的区别

语法：
普通for

int[] scores = {1,2，3,4，5,6};
for（int i = 0;i<scores.length;i++） {
		sout(scores[i])
}
增强for循环
for(int  i  : scores ){
	sout(i);
}

增强for循环：
优点：代码简单
缺点：单纯的增强for循环不能涉及跟索引相关的操作

数组的三种初始化方式

一、静态初始化

int[] arr = {12,23,45};

int[] arr = new int[]{12,23,45};

二、动态初始化

int[] arr ;

arr = new int[3]

arr[0] = 12;

arr[1] = 23;

arr[2] = 45;

三、默认初始化

int[] arr = new int[3]; —> 数组有默认的初始化值

结论：定义数组，遵循这三种格式就ok了，遍历的时候遍历索引就ok了

重要一点

循环是找规律的，所有有规律的基本上都可以用集合来解决：例如九九乘法表之类的
开发过程中一定要利用好 判断 和 循环 真的太重要了

求最值练练

public static void main(String[] args) {
       /*
             将求最大值的方法提取出来：
        */
        testUtils();
    }
    public static void testUtils(){
        int[] i = {1,2,5,6,9,7,4,12,54,5,8,7};
        int i1 = arrayMaxUtils(i);
        System.out.println(i1);
    }

    public static int arrayMaxUtils(int[] ints){
        /*
            求数组中最大的数值
         */
        //假设索引为0的是最大元素，索引为0代表着是第一个元素
        int max = ints[0];
        //遍历这个数组
        for (int i = 0; i < ints.length; i++) {
            if (ints[i]>max) {
                max = ints[i];
            }
        }
        return max;
    }

找到具体索引练练

public static void main(String[] args) {
        //找到4的索引是多少
        int[] i = {1, 2, 3, 4, 5, 6, 7};
        集体索引(i, 4);
    }
    
    public static int 集体索引(int[] i, int num) {
        int index = -1;
        for (int j = 0; j < i.length; j++) {
            if (i[j] == num) {
                index = j;
            }
        }
        if (index == -1) {
            System.out.println("没查到");
        } else {
            System.out.println("查到的索引为：" + index);
        }
        return index;
    }

数组不能添加元素

结论：数组中不能添加元素，最大限度也就是把之前的数给替换掉，然后重新排序，删除也是重新排序的过程

main 方法讲述

暂时不写

数组工具类

//给定一个数组：
                int[] arr = {1,3,7,2,4,8};
                //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
                System.out.println(Arrays.toString(arr));
                
                //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
                //这个方法的使用前提：一定要查看的是一个有序的数组：
                //sort：排序 -->升序
                Arrays.sort(arr);
                System.out.println(Arrays.toString(arr));
                System.out.println(Arrays.binarySearch(arr,4));
                
                int[] arr2 = {1,3,7,2,4,8};
                //copyOf:完成数组的复制：
                int[] newArr = Arrays.copyOf(arr2,4);
                System.out.println(Arrays.toString(newArr));
                
                //copyOfRange:区间复制：
                int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
                System.out.println(Arrays.toString(newArr2));
                
                //equals:比较两个数组的值是否一样：
                int[] arr3 = {1,3,7,2,4,8};
                int[] arr4 = {1,3,7,2,4,8};
                System.out.println(Arrays.equals(arr3,arr4));//true
                System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
                
                //fill：数组的填充：
                int[] arr5 = {1,3,7,2,4,8};
                Arrays.fill(arr5,10);
                System.out.println(Arrays.toString(arr5));

二维数组的定义与遍历

定义：
int[][] arr = new int[3][];
arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4};
arr[2] = new int[]{5,6};
总结：定义一个长度为3的二维数组，每个二维数组中都是一个一维数组
理解 ： System.out.println(arr[1][0]); 此时结果为：3
遍历：

二维数组的长度
for (int i = 0; i < arr.length; i++) {
二维数组中一维数组的长度
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }

内存图：一目了然

数组的三种初始化方式、静态初始化、动态初始化、默认初始化。

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4,5,6};
arr[2] = new int[]{34,45,56};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public class TestArray16{
        public static void main(String[] args){
                int[][] arr = new int[3][2];
                //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：

                arr[1] = new int[]{1,2,3,4};

                //数组遍历：
                for(int[] a:arr){
                        for(int num:a){
                                        System.out.print(num+"\t");
                        }
                        System.out.println();
                }

        }
}

第七章、idea的使用

暂时略

第八章、面向对象

暂时略

断点

常用断点调试快捷键：

第九章、异常

一、异常出现了以后怎么看

二、捕获异常： try-catch

语法：

try {
            //感觉会出现异常
        } catch (Exception e) {
            //出现异常时的处理
            e.printStackTrace();
        } finally {
            //一定会执行的代码块
        }

【1】在什么情况下，try-catch后面的代码不执行？
（1）throw抛出异常的情况
（2）catch中没有正常的进行异常捕获
（3）在try中遇到return

【2】怎么样才可以将 try-catch后面的代码 必须执行？
只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行。

【3】return和finally执行顺序？
先执行finally最后执行return

【4】什么代码会放在finally中呢？
关闭数据库资源，关闭IO流资源，关闭socket资源。

【5】有一句话代码很厉害，它可以让finally中代码不执行!
System.exit(0);//终止当前的虚拟机执行

throw和throws的区别

（1）位置不同：
throw：方法内部
throws: 方法的签名处，方法的声明处

（2）内容不同：
throw+异常对象（检查异常，运行时异常）
throws+异常的类型（可以多个类型，用，拼接）

（3）作用不同：
throw：异常出现的源头，制造异常。
throws:在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理：
要么自己处理要么再继续向外抛出异常

第十章、常用类

包装类

引入：
【1】什么是包装类：
以前定义变量，经常使用基本数据类型，
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，
将基本数据类型对应进行了一个封装，产生了一个新的类，—》包装类。
int,byte…—>基本数据类型
包装类—>引用数据类型

【2】对应关系：

基本数据类型          对应的包装类                继承关系
byte                          Byte                           ---》Number---》Object
short                         Short                         ---》Number---》Object
int                             Integer                      ---》Number---》Object
long                          Long                          ---》Number---》Object
float                          Float                          ---》Number---》Object
double                      Double                      ---》Number---》Object
char                          Character                  Object
boolean                    Boolean                    Object

【3】已经有基本数据类型了，为什么要封装为包装类？
（1）java语言 面向对象的语言，最擅长的操作各种各样的类。
（2）以前学习装数据的—》数组，int[] String[] double[] Student[]
以后学习的装数据的—》集合，有一个特点，只能装引用数据类型的数据
【4】是不是有了包装类以后就不用基本数据类型了？
不是。
（1）自动装箱 自动拆箱 是从JDK1.5以后新出的特性
（2）自动装箱 自动拆箱 ：将基本数据类型和包装类进行快速的类型转换。