*****************************基础************************************
1.java是高级的编译语言，继承了c,c++优点，c的高效性，c++面向对象特性。
2.jvm --> 5部件：字节码指令集，寄存器，stack，heap，方法域
内存分配：堆64M 栈64M 方法域64M
3.六大存储区域：
堆：对象、临时变量
栈：知道生命周期的变量
静态存储区域：静态变量、静态块、静态方法
常量存储区域：常量、final修饰的东西
非RAM存储：硬盘
流存储：管道存储
4.对象：描述一个事物，可以是具体的，可以是抽象的。
5.属性：指的是对象的特点。
6.方法：指的是对象的功能。
7.类：是创建对象的模板。类有普通类、抽象类、内部类、匿名类。
类被编译时内部接口都会被加上static修饰符。
8.全局变量：全局范围可以用
9.局部变量：局部范围可以用
10.方法：修饰符+返回值+方法名字+参数列表+方法体
11.方法重载：名字相同，参数列表不同
12.八种基本数据类型：short int long float double char byte boolean
短整型，整型，长整型，单精度，双精度，字符型，字节，布尔
13.程序控制语句：if,if else,for,while,do while;,while do,switch
14.数组：3种定义方法：
String[] str = new String[10];定义不初始化
String[] str = {"dd","ss",aa};定义并初始化
String[] str = new String[]{"dd","ss","aa"};定义并初始化
15.二维数组
16.this：指向本类
17.final：定义类这不能被继承，定义方法则不能被重写，定义变量则不能第二次赋值，不能用来修饰构造方法。
18.static：修饰变量、方法。修饰变量时只能修饰全局变量。使得数据等到共享。在同一个类里调用静态方法不用实例化对象。调用别的类的静态方法或者变量时需要在静态方法、变量前面加上类的索引，这样jvm才知道加载那个类的静态方法和变量。
原理：在jvm加载类的时候同时加载静态关键字修饰的（方法、变量、块）到内存的静态存储区域。
19.单例模式：当这个对象经常给使用的时候，为了节省资源开销把对象进行共享和控制。
1.私有静态对象变量（共享一个对象）
2.静态的对象类型方法（提供对象的实例）
3.私有化构造器（防止别的类来创建对象）
20.构造器：名字和类名相同，没有返回返回值的方法。用于初始化操作。当一个类不写构造方法时候，jvm会自动调用本类的无参构造方法，如果写了构造方法则jvm只是调用写的构造方法。
21.jvm加载顺序
简写 详细
1.分配内存空间 1.分配内存空间
2.初始化变量 2.初始化静态变量
3.构造器 3.加载静态块
4.引用变量赋值 4.加载静态方法(在静态块里被调用的会先加载)
5. 5.初始化普通变量
6. 6.加载构造块
7. 7.加载构造器
8. 8.加载普通方法(在构造块里被调用的会先加载)
9. 9.其他成员
(编译时，构造块内容被嵌入到所有构造方法内部开头，即是构造块先于构造方法。)
在同一进程里面静态的东西可以共享的。需要使用静态东西的时候如果还没有加载则加载，如果已经被加载过了则直接跳过而加载下一项。
*****************************面向对象************************************
1、封装(不写修饰符就是default权限)
原理：基于操作系统文件目录存储结构。
作用：代码重用、方便管理、更新、维护、拓展、权限控制。
作用：public和default可以修饰类、接口。
作用：这四个修饰符可以修饰全局变量，不可以修饰局部变量（除了default）。
作用：这四个修饰符可以修饰类普通的方法。
作用：public、protected、default才能修饰抽象方法。因为抽象方法在抽象类里面，被继承了就要重写，而私有不能被访问，所以矛盾，所以private不可以修饰。
作用：public、default才能修饰接口的方法。（规定的）不管怎么样编译接口后都是接口里面的方法都是public、abstract修饰的。
------------------------------------------------------------------------
作用域 当前类 同一包内 子孙类 其他包
------------------------------------------------------------------------
public √ √ √ √
------------------------------------------------------------------------
protected √ √ √ ×
------------------------------------------------------------------------
default √ √ × ×
------------------------------------------------------------------------
private √ × × ×
------------------------------------------------------------------------
2、继承：是对象之间的层次关系（父类、子类）。需要用到extends关键字。一个类只能有一个父类。
继承的作用：是子类可以直接调用父类的方法，可以重写拓展父类的方法属性。 方法的重写：子类和父类的方法相同（名字、参数列表和返回类型都相同、是否有static修饰也一样）子类的权限不能比父类的小，抛出异常不能比父类大
3、super关键字：是指父类。"super()"语句（即是父类构造函数）必须是子类的构造函数中的第一个执行语句。super可以调用父类的方法和使用父类属性（如super.方法、super.属性）。super()总是引用子类最接近的超类的构造函数。
4、多态：是面向对象的一个特征，可以说是变化多端的。
多态形式1：父类对象指向子类的引用（Father f = new Child()这样是自动向上自动转型的）作用：范围得到拓展。
多态形式2：子类对象指向父类的引用（Child c = (Child)f这样是强制向下转型的，需要知道是子类对象才强制转型，要不然就抛出异常。通常用instanceof判断某对象是否是某对象的实例，如：boolean b = f instanceof Child）
5、abstract：由abstract修饰的 类是抽象类。抽象类是具有特殊性和普遍性的。
抽象类不能实例化，抽象类可以有普通的方法可以有抽象方法。
抽象方法只能存在抽象类里面。
抽象类的抽象方法必须由子类去重写。
抽象类的普通方法一般认为是共公用的。
6、interface：接口与类不一样。接口里面默认是抽象方法而且只能有抽象方法。
接口被编译时候会自动加上abstract关键字。所以接口也不能被final修饰。
（abstract和final是非法组合，abstract和private是非法组合）
（对于方法而言abstract和static是非法组合）
接口被编译时里面的属性会被加上public、static、final修饰符，所以必须给它赋初始值。
接口被编译时里面的抽象方法会被加上public、abstract修饰符。
接口被编译时里面的成员内部类和成员内部接口都会被加上public、static修饰符。
接口作用是：定义规则。让不同厂商去实现它。
接口不能被实例化。不能被final关键字修饰。接口可以多继承接口,不能继承类。
7、implements：是类用来实现接口的。类可以实现多个接口。实现就是重写接口里面的方法，而且重写后的方法要用public来修饰。（因为接口在编译时自动加上了abstract修饰符,变量被加上public static final修饰符号，方法被加上public abstract修饰符。所以实现接口方法时要写上public要不然访问不了。编译就不通过）
8、String池：本身含有了一些字符了。如果没有某字符串，才创建个字符串。这样一来就可以多个变量去引用某个字符串了。
9、“==”:变量是基本类型时候是做算术运算，变量是对象类型时候是比较地址（即是引用变量存放的对象的地址字符串）。
10、throw：表示要抛出异常，有可能抛出的异常。写在方法体里的最后一行。需要捕获。若没有捕获就要抛出。如果都没有捕获那么最终由jvm捕获。
11、throws：表示往上抛出异常。
12、try catch：可以捕抓异常同时按照我们想要的方法去处理。同时还可以让程序继续运行下去。如果想不管出不出异常都执行某些语句的话就用finally
try {
}catch (Exception) {
}finally {//最终会执行的语句
}
13、内部类：就是在一个类里面定义的一个类。而且可以嵌套。全局内部类是外部类的一个成员，对外部是封闭的。
在外部类调用内部类，必须要先获得内对象。
内部类不能有静态的声明。静态内部类才可以有静态声明。
在内部类可以调用外部类的属性、方法。
一般对于一个方法处理的事情很大的话，可以把该方法要实现的功能用内部类来代替处理。
作用：内部类可以存储更多、更复杂、功能更多。有利于类的拓展、代码重用。还可以实现类的多继承效果。
14、成员内部类和局部内部类
一、成员内部类：是全局内部类。
功能：内部类可以直接调用外部类的属性和方法。
功能：外部类可以直接创建内部类。如果不是内部类的直接外部类，需要通过外部类的实例来获得它的内部类的对象。
用途：把能共同描述一个小对象的东西放到一起组成成员内部类。(比喻：外部类是一级菜单的 话，那么成员内部类就是二级菜单)
二、局部内部类：只能在局部范围使用(包括实例化等其他操作)。
15、静态内部类：内部类里面不能有static静态的声明,所以内部类里面不能有接口，静态内部类除外。
16、匿名内部类：是继承了指定类型的对象（已经存在的类型）。在一个类的里面运行。
作用：用于某些特殊情况，临时需要。
17、Error和Exception都继承了Throwable 。Error是指编译时的错误，Exception是指运行时的异常。
异常是可以捕抓的。所有运行时异常(RuntimeException)可以捕获也可以不捕获。
*****************************集合************************************
18、集合：Set接口用于存放不相同的记录。
19、迭代器：Iterator接口是迭代器，hasNext()用来判断是否有下一元素。next()是返回下一个元素。
20、键值对：Properties类用来存储有固定格式的数据。load(InputStream is)用来读取流中的(键和元素对)
getProperty(String key)用来获取key的值即元素。
21、Collection 是集合的接口，其中有常用的子接口List和Set
22、ArrayList是List的一个实现类。一般用来插队（底层是数组）
ArrayList实现了可变大小的数组。
23、LinkedList是List和Deque的一个实现类。一般用来排队（底层是栈）
LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
ArrayList和LinkedList都是非同步的。
24、泛型的写法 类型<类型> 用来指定类型。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
├Set
│ |-hashSet
│ |-TreeSet
├Deque
│├ArrayDeque
│├LinkedList 25、Collections类的sort(List<T> list)方法用来排序列表的元素的。要求列表的所有元素必须实现Comparable接口。重写compareTo(T o)方法。“T”可以与此对象进行比较的那些对象的类型
例如：
public int compareTo(Object obj){
User temp = (User)obj;
if(this.age>temp.age){
return 1;
}else if(this.age == temp.age){
return 0;
}else{
return -1;
}
}
Collection是最基本的集合接口，一个Collection代表一组Object。
List和Set是Collection的子接口。
26、Vector(向量)也是List的实现类。大小可以根据需要增大或缩小，默认容量是10，满了就变为原来的2倍 ,可以通过构造方法指定初始容量和增量。可以用iterator()方法返回迭代器，也可以用elements()返回枚举。Vector与ArrayList优点相似。另外不允许不同线程进行同时访问。
27、Enumeration类可以装迭代枚举类型的类。一般和Vector类合用：Vector有elements()方法是返回枚举的。例如：
Enumeration e = v.elements();
//迭代枚举类型
while(e.hasMoreElements()){
//返回一个对象
Object obj = e.nextElement();
System.out.println("Elements is : "+obj);
}28、Stack是Vector子类。遵循先进后出原则.实现一个后进先出的堆栈。
29、Deque接口。支持在两端插入和移除元素的。ArrayDeque是Deque实现类。
30、Set接口。定义一个不包含重复元素的规则。添加时候是没有顺序的。HashSet是Set的实现类。有利于注册之类的程序。
31、List接口是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。
32、ListIterator接口和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。Iterator 一般与Collection的实现类使用。如：
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
33、HashSet是Set的实现类。可以存在不同的类型的元素。
34、TreeSet是Set的实现类。只能存在同一种类型的元素。添加时候会自动排序的。如果元素是对象类型，那么这个对象需要实现Comparable接口。Comparable接口有int compareTo(T o)方法。返回：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。如：
public int compareTo(Object o){
User u = (User)o;
if(this.age>u.age){
return 1;//整数
}else if(this.age==u.age){
return 0;//零
}else{
return -1;//负数
}
}
35、HashSet使用boolean add(E e)方法时候会调用int hashCode()方法，如果一样，再调用boolean equals(Object o)和同种类型的元素比较，如果返回true，才添加该元素。
36、Comparator接口。实现该接口可以自定义比较器。TreeSet和TreeMap有构造方法传入比较器的。 比较器例如:
//自定义比较器 。 接口 方便了 功能的拓展
class OrderByAccountComparator implements Comparator{
public int compare(Object obj,Object obj2){
Product p1 = (Product)obj;
Product p2 =(Product)obj2;
if(p1.getAccount() >p2.getAccount()){
return 1;
}else if(p1.getAccount() ==p2.getAccount()){
return 1;// 如果返回 0 就不能添加。
}else{
return -1;
}
}
}
37、Map接口:将键映射到值。一个映射不能包含重复的键，每个键最多只能映射到一个值。
常用方法： clear()清空，put(Object key,Object value),remove(Object key),get(Object key)
keySet()将键全部装进Set接口的实现类。map的遍历方法例如:
//map集合的遍历方法
public static void print(Map map){
Set keys = map.keySet();
Iterator it = keys.iterator();
while(it.hasNext()){
Object key =it.next();//因为key有可能是不同类型的
System.out.println("Key : "+key+" value : "+map.get(key));//遍历Map
}
}
38、HashMap是Map的实现类。允许“null”键和“null”值。可以存放不同类型的键。使用boolean put(K k,V value)方法时候会调用int hashCode()方法，如果一样，再调用boolean quals(Object o)和同种类型的键比较，如果返回true，才添加该键值对。
39、TreeMap是Map的实现类。只能存放同一种类型的键。这个类有个构造函数，需要自定义比较器(用于键的比较器)。
40、Properties类是HashTable（实现了Map接口）的子类。常用方法有：
String getProperty(String key)
Object setProperty(String key, String value)
void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
void loadFromXML(InputStream in) 将指定输入流中由 XML 文档所表示的所有属性加载到此属性表中。
void store(OutputStream out, String comments) 保存键值对到文件
void storeToXML(OutputStream os, String comment)保存键值对到xml文件
*****************************IO************************************
41、File类 文件和目录路径名的抽象表示形式。
createNewFile()创建一个文件，如果已存在就不创建。
deletet()删除此抽象路径名表示的文件或目录。如果此路径名表示一个目录，则该目录必须为空才能删除。
mkdir()创建指定路径名的目录。如果找不到路径也会返回false。
mkdirs()创建指定路径名的目录。会补全不存在的父目录。
isFile()判断是否是文件
isDirectory()判断是否是目录
listFiles()返回一个目录中的所有文件和目录的名字。
listfiles(FileFilter filter)返回一个目录中的过滤之后的所有文件和目录。
FileFilter接口 accept(File file)符合条件返回true否则返回false 。方法内容自定义。例如：
class MyFilter implements FileFilter{
private int time=1;
public boolean accept(File file){
boolean flag =false;//局部变量
if(file.isFile()){//过滤文件
if(file.getName().endsWith(".java")){//过滤后缀
flag =true;
}
}
return flag;
}
}
42、InputStream类：此抽象类是表示字节输入流的所有类的超类。其中有子类FileInputStream从某个文件中获得输入字节。读文件方法比如：
int len = 0;
while(len!=-1){
//每次读取一个字节
len = is.read();//读取字节一个字节一个字节地读
char c = (char)len;//强制转型
System.out.print(c);
}
或者：
int len=0;
while(true){
//每次读取尽量多的字节存放到buf数组里面
len= is.read(buf,0,buf.length);
//退出的条件
if(len ==-1){
break;//退出前的操作
}
//String str = new String(buf,0,len);//构造一个字符串.
System.out.print("读取了"+len+"个字节--"+str);
}
43、OutputStream类：此抽象类是表示输出字节流的所有类的超类。其中有子类FileOutputStream向某个文件输出字节流。如果要写出字符流应该用FileWriter。写文件的方法如：
OutputStream os = new FileOutputStream(fileName);//1.创建管道
//写操作
os.write(123);//写入数字
os.write('a');//写入字符
String zw = "测试输出流";
os.write(zw.getBytes());//先把字符串转换为字节数组
44、DataInputStream类：允许从选择的底层输入流中读取基本 Java 数据类型。
45、DataOutStream类：允许以基本 Java 数据类型写到选择的底层输出流中。
46、字符流Reader、Writer用于读写字符流的抽象类。用法如：
*************读***********
FileReader reader = new FileReader("roy.doc");
//创建一个自带缓存的读取器
BufferedReader br = new BufferedReader(reader);
//只是知道退出的条件--while循环
while(true){
String s = br.readLine();
if(s==null){//退出的条件
break;
}
System.out.println(s);
}
**************写***********
//创建一个文件写出器
FileWriter writer = new FileWriter("writer.dat");
BufferedWriter bw = new BufferedWriter(writer);//自带缓存的字符流
Scanner sc = new Scanner(System.in);
String words = sc.nextLine();
bw.write(words,0,words.length());
bw.newLine();//写入一个分隔符(换行)
bw.flush();
47、PrintWriter类：用于打印字符，以字符格式写到输出流中。
48、ZipInputStream zip压缩输入流。getNextEntry()读取下一个zip文件的条目。
49、ZipOutputStream zip压缩输出流。putNextEntry(ZipEntry e)开始写入zip文件的条目
50、ObjectInputStream 对象输入流。readObject()读取对象。
51、ObjectOutputStream 对象输出流。writeObject(Object obj)把对象写到输出流。
52、对象压缩流，要求对象需要实现序列化。Serializable接口
53、PipedInputStream 管道输入流 connect(PipedOutputStream src) 连接管道输出流
54、PipedOutputStream 管道输出流 connect(PipedInputStream snk) 连接管道输入流
55、管道流：两条管道相连了。就不能和其他管道连接了。管道输入流读取时候，如果管道输出流没有数据则阻塞等待。
*******************************多线程**********************************
56、进程：是正在运行的一个程序，可以包含多个线程，其中必须有一个主线程。
57、线程：是进程的子程序。每个线程是独立，每个线程都有可能抢到cup运行。在同一个进程内的线程可以共享内存空间和资源，是可能互相影响的。
58、线程生命周期：
创建----start()----->就绪---get-cpu----->运行--------->终止
↖______阻塞_____↙
解除阻塞 阻塞事件
59、线程默认命名：Thead-0,Thread-1,Thread-2…
60、实现多线程的方法：
一、继承Thread类重写run()方法。调用start()方法启动。
二、实现Runnable接口,然后通过Thread类的构造方法Thread(Runnable r)传递进去。调用start()方法启动。
61、Thread基本方法：
isAlive()判断线程是否活着。
sleep(int ms)当前线程睡眠一定毫秒。(静态方法)
yield()暂停当前正在执行的对象,执行其他线程。(静态方法)
join()和join(long ms)等待该线程终止。即是当前正在运行的线程等待该线程运行完毕再接着运行。
wait()和wait(long ms)进入等待状态
notify()唤醒被某对象锁锁住（即处于等待状态）的一个线程
notifyAll()唤醒被某对象锁锁住（即处于等待状态）的所有线程。优先级高的先被唤醒。
注意：某线程调用A对象wait()进入等待，只有A对象的notify()才能唤醒。
currentThread()返回当前正在执行的线程对象的引用。(静态方法)
interrupt()中断线程。
62、synchronized关键字 表示同步。用于标记为本该对象监听器的一部分。线程等待对象监听器，必须先指定等待哪一个对象监听器。用synchronized声修饰方法标记为本对象监听器的一部分，这样在方法里面调用wait()才表示等待本对象的监听器发布权限（得到权限才能继续运行）。
同步关键字还可以构成同步块。synchronized(object o){},同步块放在静态或者普通方法中。
63、死锁：2个以上的线程同时去强同一资源时候,引起互相等待。
64、BlockingQueue接口(阻塞队列)：元素不能为空null。
put(object o)将指定元素插入此队列中，将等待可用的空间（如果有必要）。
take()获取并移除此队列的头部，在元素变得可用之前一直等待（如果有必要）。
BlockingQueue实现类ArrayBlockingQueue和LinkedBlockingQueue 这些类可以用于消费者和生成者模式。
65、Callable接口：代表一个任务。V call()返回计算结果，如果得不到结果就抛出异常。然而Runnable接口的run()却没有抛出异常。
66、Exector接口：执行已提交的Runnable对象的任务。execute(Runnable command)在未来某个时间执行指定的命令。下面是两个重写execute方法的例子：
public void execute(Runnable r) {
r.run();//执行普通任务
}//第一个例子
public void execute(Runnable r) {
new Thread(r).start();//执行线程任务
}//第二个例子Executor接口
└ExecutorService接口
└ScheduledExecutorService接口ScheduledExecutorService的方法：
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 第一个参数表示将要执行的对象任务，第二个参数表示多少延迟时间开始，第三个参数表示执行该任务的频率（即是多少时间执行一次），第四个参数表示时间单元是什么（如时、分、秒）
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)延迟执行Runnable类型的任务
ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)延迟执行Callable类型的任务
67、Future接口：表示异步计算的结果。
boolean cancel(boolean mayInterruptIfRunning) 试图取消对此任务的执行。
get()如有必要，等待计算完成，然后获取其结果。
get(long timeout, TimeUnit unit) 如有必要，最多等待多少时间就获取其结果（如果结果可用）。
boolean isCancelled() 如果在任务正常完成前将其取消，则返回 true
boolean isDone() 如果任务已完成，则返回 true
Future接口
└ScheduledFuture接口：通常是用ScheduledExectorService安排任务的结果
68、Exectors类：用于给Callable、Exector接口的实现类和其他类联系的。
static Callable<Object> callable(Runnable task)传入Runnable对象,返回Callable对象。
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池。可以安排指定的延迟时间后运行或者定期运行。
69、线程池：把一定数量的线程纳入统一管理的对象。节省了开销。
*******************************网络**********************************
70、TCP/IP协议：传出控制协议/网际协议(transimission control protocol/internet protocol)
发送请求、服务端接收请求、服务端处理请求、服务端响应请求、客户端接收响应
71、UDP协议：用户数据包协议user datagram protocol
72、OSI与TCP/IP模型。
OSI:应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
TCP/IP:应用层、传输层、网际层、网络访问层
73、ServerSocket类：开启一个服务，默认是本地ip，需要指定一个端口。使用accept()方法可以阻塞监听请求,如果监听到则返回一个Socket对象。
74、Socket类：创建一个指定ip和端口的连接。getInputStream()可以返回输入流。getOutputStream()输出流。 InetAddress getInetAddress()返回套接字连接的地址。 InetAddress getLocalAddress() 获取套接字绑定的本地地址。
75、 InetAddress类：getHostName()返回主机名。
76、DatagramSocket类：发送和接收数据报包的套接字。只管发送。不管别人收不收收到数据报包。
receive(DatagramPacket p) 从此套接字接收数据包。
send(DatagramPacket p) 从此套接字接收数据报包。
75、DatagramPacket类：表示数据报包，从一台机器发送到另外一台机器可能不能同顺序收到，可能通过不同的路由，也可能有丢失的数据报包。
byte[] getData()返回数据缓冲区
setData(byte[] buf)设置缓冲区的数据
*******************************图形界面Swing**********************************
