异常处理

try{

//一些会抛出异常的方法

}catch(Exception e){

//处理该异常的代码块---先子类后父类 从小到大

}finally{

//最终将要执行的一些代码

}

调用类记得加（）

和字符直接比较 加'' 或“”

14.异常

* 异常的作用：增强程序的健壮性

* 异常在java中以类和对象的形式存在

* java异常处理的两种方式：

* 1.在方法声明的位置上，使用throws关键字

* 2.使用try catch 语句进行异常的捕捉

* 异常的两个方法：

* 1.getMessage（获取异常简单的描述信息）

* 2.printStackTrace(打印异常追踪的堆栈信息)

* finally是一定运行的除了你退出jvm退出jvm代码 System.exit(0）;

* throw 关键字是手动抛出异常

**15.集合

* 集合实际上就是一个容器，也是一个载体，可以容纳其他的类型数据

* 集合是中不能存基本数据类型，也不能存对象，它存的是对象的地址

* 集合在java中本身是一个容器，是一个对象，是一个引用

* 集合分为两大类：

* 1.一类是单个方式存储元素

* java.util.Collection

* 2.一类是以键值对的方式存储元素

* java.util.Map

* list集合：有序，可重复，先进先出：

* 1.ArrayList集合(底层采用数组这种数据结构)

* ArrayList集合是非线程安全的

* 2.LinkedList集合(底层采用双向链表数据结构)

* 3.Vector集合(底层采用数组数据结构)

* Vector集合是线程安全的

* set集合：无序，不可重复：

* 1.HashSet(HashSet集合在new的时候底层实际上new的是HashMap集合)：

* 向HashSet集合中存储数据其实是存储到HashMap集合中，Hashmap

  集合是一个哈希表数据结构

* hashset初始化容量是16，加载因子是0.75，初始化容量建议

  是2的倍数，扩容之后是原容量2倍

* 2.set集合的子类接口（SortedSet）中的TreeSet集合

* SortedSet存储元素的特点：

由于继承了Set集合，所以它的特点也是无序不可重复

但是它里面的元素会自动排序，所以称为可排序集合

* TreeSet是二叉树数据结构，它的底层实际上是TreeMap集合

* Map集合：（所有的Map集合都是无序不可重复的）

* HashMap集合数据结构是哈希表，是非线程安全的

* Hashtable集合是线程安全的，底层也是哈希表数据结构，其中所有方法

  都带有synchronized关键字

Hashtable的子类Properties集合是线程安全的，它的key和value

都是只支持String类型的，Properties被称为属性类

* SortedMap集合的特点：

无序不可重复的，放在这里面的集合key部分都是按照大小顺序

排序的，称为可排序集合

* 它的子类TreeMap集合底层存储元素的数据结构是一个二叉树

* 链表的数据结构

* 1.基本的单元是节点Node

* 2.对于单向链表来说，任何一个节点Node中都有两个属性

* 1.存储的数据 2.下一节点的内存地址

* 单向链表的优缺点：

* 优点：随机增删元素效率较高，因为元素不涉及到大量的元素位移

* 缺点：查询效率较低，每一次查找某个元素的时候都需从头节点

开始往下遍历

* 泛型

* 使用泛型指定集合中存储的数据类型，指定什么类型就只能存什么类型

* 使用泛型的好处：

* 1.集合中的数据类型统一了

* 2.从集合中取出的元素类型都是泛型指定的类型，不需要

    大量的向下转型

* 泛型的缺点：

* 1.导致集合中的存储元素缺乏多样性

* HashSet集合（无序不可重复）

* Map和Collection没有继承关系

* Map集合以key和value的方式存储数据：即键值对

* key和value都是引用数据类型

* key和value都是存储对象的内存地址

* key起到主导的地位，value是key的一个附属品

* 哈希表数据结构/散列表数据结构

* 哈希表是一个数组和单向链表的结合体

  数组：查询效率高，随机增删效率低

  单向链表：随机增删效率高，在查询方面较低

  哈希表是将两种数据结构融合在一起，充分发挥他们各自的特点

* 为什么哈希表的随机增删和查询都高：

* 因为增删是在链表中完成

* 查询也不需要都扫描，只需要部分扫描

* 其实它实际没有纯数组查询效率高也没有纯链表增删效率高

  但是它综合了这两项的特点

* hashmap的集合key，会先调用两个方法：

* 1.hashCode()方法

* 2.equals()方法 注：这两个方法都需要重写

* 注：hashmap集合的初始容量为16，默认因子是0.75，就是说

      当hashmap底层容量达到75%的时候开始扩容。

  注：hashmap初始化的容量必须为2的倍数，这是为了达到散列均

      为了提高hashmap集合的存取效率。

* mp.put(K, V)的实现原理：

* 1.先将K,V封装到Node对象中

* 2.底层调用k的hashCode()方法得出hash值，然后通过哈希函数

    （哈希算法），将hash值转换成数组的下标，下标位置上如果

    没有任何元素，就把Node添加到在这个位置上了，如果说下标

    对应的位置上有链表，此时会拿着k和链表中的k进行equals，

    如果所有的equals方法返回都是false，那么这个新节点将被

    添加到链表的末尾，如果其中有一个equals返回了true，那么

    这个节点的value值将会被覆盖。

* 注：同一个单向链表上所有的节点都是一样的，因为他们的数组

      下标都是一样的。但是同一个链表上k和k的equals方法返回

      的是false，都不相同。

* mp.get(k)的实现原理：

* 先调用k的hashCode()方法得出哈希值，通过哈希算法转化成

  数组下标，通过数组下标快速定位到某个位置上，如果这个位

  置上什么都没有，返回null，如果这个位置上有单向链表，那

  么会拿着参数k和单向链表上的每个节点中的k进行equals，如

  果所有equals都返回false，那么get方法返回null，只要其中

  有一个节点的k和参数kequals返回true，那么此时这个节点的

  value就是我们要找的value，get方法最终返回这个要的value

* 放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写

  hashcode方法和equals方法。

* 在jdk8之后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成

  红黑树数据结构，放红黑树上的节点数量小于6时，会重新把红黑树变成单向链表

  数据结构。

* HashMap集合key和value允许null，但是只允许存在一个null，在写就会覆盖

  * HashTable集合的key和value都不允许为null

* HashTable集合（底层也是哈希表数据结构）：

* hashtable默认初始化容量为11，默认加载因子是0.75，它的扩容是

  原容量的2倍加1

* TreeSet集合

* TreeSet集合底层其实是一个TreeMap，TreeMap底层是一个二叉树

* 放到TreeSet集合中元素，等同于放到TreeMap集合的key部分

* TreeSet集合的元素：无序不可重复，但是可以按照元素的大小自定排序

  称为可排序集合

* 自平衡二叉树：

* 1.遵守左小右大的原则存放

* 2.遍历二叉树的三种方式：

* 1.前序遍历：根左右

* 2.中序遍历：左根右

* 3.后序遍历：左右根

* 注：前中后说的是根的位置，跟在前面时前序，在中间是中序

      在后面是后序。

* 3.treeset集合采用的是中序遍历方式（iterator迭代器）左右根

*10.数组：

    1. java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是object

    2. 数组是一个数据的集合，也就是一个容器，可以同时容纳多个元素

    3. 数组当中可以存储基本数据类型，也可以存储引用类型

    4. 因为数组是引用数据类型，所以它存放在堆内存里

    5. 数组当中如果存储的是java对象的话，实际上存储的对象的引用（内存地址）

    6. 数组一旦创建，在java中规定，长度不可变

    7. 数组的分类：一维数组，二维数组，三维数组，多维数组

    8. 数组都有length属性，用来获取数组中元素的个数

    9. java中的数组要求数组中元素的类型统一，比如int类型只存int类型

    10.数组的内存方面存储的时候，数组中的元素内存地址是连续的，数组实际上是一种

       简单的数据结构。

    11.数组都是拿第一个小方框的内存地址作为整个数组对象的内存地址

    12.数组的优点缺点：

       优点：查找某个下标上的元素时效率高

          为什么检索效率高？

              1. 每个元素的内存地址在空间存储上是连续的

              2. 每一个元素类型相同，所以占空间大小一样

              3. 知道第一个元素的内存地址，知道每一个元素占空间大小，又知道下标

                 所以通过一个数学表达式就可以算出某个下标元素的内存地址，再通过

                  内存地址定位元素

      缺点：1.由于为了保证数组中每个元素的内存地址连续性，所以在数组上随机删除或者

             增加元素的时候，效率低，因为随机增删元素会涉及到后面元素统一向前或者

             向后位移的操作（数组中最后一个元素的增删是没什么影响的）

           2.数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存

             空间

    13. 定义一个一位数组

           语法格式：int[] array1;

    14. 初始化一个一位数组

           包括两种方法：静态 初始化， 动态 初始化

           静态格式：int[] array = {100, 200, 300};

           动态格式：int[] array = new int[5];这里的5表示数组的个数，默认值为0

11.抽象类

* 抽象类定义的格式

【修饰符列表】 abstract class 类名{}

* 抽象类不能创建对象，不能实例化对象，所以它可以用来给子类继承

* final不能和abstract同时使用

* 抽象类的子类可以是抽象类  

* 抽象类虽然不能实例化，但是可以有构造方法，这个构造方法是供子类使用的

* 抽象类中有抽象方法也可以有非抽象方法，抽象方法特点：

* 1.抽象方法，没有方法体，以分号结尾

* 2.前面修饰符列表中有abstract关键字

* 父类中有抽象方法，抽象方法只能在抽象类中，所以子类也必须定义为抽象的类

  或者子类重写父类的方法，将其改为非抽象方法

12.接口

* 接口是一个数据引用类型

* 接口是完全抽象的，（抽象类是半抽象的）也可以说接口是特殊的抽象类

* 接口定义：

* 【修饰符列表】 interface 接口名{}

* 接口可以多继承

* 接口中只包含两部分内容：常量和抽象方法

* 因为接口里面都是抽象方法，所以可以省略public abstract

* 因为接口里面都是常量，所以可以省略public static final

** is a和like a以及has a的说明：

   * is a：

cat is a Animal(猫是一个动物)

  凡是能满足is a 的表示“继承关系”

  例子：A 继承 B

   * like a：

cooker like a FoodMenu(厨师 像一个菜单一样)

  凡是能满足like a的关系的表示“实现关系”

  实现关系通常是类实现接口

  列子：A 实现 B

   * has a：

I has a pen(我有一支笔)

    凡是能满足 has a关系的表示“关联关系”

    关联关系通常以“属性”的形式存在

    列子：A 里面有 B

13.接口类和抽象类的语法区别

* 接口类是完全抽象，抽象类是半抽象，

* 抽象类中有构造方法，接口类中没有

* 接口和接口之间支持多继承，类和类之间只能单继承

* 一个类可以同时实现多个接口，一个抽象类只能继承一个类

* 接口中只能有抽象方法，而抽象类里可以有方法体方法

第三章 面向对象

1.面向对象的三大特征：

* 封装

* 继承

* 多态

2.定义一个类

* 一个类一般由属性和方法组成

* 属性一般表示状态（属性一般为变量）：

因为定义在类体中，所以也叫做成员变量；

这个属性不能直接通过类去访问，所以这个也叫做实例变量

访问这个变量要创建对象，通过对象去访问这个信息；

对象又被称为实例，所以也叫做对象变量【对象级别的变量】

* 方法一般表示动作（）

3.面向对象之封装

  封装的步骤：

  1.使用关键字private进行修饰

2.对外提供简单的入口，也就是说以后外部想要访问age属性，

  必须通过简单的入口进行访问：

-对外提供两种方法 get和set方法

-set方法的命名规范：

public void setAge（int a）{

this.age = a;

}

-get方法命名规范：

public int getAge（）{

return age;

}

-set用于修改 get用于读取

4.构造方法

构造方法的作用：

* 创建对象

* 创建对象的同时，初始化实例变量的内存空间

5.this关键字

* this是一个引用，是一个变量，this变量中保存了内存地址指向自身，this

  储存在jvm堆内存java对象内部。

* 创建一百个对象就有一百个this关键字，也就是说有一百个不同的this

* this可以是现在实例方法中，this代表当前对象

* this不能出现在带有static的方法中

# 带static方法的可以直接new对象然后去访问实例变量

# 不带static的方法叫实例方法，需要先new对象才能去调用该方法

* this大部分都可以省略不写

# 用来区分局部变量和实例变量的时候，不能省略！

* this可以用来调用其他构造方法(但是这个this(1999,1,2)只能出现在第一行)

例：this(根据别的构造方法的传参数据类型以及个数）

例：this(1999,1,2)

6.static关键字

* 加static关键字的方法和变量称为静态方法和静态变量

* 可以用static关键字来定义静态代码块

# 静态代码块在类加载时执行，并且只执行一次

# 静态代码块在一个类中可以定义多个

7.总结

* class 类{

静态代码 块

实例代码块

静态变量

实例变量

构造方法

静态方法

实例方法

}

*8.继承

方法覆盖：

1. 方法的覆盖又被称为方法的重写（override）

  2. 什么时候方法要重写

  ——当父类的方法不能满足子类的时候，

  3. 什么条件满足之后方法会发生重写

  ——返回值类型，方法名，形参列表相同的时候（就是父类方法是什么他就是什么）

  4.私有属性不能继承所以不能覆盖

      构造方法不能继承所以不能覆盖

      静态方法不存在继承所以不能覆盖

      覆盖只针对方法，不谈属性。 

第一章：

1.public class 和 class的区别

1.一个java源文件当中可以定义多个class

2.一个java源文件中不一定要有public class

3.其中一个class会生成一个对应的xxx.class字节文件

4.一个java源文件当中定义公开的类的话，名字需和文件名保持一致

5.每一个class中都可以编写main方法，都可以设定程序入口

第二章：java语言基础

1.数据类型：

* 基本数据类型(四大类八小种）

1.整数型

  byte （字节型，占1字节，取值范围为-128~127）

  short（短整形，占2字节，取值范围为-32768~32767）

  int  （整形，  占4字节，取值范围为-2147483648~2147483647）

  long （长整形，占8字节，取值范围为-2^63~2^63-1）

2.浮点型

  float（单精度浮点型）,double（双精度浮点型）

3.布尔型

  boolean（布尔型）

4.字符型(*字符串不属于数据类型，它属于引用数据类型）

  char   （字符型）

* Java 中使用 final 关键字来修饰常量，声明方式和变量类似

* 当使用字面量的时候前缀0表示8进制，而前缀0x代表16进制,例如：

int decimal = 100;

int octal = 0144;

int hexa =  0x64;

* 转义字符：(\在java中具有转义功能）

1.\n--表示换行符，属于char类型

2.\t--表示制表符tab，属于char类型

……

2.数据类型的类型转换

* 例：short i = 10; short j = 5; int k = i + j;

* 例：short k = i + j;报错！因为编译期不会运算，而i,j为int类型

* 例：short k = （short）（i + j）；正确，因为加括号可以增加优先级

* 如果定义是short或者其它比int小的数据类型就会报错，因为在java里，

  i跟j是默认为int类型，只要你定义的值没有大过你定义的类型，大不能转小

3.运算符

* 例：int i = 10;int j = i++;j等于10；但是此时j已经是11了

因为java里当++在值后面是先赋值再++；

* 例：int i = 10；int j = ++i;j等于11；

因为java里当++在值前面时，是先++再赋值

4.逻辑运算符（短路与&&和短路或||）

* int a = 10; int b = 5;(a<b && ++a<b)

这时a等于10；因为在短路与里面，前面为false，后面则不会计算

但是在逻辑与里面会在计算！

* int a = 10; int b = 5;(a<b || ++a<b)

这时a等于11，因为在短路或里面，前面为false，后面还是会计算

如果前面为真时，后面则不会计算了，即等于10；但是在逻辑或里面

就算前面为真，后面还是会计算！

5.for循环的原理

* for(int i = 1;i <= 10; i++){

System.out.println()；

······等等java语句

* 其中int i = 1；为初始表达式，只运行一次。

* i <= 10；为布尔判断，

* i++；为更新表达式

* System.out.println（）为java语句；

* 运行原理为先运行初始表达式且只运行一次，然后进行布尔判断，

   如果为真，则运行java语句，再运行更新表达式，最后再去判断

   布尔是否为真，为真则又进行java语句，再运行更新表达式，反

   复到布尔为假时，结束for循环。

}

每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法

11111111

Comparable接口——可比较的

实现该接口表示：这个类的实例可以比较大小，可以进行自然排序；

定意了默认的比较规则；

其实现类需要实现compareTo()方法；

compareYTo()方法返回正数表示大，复数表示小，0表示二者相等。

Comparator接口——比较工具接口

用于定义临时比较规则，而不是默认比较规则；

其实现类需要实现compare()方法；

Comparator和Comparable都是Java集合框架的成员。 

StringBuilder创建对象，对字符串的值进行修改和其他操作并不会修改对象

基本类型是不能调用方法的，而其包装类具有很多方法

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位

2.推荐使用 Calendar 类进行时间和日期的处理。

1.Date 类最主要的作用就是获得当前时间

1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理

2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包