一、二维数组：
1.1 定义：int[ ][ ] num = new int[2][3];
数组名 [行的索引][列的索引]
声明并赋值：int [ ] [ ] num = {{1, 2, 3,},{11, 22, 33}};
1.2 处理数组：通过二重循环来处理数组中的数据
int [] [] num = {{1, 2, 3,},{11, 22, 33}};
for(int i = 0; i < num.length; i ++){//定位每行的元素
for(int j = 0; j < num[i].length; j ++){//该行的每个元素
System.out.println(num[i][j]);
}
}1.3 其他：定义二维数组时，可以只指定行的个数，然后再为每一行分别指定列的个数。每行的列数可以不同，则创建的是不规则的二维数组。
int[][] num = new int[3][];//定义一个三行的二维数组
num[0] = new int[2];//为第一行分配两列
num[1] = new int[3];//为第二行分配三列
num[2] = new int[4];//为第三行分配四列
num[0][0] = 1;//第一行第一列赋值为1
num[1][1] = 2;//第二行第二列赋值为2
num[2][3] = 3;//第三行第三列赋值为3二、方法的重载
1、什么是方法的重载
如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称方法的重载。
//无参数方法
public void show(){
System.out.println("hello");
}
//重载show方法，有一个参数
public void show(string name){
System.out.println("hello" + name);
}
//重载show方法，有两个参数
public void show(string name, int age){
System.out.println("hello" + name);
System.out.println("age" + age);
}
//重载show方法，两个参数顺序不同
public void show(int age, string name){
System.out.println("hello" + name);
System.out.println("age" + age);
}2、 调用：根据传参的个数和类型，传参的顺序来判断调用哪一个方法
3 、 如何判断方法重载
（1）必须在同一个类中
（2）方法名相同
（3）方法参数的个数，顺序或类型不同
（4）与方法的修饰符或返回类型没有关系
三、局部变量与成员变量
1、在初始化时，java会给成员变量一个初始值0，但是不会给局部变量初始值。
2、两种变量同名时，局部变量具有更高的优先级（就近原则）
3、在同一个方法中，不允许有同名局部变量
4、在不同方法中，可以有同名局部变量
四、构造方法
1、使用new+构造方法，创建一个新的对象
2、构造方法是定义在java类中的一个用来初始化对象的方法
3、有参构造方法目的是初始化成员变量的值
4、通过无参构造方法可以创建对象
Object obj = new Object();通过有参构造方法可以创建对象并给对象赋初值
Object obj = new Object(1, 2, 3);5、当没有构造方法时，系统会自动添加无参的构造方法。如果有构造方法（有参或无参），都 不会自动添加无参的构造方法
6、构造方法的重载：与普通方法的重载一样
7、构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值（在构造方法中加入判断）
五、static
被static修饰的成员成为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享
1、静态变量
2、静态方法
3、静态初始化块
六、面向对象三大特性：封装、继承、多态
1、封装
1.1、 封装概念：将类的某些信息隐藏在类的内部，不允许外部程序直接方法，而是通过该类提供的方法来实现隐藏信息的操作和访问
1.2、 好处：a.只能通过规定的方法访问数据。b.隐藏类的实例细节，方便修改和实现
1.3、 封装的实现步骤：
（1）修改属性的可见性（private）
（2）创建getter和setter方法（用于属性的读写）
（3）在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）
2、继承
class 子类 extends 父类2.1：继承是类和类的一种关系，是一种”is a “的关系，java中是单继承的。（一个类只有一个父类）
2.2：继承的优点：
2.2.1：子类拥有父类的所有属性和方法（属性和方法的修饰符不能是private）
2.2.2：实现代码复用
2.3：方法的重写
2.3.1：可以重写父类继承的方法，当调用方法时会优先调用子类的方法
2.3.2：语法规则：（1）返回值类型（2）方法名（3）参数类型及个数，都要与父类继承的方法相同
2.4：继承的初始化顺序
2.4.1：初始化父类再初始化子类
2.4.2：先执行初始化对象中的属性，再执行构造方法中的初始化
2.5：final关键字（最终的含义）
2.5.1：final关键字可以修饰类、方法、属性和变量
2.5.2：final修饰类，则该类不能被继承
final修饰方法，则该方法不能被覆盖（重写）
final修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（只能选其一）
final修饰变量，则该变量的值只能赋一次值，即变为常量
2.6：super关键字
在对象的内部使用，可以代表父类对象
2.6.1：访问父类的属性
super.属性
2.6.2：访问父类的方法
super.方法()
2.6.3：super的应用
子类的构造过程当中必须调用其父类的构造方法
如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法
如果显示的调用构造方法，必须在子类的构造方法的第一行
如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错
3、多态
多态是指对象的多种形态
在使用多态的时候，两个类一定要有一个继承的关系，继承是多态的实现基础
3.1
a：引用的多态
父类的引用可以指向本类的对象
父类 对象名 = new 父类();
父类的引用可以指向子类的对象
父类 对象名 = new 子类();
不允许子类的引用指向父类
b：方法的多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法
子类独有的方法是不能在父类通过引用调用子类独有的方法
3.2：引用类型转换
3.2.1：向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
子类 对象名 = new 子类();
父类 对象名 = 子类对象名;// 自动类型转换，向上类型转换
3.2.2：向下类型转换（强制类型转换），是大类型到小类型
子类 对象名 = (父类)子类对象名 向下类型转换 强制类型转换
3.2.3：instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
对象名 instanceof 对象 判断对象中是否含有该对象名对应对象的元素
七、this关键词
1、this关键字代表当前对象（this.属性 操作当前对象的属性）
八、内部类
定义在一个类里面的类叫做内部类
主要作用：
（1）：内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
（2）：内部类的方法可以直接访问外部类的所有数据，包括私有数据。
（3）：内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
分类：
1、成员内部类：
1.1：内部类可以直接访问外部类的属性
1.2：定义了成员内部类之后，必须使用外部类来创建内部类，而不能直接去new一个内部类对象
1.3：外部类不能直接使用内部类的属性和方法，要先创建内部类对象，通过对象来使用
2、静态内部类
2.1：静态内部类不能直接访问外部类的非静态成员，但是可以通过new 外部类().成员的方式访问
2.2：外部类的静态成员与内部类的成员名称相同时，可以通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
2.3：创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类（）；
3、方法内部类
3.1：内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
3.2：方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符。
九、Object类
Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。
Object类中的方法，适合所有子类
1：toString()方法：返回的对象的哈希code码（对象地址字符串）
2：equals()方法：比较的是对象的引用是否指向同一块内存地址，返回的值是一个布尔值，类对象（对象的属性信息）和类的对象（对象的属性值信息，数据信息），可重写equals方法。
十、抽象类 abstract关键字修饰
1、应用场景：
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法（抽象类约束了子类必须有哪些方法，但是并不关心怎么去实现的）
b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类模板，从而避免了子类设计的随意性
2、作用
限制规定子类必须实现某些方法，但不关注实现细节
3、使用规则
a：abstract定义抽象类
b：abstract定义抽象方法，只有声明，不需要实现（抽象方法没有方法体以分号结束）
c：包含抽象方法的类是抽象类
d：抽象类中可以包含普通的方法，也可以没有抽象方法
e：抽象类不能直接创建，可以定义引用变量
要实现抽象类的方法必须继承抽象类，继承了抽象类必须实现抽象类的方法。
引用的时候可以用抽象的父类引用指向一个子类对象。
十一、接口
接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。
1、接口的概念
类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
2、接口的定义
接口命名首字母加上大写的I
接口定义使用interface关键字
接口可以继承多个父类，继承是可选的。
接口中的属性是常量，即使定义时不添加public static final 修饰符，系统也会自动加上。方法一样会自动添加。
3、使用接口
一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。
继承父类实现接口的语法为：
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
} 如果要继承父类，继承父类必须在实现接口之前
可以与匿名内部类配合使用（匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称）
接口 接口名 = new 接口()
{
实现方法
};十二、异常
1、异常简介
java中的所有异常都继承于Throwable类，Throwable类主要有两个子类，Error类和Exception类。主要是Exception异常。
Exception有很多子类：
（1）：RuntimeException（非检查异常）
a：空指针异常 NullPointerException
b：数组下标越界异常 ArrayIndexOutOfBoundsException
c：类型转换异常 ClassCastException
d：算法异常 ArithmeticException
…
（2）：CheckException（检查异常）
a：文件异常 IOException
b：SQL异常 SQLException
2、处理异常
try-catch以及try-catch-finally捕获并处理异常
try{
//一些会抛出异常的方法
} n个catch(…) {
//…
}catch(Exception e){
//处理异常的代码块
} finally{
//最终要执行的一些代码
} 对于可能抛出多种类型的异常，采用多重catch块捕获不同类型的异常并处理。多重catch块 的编写，要注意catch块的顺序问题，按照从子类到父类的顺序编写。
3、异常抛出以及自定义异常
throw——将产生的异常抛出（动作），写在方法体里面
throws——声明将要抛出何种类型的异常（声明），写在方法名和方法的参数表之后，在方法体之前
public void 方法名（参数列表）
throws 异常列表{
//调用会抛出异常的方法或者：
throw new Exception();
}public void divide(int one, int two) throws Exception {//声明抛出异常
if(two == 0){
throw new Exception("两数相除，除数不能为0！！");
}else{
System.out.println("两数相除，结果为：" + one/two);
}
}通过try-catch语句捕获并处理异常
public void compute() {
/*
*此处省略。。。。代码
*/
try {
divide(5, 0);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}当调用者不能处理异常的时候，则将异常继续声明抛出，给更上一层的调用者去处理
public void compute() throws Exception {
/*
*此处省略。。。代码
*/
divide(5 ,0);
}
自定义异常
class 自定义异常类 extends 异常类型 {
}4、异常链
5、处理异常的经验
（1）处理运行时异常时，采用逻辑去合理规避同事辅助try-catch处理
（2）在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
（3）对于不确定的代码，也可以加上try-catch，处理潜在的异常
（4）尽量去处理异常，切忌只是简单的调用printStackTrace（）去打印输出
（5）具体如何处理异常，要根据不同的业务需求和异常类型去决定
（6）尽量添加finally语句块去释放占用的资源
十三、字符串
1、字符串的不变性：String对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。
2、String类的常用方法
1）int length()返回当前字符串的长度
2）int indexOf(int ch) 查找ch字符在该字符串中第一次出现的位置
3）int indexOf(String str) 查找str子字符串在该字符串中第一次出现的位置
4）int lastIndexOf(int ch) 查找ch字符在该字符串中最后一次出现的位置
5）int lastIndexOf(String str) 查找str子字符串在该字符串中最后一次出现的位置
6）String substring(int beginIndex) 获取从beginIndex位置开始到结束的子字符串
7）String substring(int beginIndex, int endIndex) 获取从beginIndex位置到endIndex位置的子字符串
8）String trim() 返回去除了前后空格的字符串
9）boolean equal(Object obj) 将该字符串与指定对象比较，返回true或false
10）String toLowerCase() 将字符串转换为小写
11）String toUpperCase() 将字符串转换为大写
12）char charAt(int index) 获取字符串中指定位置的字符
13）String[ ] split(String regex, int limit) 将字符串分割为子字符串，返回字符串数组
14）byte[ ] getBytes() 将该字符串转换为byte数组
使用substring(int beginIndex, int endIndex)进行字符串截取时，包括beginIndex位置的字符，不包括endIndex位置的字符
“==”与equal()的区别：
==：判断两个字符串在内存地址中的首地址是否相同，即判断是否是同一个字符串对象
equal()：比较存储在两个字符串对象中的内容是否一致
3、StringBuilder类
1）String类具有不可变性，当对String类进行修改时，程序运行时会额外创建一个String类来保存修改后的String类，如果频繁操作字符串时，就会额外产生很多临时变量。使用StringBuilder或者StringBuffer就可以避免这个问题。
2）StringBuilder和StringBuffer基本相似，区别是，StringBuffer是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高，一般情况下，需要创建一个可变的字符串对象，优先考虑使用StringBuilder类
3）创建StringBuilder类
创建一个空的StringBuilder对象
StringBuilder str1 = new StringBuilder();创建一个字符串“string”
StringBuilder str2 = new StringBuilder("string"); 4）StringBuilder类的常用方法
StringBuilder append(参数) 追加内容到当前StringBuilder对象的末尾
StringBuilder insert(位置，参数) 将内容插入到StringBuilder对象的指定位置
String toString() 将StringBuilder对象转换为String对象
int length() 获取字符串的长度
十四、包装类
1、基本数据类型如int、float、double、boolean、char等，基本数据类型是不具备对象的特征的，比如基本数据类型不能调用方法、功能简单。
2、为了让基本数据类型具备对象的特征，java为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样操作基本数据类型。
| 基本数据类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Integer |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
4、包装类主要提供了两大类方法：
1）将本类型和其他类型进行转换的方法
2）将字符串和本类型及包装类互相转换的方法
5、基本类型和包装类型之间的转换
1）装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
举例：
int i = 10;//定义一个int基本类型值
Integer x = new Integer(i);//手动装箱
Integer y = i;//自动装箱2）拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
举例：
Integer j = new Integer(8);//定义一个Integer包装类对象，值为8
int m = j.intValue();//手动拆箱
int n = j;//自动拆箱3）基本类型和字符串之间的转换
基本类型转换为字符串有三种方法：
（1）使用包装类的toString（）方法
（2）使用String类的valueOf（）方法
（3）用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串
举例：
int c = 10;//将基本类型转换为字符串
String str1 = Integer.toString(c);//方法一
String str2 = Integer.valueOf(c);//方法二
String str3 = c + "";//方法三字符串转换成基本类型有两种方法：
（1）调用包装类的parseXxx静态方法
（2）调用包装类的valueOf()方法转换为基本类型的包装类，会自动拆箱
举例：
String str = "8";//将字符串转换为基本类型
int d = Integer.parseInt(str);//方法一
int e = Integer.valueOf(str);//方法二6、使用Date和SimpleDateFormat类表示时间
Date类的主要作用就是获取当前时间
Date d = new Date();//使用默认的构造方法创建Date对象 使用默认的构造方法创建Date对象就代表当前的时间
当获取到当前时间后，可以用SimpleDateFormat来对日期时间进行格式化，可以将日期转换为指定个还是的文本，也可以将文本转换为日期。
举例：
（1）使用format()方法将日期转换为指定格式的文本
//创建Date对象，表示当前时间
Date d = new Date();
//创建SimpleDateFormat对象，指定目标格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//调用format()方法，格式化时间，转换为指定格式字符串
String today = sdf.format(d);
（2）使用parse()方法将文本转换为日期
//创建日期格式的字符串
String day = "2018年8月29日 09:24:54";
//创建SimpleDateFormat对象，指定字符串的日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//调用parse()方法，将字符串转换为日期
Date date = df.parse(day); 调用SImpleDateFormat对象parse()方法时可能会出现转换异常，即ParseException，因此需要进行异常处理
7、Calendar类——对日期和时间的处理
Calendar类是一个抽象类，可以通过调用getInStance()静态方法获取一个Calendar对象，此对象已由当前日期时间初始化，即默认代表当前时间，如Calendar c = Calendar.getInstance();
举例：
Calendar c = Calendar.getInstance();//创建Calendar对象
int year = c.get(Calendar.YEAR);//获取年
int month = c.get(Calendar.MONTH) + 1;//获取月份，0表示1月
int day = c.get(Calendar.DAY_OF_MONTH);//获取日期
int hour = c.get(Calendar.HOUR_OF_DAY);//获取小时
int minute = c.get(Calendar.MINUTE);//获取分钟
int second = c.get(Calendar.SECOND);//获取秒
Calendar类提供了getTime()方法，用来获取Date对象，完成Calendar和Date的转换，还可以通过getTimeInMillis()方法，获取此Calendar的时间值，以毫秒为单位。
Date date = c.getTime();//将Calendar对象转换为Date对象
Long time = c.getTimeInMillis();//获取当前毫秒数8、使用Math类操作数据
用于执行基本数学运算的方法，Math类的所有方法都是静态方法。
| 返回值 | 方法名 | 解释 |
|---|---|---|
| long | round() | 返回四舍五入后的整数 |
| double | floor() | 返回小于参数的最大整数 |
| double | ceil() | 返回大于参数的最小整数 |
| double | random | 返回[0,1)之间的随机数浮点数 |
十五、集合框架
1、集合的概念：
现实生活中：很多具有相同属性的事物凑在一起
数学中的集合：具有共同属性的事物的总体
Java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象
2、集合的作用
在类的内部，对数据进行组织
简单而快速的搜索大数量的条目
有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素
有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型
3、数组、集合的区别
数组的长度固定，集合长度可变
数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象
4、Java集合框架体系结构
由Collection和Map组成，Collection和Map是集合框架中的两个根接口
Collection有三个子接口：
List（序列）和Queue（队列）：它们存储的元素是排列有序的，可以重复的
Set（集）：存储的元素是无序的，不可重复的
List——>ArrayList（数组序列）
Queue——>LinkedList（链表，也是List接口的一个实现类）
Set——>HashSet（哈希集）
Map——>HashMap（哈希表）：以<key,value>映射去存储数据，就是Entry类（键值对，Map的内部类）的实例
Collection接口、子接口以及实现类
Collection接口：
1）是List、Set和Queue的父接口
2）定义了可用于操作List、Set和Queue的方法——增删改查
List接口及其实现类——ArrayList
List是元素有序并且可以重复的集合，被称为序列
List可以精确的控制每个元素的插入位置，或删除某个位置元素
ArrayList——数组序列，是List的一个重要实现类
ArrayList底层是由数组来实现的
泛型
（1）集合中的元素，可以是任意类型的对象（对象的引用）
如果把某个对象放入集合，则会忽略他的类型，把他当做Object处理
（2）泛型则是规定了某个集合只可以存放特定类型的对象
会在编译期间进行检查
可以直接按指定类型获取集合元素
（3）在泛型集合中，可以存放泛型类型的对象实例，还可以存放泛型的子类型的对象实例
（4）泛型集合中的限定类型不能使用基本数据类型。可以通过使用包装类限定允许存入的基 本数据类型。
int——Integer
long——Long
boolean——Boolean
Set接口及其实现类——HashSet
1）Set是元素无序并且不可以重复的集合，被称为集
2）HashSet——哈希集，是Set的一个重要实现类
（2）Map和HashMap
Map接口
1）Map提供了一种映射关系，其中的元素是以键值对（Key–Value）的形式存储的，能够实现根据key快速查找value，key和value可以是任意类型的对象。
2）Map中的键值对以Entry类型的对象实例形式存在的
3）键（key值）不可重复，value值可以
4）每个键最多只能映射一个值
5）Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
6）Map支持泛型，形式如：Map<K, V>
HashMap类
1）HashMap是Map的一个重要实现类，，也是最常用的，基于哈希表实现
2）HashMap中Entry对象是无序排列的
3）Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）
a>Collection和Set方法中都含有contains方法
（3）Collections工具类
是Java集合框架中，用来操作集合对象的工具类，也是Java集合框架的成员。
sort()（排序）方法
（4）Comparable接口——可比较的（默认比较规则）
1）实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
2）定义了默认的比较规则
3）其实现类需实现comparaTo()方法
4）comparaTo()方法返回整数表示大，负数表示小，0表示相等。
Comparator接口——比较工具接口（临时比较规则）
1）用于定义临时比较规则，而不是默认比较规则
2）其实现类需要实现compara()方法
3）Comparator和Comparable都是Java集合框架的成员