java语言特性：
1、简单易用
2、面向对象
3、安全性高
4、多线程
5、跨平台
JVM java虚拟机
在不同系统（Mac，Windows等）上必须安装jvm和核心类库，才可以运行java程序。。。
JRE = JVM+核心类库 即 java运行环境。。。
JDK java开发工具包。jdk中包含了jre。
所以java开发时，只需要下载jdk安装即可。。。
面向对象特性：
封装
继承
多态 ：不同子类实现的差异。
访问修饰符
基本数据类型及其包装类。
通常基本数据类型在方法中使用 因为基本数据在栈中
包装类在属性字段中使用。。在堆中
抽象类和抽象方法的产生：父类不知道如何实现的方法，由子类来实现。。。使用abstract来修饰
因此，子类必须覆盖抽象方法。。。因此不能使用private，final，static 来修饰。。。
抽象类不能直接用来创建对象。只能由其子类实例化。。。
抽象类里可以有非抽象方法。。。。。
接口：是一个特殊的抽象类。。。
1、接口没有构造器，接口不能创建对象
2、接口中定义变量，都是全局的静态变量。
3、接口中定义的方法，都是公共的（public）抽象方法。
4、类中实现接口的方法时，必须用public来修饰
5、接口可以继承接口，可以继承多个接口
接口和抽象类的区别：
相同点：1、都是被继承或者被实现
2、都不能实例化
3、都可以定义抽象方法，抽象方法必须被覆盖
不同点：1、接口没有构造器，抽象类是有构造器的。
2、抽象类可以包含普通方法和抽象方法，接口只能有抽象方法
3、接口当中默认成员变量，public static final 变量；抽象类中为默认
4、方法：接口当中默认方法 public abstract 方法名； 抽象类中为默认
内部类：定义在类中的类
为什么要使用内部类
1、增强封装，把内部类隐藏在外部类中，
不允许其他类访问这个内部类。
2、增加了代码维护性
3、内部类可以直接访问外部类当中的成员。
内部类分类：
1、实例内部类：直接定义在类中的类，前面没有任何修饰符
2、静态内部类：在类中定义一个static 类
3、局部内部类：定义在方法中的类
4、匿名内部类：属于局部内部类的特殊情况
实例内部类：
class Outter{
String name;
class Inner{
}
}
静态内部类：可以定义静态成员和非静态成员
class Outter{
String name; 静态内部类里面无法直接访问，可以通过new Outter().name来访问
static String address; 静态内部类里面可以直接访问
static class Inner{
}
}
局部内部类：定义在类中方法中的类
1、不能使用一些修饰，如public、private。。。
2、局部内部类只能在定义的方法中使用
3、局部内部类当中不能包含静态变量
4、局部类中可以包含局部变量,使用局部变量的本质是final
class Outter{
void test(){
String name = "dd"; //jdk1.8可以省略final
class Inner{
void test(){
这里可以使用name
}
}
}
}
匿名内部类
就是一个没有名字的的局部内部类
且没有构造器，只使用一次
使用 new 父类构造器或者 inteface(){...}
interface ToDo{
public void toDo();
}
class Outter{
void setIn(ToDo todo){
//to do what you want
}
}
class Inner implements Todo{
public void my(){...}
}
public class Test{
public static void main(String[] args){
Outter out = new Outter();
out.setIn(new Inner(){
public void my(){....}
});
}
}
浮点型（小数）
float double 表示小数，不能表示精确的值。
double d = 0.01+0.09; //正常来说结果为0.1,但是实际为0.0999999...
因此引出了BigDecimal类
字符串：
字符串比较
String str = "abc";
String str2 = new String("abc");
比较内存地址是否相同。
if (str == str2) {
System.out.println("相等");
} else {
System.out.println("不相等"); //输出
}
字符串的比较。。。比较字符是否相等。。。
if (str.equals(str2)) {
System.out.println("相等"); //输出
} else {
System.out.println("不想等");
}
字符串拼接速度
StringBuilder 效率最高
StringBuffer 由于加锁了，速度稍慢，synchronized
基本不推荐使用String的拼接方法
集合接口及其实现类
* 数组：长度固定，不能再去添加元素
* 数组能存基本数据类型，引用类型
*
* 集合： 就是用来存放数据的一个容器
* 长度可以改变
* 只能存储对象(基本数据类型，系统自动装箱为对象)
* Collection接口
*
* List 有序接口 Set 无序接口
*
* 实现类：ArrayList,LinkedList,Vector 实现类：HashSet,TreeSet
*
* * List 当中是可以添加重复元素的，返回值永远是true
* * set 当中是不可以添加重复元素的，返回值可以是false和true
*
//c1.removeAll(c2); 移除交集
//c1.containAll(c2); 判断c1中是否包含了c2中的所有元素
//c1.retainAll(c2); //取交集 把交集赋值给c1； 如果c1没有改变，返回false，改变返回true
ArrayList 是怎么改变？
把原有数组中元素复制出来，重新创建一个数组（容量扩充50%），放入元素
* LinkedList 查询比较慢，但是增减较快，链表结构。
*
* addFirst(); 在第一个位置添加元素
*
* addLast();在最后面添加元素
*
* removeFirst(); 移除第一个元素
*
* removeLast(); 移除最后一个元素
Vector 1.2 之后实现了list接口。和ArrayList差别：
Vector 带有同步锁；ArrayList没有。
set 比较元素是否相同
先比较 hashCode(), 然后比较compareTo方法。
因此比较自定义对象时，需要覆盖上面两个方法
HashSet 能够保证元素的唯一。
LinkedHashSet 时HashSet子类，内部时链表结构，怎么存怎么出
treeSet 二叉树算法
会对添加的元素进行排序，也保证元素唯一。
因此，元素类型必须是同一类型。
存储自定义对象时，该对象必须实现Comparable接口并覆盖下面的方法
/*
* return 0 只添加一个元素
* return >0 所有元素正序显示
* return <0 所有倒序显示
*/
@Override
public int compareTo(Person o) {
return 1;
}
add 对象时，会和已经存在的对象依次比较。
该方法返回值 为0 时 表示相等
该方法返回值 为>0时， 表示大于之前的对象
该方法返回值 为<0时， 表示小于之前的对象
自定义比较器
class CompareLength extends Object implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
int num = o1.length() - o2.length();
if (num==0) {
return o1.compareTo(o2);
}
return num;
}
}
//自定比较器
TreeSet<String> set6 = new TreeSet<String>(new CompareLength());
set6.add("a");
set6.add("ab");
set6.add("bafdc");
set6.add("cbca");
set6.add("bda");
set6.add("cb");
System.out.println(set6);
Map
简单理解 是键值对，且无序。
在key集合中的每一个元素，在value集合中都有唯一的一个元素与之对应。
key 集合中元素不能有重复的，value集合中可以。
Map<String, Object> map = new HashMap<>();
Object obj1 = map.put("zhangsan1", 10);
Object obj2 = map.put("zhangsan2", 20);
Object obj3 = map.put("zhangsan3", 30);
System.out.println(map);
System.out.println(obj1); //返回值为null，代表第一次添加该key
System.out.println(obj2);
System.out.println(obj3);
System.out.println("--------------------------------");
//添加的key之前已经存在，就把以前的值替换为新值，旧值作为返回。
Object obj4 = map.put("zhangsan3", 40);
System.out.println(map);
System.out.println(obj4); //输出为30
map如何遍历元素？
法一：取出key集合通过遍历key，取出value来遍历。
法二：取出 entry 集合 来遍历
Set<Entry<String, Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry.getKey()+"="+entry.getValue());
}
HashMap 中自定义元素，通过比较属性值判断是否相等，需要覆盖hashCode 和compareTo方法。
LinkedHashMap 添加的元素是 有序的。
treeMap 会对key集合进行排序。自定义对象实现Comparable接口及其方法。
HashMap 和 HashTable 区别？
共同点： 底层都是哈希算法，都是双列集合
区别：HashMap 线程不安全，效率较高 1.2版本才有；HashTable 线程安全的，效率不高 1.0之前就有。
HashMap可以存储null，HashTable不可以
异常Exception
JVM 是怎么处理异常？ 将异常名称和出现位置输出到控制台，并终止程序执行。
