开个帖子，写自己对自己知识点掌握情况的检查。

面向对象：
它是一种编程思想，是相对于面向过程而言的。
它更符合我们的思考习惯，把复杂的事情简单化，让我们从程序的执行者变成程序的指挥者。
举个例子：我们去北京，首先考虑住房问题，而用面向对象的思想来说，我可以找一个中介，调用中介的找房子功能，让中介去帮我找房子，找到了告诉我就行了。让原本一个复杂的东西，变得简单化，让我们从执行者变成了指挥者。
面向对象有3大特性：封装、继承、多态。
封装：就是把功能的实现隐藏起来，对外提供公共的访问方式。
它的好处：把实现隐藏，仅仅对外提供公共的访问方式。提高了代码的复用性。让我们的程序变得更安全。
private是封装的一种体现形式，像类、方法等，这都是封装的体现。
继承：当多个类中含有相同的内容，我们把它抽取出来，组成一个类，然后再让这多个类与这个类产生一个关系，这样这多个类就具备了这些功能。这个关系就叫做继承。
继承的好处：提高的代码的复用性；提高了代码的维护性；让类与类产生了关系，是多态的前提。
它的弊端：打破了封装性；因为让类与类间产生了关系，让类的耦合性增加。
继承的设计理念：是类与类间存在is a的关系。与接口不同，实现关系是like a的关系。
举个例子：如果说黑马程序员是一个抽象类的话，那么黑马精神就可以看成是一个接口。在考入黑马程序员之前，我可以具备"黑马精神"，我有这个功能，即是has a的关系。而当我考入了黑马程序员，我就成了它的一员，就是继承了它，是is a的关系。
多态：指的是同一事物在不同时刻表现出的不同状态。它有3个前提：1、存在继承或者实现关系。2、存在方法的重写。3、存在父类或父接口的引用指向子类对象。它分为：具体类多态、抽象类多态、接口多态。关于多态中成员的访问特点，只有成员方法是"编译看左边运行看右边"，因为只有方法，存在方法的重写；成员变量和静态方法，都是"编译看左边运行也看左边"。
多态的好处：提高了程序的扩展性。提高了程序的维护性。
它的弊端：父类不能直接使用子类的特有功能。

集合：
collection是单列集合的顶层接口，它是存储数据的一个容器，与数组不同，它的长度是可变的，而且只能存储引用数据类型的数据。可以存储不同类型的数据。它有2个儿子：list和set。List元素的特点是，元素有序可以重复。它又有3个儿子。ArrayList、Vector、LinkedList。ArrayList底层数据结构是数组，查询快增删慢、线程不安全效率高，Vector底层数据结构也是数组，查询快增删慢，但它线程安全所以效率低。LinkedList底层数据结构是链表，查询慢增删快，线程不安全效率低。
Set元素的特点是：元素无序、唯一。它有两个儿子：HashSet、TreeSet。HashSet底层数据结构是哈希表，由两个方法保证元素唯一：hashCode()和equals()。TreeSet底层数据结构是二叉树，它根据元素比较的返回值是否是0来判断元素是否唯一。有两种方式实现：1、让元素具备比较性，元素所在的类实现Compareable接口，重写compareTo方法。2、让集合具备比较性，集合实现Comparator接口，重写compare方法。
Map集合是双列集合的顶层接口，元素以键值对形式存储。键唯一、值可以重复。

HashMap底层数据结构是哈希表，与HashSet保证元素唯一性相同。
TreeMap底层数据结构是二叉树，与TreeSet保证元素唯一性相同。
另外：HashMap允许使用null键和null值，线程不安全效率高。而Hashtable不允许使用null键和null值，线程安全效率低。

IO流。
分为字节流和字符流。
字节流：可以一次读一个字节，也可以一次读一个字节数组。
字节输入流：InputStream
字节输出流：OutPutStream
由于都是抽象类，所以使用它的子类
FileInputStream
FileOutputStream
想要高效：
BufferedInputStream
BufferedOutputStream
字符流：一次读一个字符，一次读一个字符数组。
字符输入流：Reader
字符输出流：Writer
字节流通向字符流的桥梁：InputStreamReader
字符流通向字节流的桥梁：OutputStreamWriter
它的子类
FileReader
FileWriter
想高效：有一次读一行、一次写一个字符串的方法
BufferedReader
BufferedWriter

异常：异常就是程序执行出现不正常的情况。java通过类的形式，来描述异常，把异常封装成对象。
Throwable是异常体系的超类，它有两个子类来描述异常的情况。
Error：很严重的问题，比如内存溢出，这不是靠我们写代码能解决的，所以不由我们处理。
Exception：由我们来处理的异常。它又分为两大类：编译时异常和运行时异常。
运行时异常：即RuntimeException及其子类。当发生时，系统希望程序停止。因为出现了无法继续运算的情况，需要我们在程序停止之后，对代码进行修改。
比如：IndexOutOfBoundsException(数组角标越界异常)、ClassCastException(类型转换异常)等。
编译时异常：即非RuntimeException及其子类，就是存在安全隐患的，要标识出去给调用者进行处理，否则就会编译失败。比如：IO流中经常见到的IOException。
对于异常的处理，有两种方法：1、不处理，用throws在方法声明上抛出去，抛给调用者，让调用者处理。（如果一直抛，最终抛给JVM）。2、用try...catch...finally语句处理。
当我们在写异常的时候，该有RuntimeException还是非RuntimeException呢？
我们看当发生异常时，能不能由我们来解决。如果不能解决需要修正代码，就继承RuntimeException。如果能处理，就继承Exception，对其处理后，程序即可继续执行。

小小面试题：
throw和throws的区别：
throw：用在方法体内，跟的是一次对象名；只能抛出一个一次对象名；表示抛出异常，由方法体内的语句处理；throw表示跑出了异常，执行throw一定抛出了某种异常。
throws：用在方法声明后面，跟的是异常类名；可以跟多个异常类名，用“，”隔开；表示跑出一次，由方法的调用者来处理；表示出现异常的可能性，并不一定是会发生这样的异常。

多线程：
要说多线程，就得先了解进程。进程是指正在运行中的程序。而线程，是进程的一个执行单元。
多线程的意义：提高了CPU的使用率。
java实现多线程有两种方式：一种是继承Thread类，一种是实现Runnable接口。
有了 方式1 为什么要有 方式2？  答：实现Runnable避免了java语音单继承的局限性。更符合多个线程去处理同一个资源的情况，把线程和程序代码数据有效的分类，更符合面向对象的思想。举例：当用第一种方式创建线程时，Thread t1 = new Thread(); Thread t2 = new Thread(); 这样，没创建一个线程，就会创建一个对象，复制一份数据。而实现Runnable接口后，仅仅 MyThread mt = new MyThread()； 创建了一个对象。
run和start的区别。run里面放的是被线程执行的代码，直接调用仅仅是普通方法。start()是启动线程的方法，启动后由JVM调用run里面的方法。
线程的调度：分时调度和抢占式调度。java采用的是抢占式调度。
线程控制常见的方法：
休眠线程：sleep(...) 线程休眠xxx毫秒。
加入线程：join( ) 等待该线程终止
礼让线程：yield( ) 一定程度上你一次我一次
守护线程（后台线程）：setDaemon(boolean flag) 设置为后台线程。如果全为后台线程时，虚拟机退出。
终止线程：stop( )（已过时）、interrupted( )
方法的区别：（1）sleep和wait、（2）stop和interrupt
（1）sleep和wait。
sleep是Thread类的方法。它的参数列表内必须有参数。调用该方法不会自动释放锁。
wait是Object类的方法。它的参数列表内可以有参数也可以没有。调用该方法后会自动释放锁。
（2）stop和interrupt。
stop：使该线程终止。但终止之后，后面的代码不会被执行。因为太过于暴力，所以被淘汰了。
interrupt：通过抛出一个InterruptException异常来是线程终止，后面的代码还会执行。
线程的生命周期：
新建-->就绪-->运行-->死亡
新建-->就绪-->运行-->阻塞-->死亡
多线程出现安全问题的原因：1、存在多线程。2、存在共享数据。3、出现多条语句操作共享数据。
同步解决线程安全问题：
同步代码块：synchroized(锁对象) { 被同步的代码 }
同步方法：这里的锁对象是this
静态同步方法：这里的锁对象是当前类的字节码文件对象
死锁：我的理解：至少存在两个线程和两把锁，我拿了你的锁，你拿了我的锁。我等着你给我，你等着我给你。这样就形成了死锁现象。

网络编程：网络编程三要素：IP地址、端口、协议。
UDP协议和TCP协议的区别：
UDP协议是将数据打包进行传输，每次传送的数据小，它不保证数据一定能被接收，效率高。举例：发短信。
TCP协议是建立Socket连接通道，进行大数据量的传输。保证数据一定能被接收，效率低。举例：打电话。
UDP协议：
发送端：
1、创建发送端Socket对象。（DatagramSocket）
2、创建数据，将数据打包。（DatagramPacket）
3、调用Socket方法发送数据包。（send( )）
4、关闭资源
接收端：
1、创建接收端Socket对象。（DatagramSocket(int port)）
2、创建数据包接收数据。
3、调用Socket方法接收数据。（receive）
4、解析数据包。（getData）
5、关闭资源。
TCP协议：
客户端：
1、创建客户端Socket对象。（Socket）
2、通过Socket对象，向通道内写数据。
3、关闭资源。
服务器端：
1、创建服务器端Socket对象。（ServerSocket）
2、监听客户端连接。（Socket s = ss.accept();）
3、通过Socket对象，向通道内读数据。
4、关闭资源。

反射
概念：反射就是在运行状态中，对任意一个类，都能知道它的属性和方法。对任意一个对象，都能调用它的方法和属性，包括私有。这种动态的获取信息及动态的调用对象的方法的功能，成为反射。
获取Class字节码文件的三种方式：
1、通过Object类的getCLass()方法。如： Person p = new Person(); Class c1 = p.getClass();
2、通过数据类型的静态属性，数据类型.Class。如： Class c2 = Person.Class;
3、通过Class类的静态方法，forName()。如：Class c3 = Class.forName("cn.itcast_01.Person");
用过反射创建对象的两种方法：
1、通过Class类的方法，由无参构造创建对象。Object obj = c.newInstance();
2、通过Constructor对象，指定构造方法创建对象。Object obj2 = con.newInstance();
通过得到字节码文件对象，也就是得到该类的Class文件对象，我们就可以得到它的成员变量、构造方法、成员方法。
而反射，是以类的形式体现他们的。通过该类的对象可以使用相应的方法，来使用它们。
成员变量：Field
构造方法：Constructor
成员方法：Method

练习：
通过反射获类的私有字段并使用。步骤：
1、得到该类的字节码文件对象。Class c = Class.forName("xxxx");
2、通过反射创建对象。Constructor con = c.getConstructor();   Object obj = con.newInstance();
3、通过反射获取成员变量。 Field nameField = c.getDeclaredField("name");   
4、设置取消权限访问检查。nameField.setAccessible(true);
5、使用该字段。nameField.set(obj,"张三");
通过反射获取类的私有成员并使用。步骤：
1、得到该类的字节码文件对象。Class c = Class.forName("xxxx");
2、通过反射创建对象。Constructor con = c.getConstructor();   Object obj = con.newInstance();
3、通过反射获取成员方法。Method method = c.getDeclaredMethod("show");
4、设置取消权限访问检查。nameField.setAccessible(true);
5、使用该方法。method.invoke(obj);

不错不错,果断收了

不错啊  继续加油

总结的很好