自己总结，有问题的地方，欢迎提出，共同进步!
一、JAVA基础：
| 知识点 | 明细 |
| java介绍 | |
| java变量 | |
| 命名规范 | 项目，包，类，变量，常量 |
| 数据类型 | 基本 引用 |
| 运算符 | 算数，比较，逻辑，赋值，自增自减，位 |
| if switch | 分支语句 |
| for while do-while | 循环语句 |
| 类和对象 | 概念 |
| 方法定义 | 四种定义和调用 |
| static | 静态属性，静态方法 |
1、java介绍
2、java变量
数据类型 变量名；
如：int i;
3、命名规范：
（1）驼峰命名法：首单词字母小写，其余单词首字母大写。（变量，常量，方法名）
（2）类，项目名单词首字母大写
（3）包：域名.公司名.项目名
4、数据类型：
（1）基本类型：八种
byte int short long float double char boolean
（2）引用类型：类，接口，数组
5、运算符：
（1）算数运算符：+ - * / %
（2）比较运算符：> < >= <= !=
（3）逻辑运算符：&& || ！
（4）赋值运算符：==
（5）自增自减：++ --
（6）位运算：
（7）三目运算符： ？：
6、分支语句：
（1）if语句
if(){}
if(){}else{}
if(){}else if(){}else if(){}......else{}
（2）switch语句
switch()
{
case xx:break;
case xx:break;
case xx:break;
......
default xx:break;
}
7、循环语句：
（1）for循环
for(;;){}
两个；；必须写，如果只写两个；；便是死循环
（2）while循环
while(){}
（）内是循环条件，如果是true则是死循环
（3）do-while循环
do{}while();
（）后要加；，至少要循环一次，（）内是循环条件，如果是true则是死循环
8、类和对象：
类：把对象的共有部分抽象出来，封装在类中。是引用类型。
class 类名{
变量;
方法;
}
对象：类的实例。
对象是类的实例，类是对象的模板。
9、方法四种定义及调用：
（1）定义
<1>无参数，无返回值
访问修饰符 void 方法名（）{}
生活实例：人的睡觉的方法
<2>无参数，有返回值
访问修饰符 返回值类型 方法名（）{}
生活实例：得到某人的姓名
<3>有参数，无返回值
访问修饰符 void 方法名（参数列表）{}
生活实例：人吃东西
<4>有参数，有返回值
访问修饰符 返回值类型 方法名（参数列表）{}
生活实例：花钱买东西
（2）调用
<1>方法被static修饰：
类名/对象.方法名（）；
<2>方法为被static修饰：
对象.方法名（）；
10、static（静态的）：
<1>static可以用来修饰属性，或方法（被修饰的方法称为类方法）。
被修饰的属性和方法的调用：类名/对象.属性/方法（）
<2>static静态代码块：static{}
只要调用类中的内容，静态代码块都会执行，切在构造方法前面
二、Java面向对象（要有自己的理解，不能只靠背）
| 知识点 | 明细 | 难度 | 面试 |
| 封装 | 概念：private get set this（属性 构造 普通方法） 重载（方法 构造方法） | 简单 | 必考 |
| 继承 | 关键：extends super final 特点：单继承 多层次 先实例化父类 再实例化子类 重写： 普通方法 类与类：继承 | 难 | 必考 |
| 接口 | 关键：interface Implements 特点：属性 构造（没） 抽象方法 类和接口：多实现 | 难 | 必考 |
| 多态 | Public void 方法（接口/父类 对象名）{ } | 难 | 必考 |
| 抽象类 | 定义：class abstract 类名 属性：变量/常量 构造:有 不能实例化 方法：普通 /抽象 | 中 | 必考 |
| 集合 | List：ArrayList LinkedList Set：HashSet TreeSet Map：HashMap HashTable 遍历：for foreach iterator | 中 | 必考 |
| 异常 | try catch finally |
1、封装：
（1）把对象的属性和行为（方法）结合成一个独立的整体，并尽可能隐藏内部细节。
（2）封装的对象的属性最好用private修饰，对属性的调用可以用set和get方法。
（3）this关键字：
<1>当用到本类的对象时，可以用this代替。
<2>可以在本类的构造方法A中调用其它的构造方法B，但是要在构造A的代码的第一句。
（4）构造方法：public 类名{}
<1>初始化（把变量赋为默认值），实例化对象（类创建对象的过程）给对象的某些属性赋值（对应的要有构造方法）。
<2>调用：实例化时自动调用：类名 对象名=new 类名（）；
<3>每个类中至少都会有一个构造方法，如果没有明确，系统则提供一个无参的，方法体为空的构造，若明确，系统则不再提供
（5）重载：
<1>一个类中有方法名相同，参数列表不同（参数个数，参数类型，参数顺序不同）的方法叫方法的重载。
<2>重载与访问修饰符和返回值（有的方法无返回值）无关。
<3>构造方法也可以重载。
2、继承：
（1）继承关键字：extends，适用于类与类之间，接口与接口之间。
（2）特点：
<1>类与类之间单继承，多层次，接口与接口之间多继承。
<2>子类继承父类后，若实例化子类，那必定先实例化父类，再实例化子类。
（3）重写：
<1>子类继承父类后，对继承过来的方法感到不满意，需要对其进行改写叫方法的重写。
<2>重写的前提是要继承，所以重写是对从父类里继承过来的方法，没有继承过来不能重写。
<3>重写要求：方法名和参数列表必须相同。而访问修饰符不能比父类的更“严厉”，返回值一样或是其子类。
（4）super关键字：
<1>当子类需要父类的对象时，可以用super代替。
<2>在子类构造方法中，调用父类构造方法，但是要在子类构造的代码第一行。
（5）final：
<1>如果某类，某方法不想被继承，设定某个常量则用final修饰。
<2>特点：修饰属性则是常量，修饰方法和类不能被继承。
3、接口：
（1）关键字：声明接口：interface，实现接口：implements
（2）特点：
<0>语法
<1>属性是常量，默认用public static final修饰
<2>方法是抽象方法，默认用public abstract修饰
<3>没有构造方法
<4>不能实例化
<5>实现类必须实现接口的所有方法
<6>接口与接口是实现，类与接口是继承
（3）类实现接口（多实现），接口继承接口（多继承）。
4、多态：
（1）概念：某个对象在不同的时刻表现出的多种状态。
核心：方法传入不同的值调用不同的方法。
（2）两种实现：
<1>父类或接口作为参数（体现核心）
<2>父类或接口作为返回值
（3）public 返回值类型 方法名（父类/接口 对象名）{}
生活实例：老师布置作业，每个学生做的作业的结果都不同。
5、抽象类：
（1）定义：public abstract 类名{}
（2）特点：
<0>语法
<1>可以有常量也可以有变量
<2>可以有普通方法，也可以有抽象方法
<3>有构造方法
<4>不能实例化
<5>子类继承抽象类，要实现其所有的抽象方法。
6、集合：
（1）集合有了两大类：
<1>Collection（单列集合）:
List（有序，不唯一）:
ArrayList:底层数组，查询快，增删慢，线程不安全，效率高
LinkedList:底层链表，查询慢，增删快，前程不安全，效率高
Set（无序，唯一）:
HashSet:底层哈希表
TreeSet:底层红黑树（一种自平衡的二叉树）
<2>Map（双列集合）:
HashMap:底层哈希表
TreeMap:底层红黑树（一种自平衡的二叉树）
（2）ArrayList与LinkedList区别：
ArrayList与LinkedList除了底层的区别，LinkedList比ArrayList多六个方法：
setFirst() getFirst() removeFirst() setLast() getLast() removeLast()
（3）遍历：
<1>for循环：前提：集合有序（由于for循环根据下标来取值，如果无序，则无法取到下标）
<2>for-each（增强for）：集合有序无序都可以。（for-each其实就是用来代替迭代器，用法比迭代器简单的多）
<3>迭代器（Iterator）：集合有序无序都可以。
7、异常：
（1）格式：
<1>try{
//可能发生异常的代码块
}
catch（Exception e）{
//捕捉到异常并处理代码块
}
finally{ //没有finally代码块也可以
//发不发生都要执行的代码块
//一般写关闭流等代码
}
<2>声明一个异常抛出：
当有异常时：throw new Exception("异常原因");
此时方法要抛出异常：throws Exception
（2）当catch中有return情况，代码的执行过程：
<1>如果不发生异常：执行try和finally
<2>如果发生异常：先执行try，在执行catch的return之前，在执行finally，最后执行catch的return。
三、java扩展点 加分点
| 知识点 | 明细 | 难度 | 面试 |
| 文件流IO | 字节流2 字符流2 缓存流4 转换流 | 难 | 出 |
| 线程 | 难 | 出 | |
| 网络编程 | 难 | 几率很小 |
1、文件IO流：
InputStream FileInputStream BufferInputStream
OutputStream FileOutputStream BufferOutputStream
Reader FileReader BufferReader
Writer FileWriter BufferWriter
牢记他们之间的转换，熟练运用。（具体方法就不再写了）
2、多线程：
（1）线程的基本实现：
<1>类A继承Thread类，重写run方法，在测试类中实例化类A的对象a，让a调用start()方法
<2>类A实现Runnable接口，重写run方法，在测试类中实例化类A的对象a，在实例化Thread的对象t，让a作为参数传入t的构造方 法中，让t调用start()方法。（常用这种方法实现线程）
（2）实现线程的两种方法的优缺点：
<1>Java是单继承，如果继承Thread类，就不能继承其他的类。而Java可以多实现。适合资源共享。
<2>继承Thread类实现线程要比实现Runnable接口的代码简洁。
（3）线程常用的方法：
<1>stop()：强制终止线程（不推荐使用）
<2>sleep()：使线程休眠一段时间在执行
<3>join()：线程a调用此方法可以理解为线程a霸占资源，等线程a执行完之后其他线程再执行
<4>yield()：线程a调用此方法可以理解为线程a抢到资源后，礼让出去，然后再与其他线程一起抢夺资源。
<5>setPriority()：设置线程的优先级（0-10），默认为5，
注：优先级越高，抢到的资源不一定越多，只是抢到资源的几率大而已
（4）线程的生命周期
新建---->就绪--->运行--->阻塞--->死亡
<1>新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
<2>就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
<3>运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
<4>阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
<5>死亡：线程完成了它的全部工作或线程被提前强制性地中止
（5）线程终止的原因:
<1>运行完毕，线程终止
<2>出现异常，线程终止
<3>使用stop()方法强制线程终止
（6）线程同步：
<1>同步原因
当多个线程争夺同一份资源时，执行的不确定 性引起执行结果的不稳定，比如，多个线程同时卖票，可能就会同时卖出同一张票，这样就不合理了。
<2>解决方法：
使用synchronized关键字，对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
（7）死锁：
<1>出现原因：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
<2>解决方法：
1）专门的算法
2）尽量使用完后，释放资源。减少同步资源的定义。
3、网络编程（套接字 socket）：
（1）查看ip：在命令提示符里输入ipconfig回车即可
（2）查看端口：在命令提示符里输入netstat -ano回车即可
（3）查看正在使用的端口：在命令提示符里输入tasklist|findstr "正在使用的端口号"回车即可
（4）TCP：
<1>特点：
1）基于字节流传输层
2）面向连接
3）点对点通信
4）高可靠性
5）实时，快速
<2>缺点：
占用系统资源多，效率低
比如现实世界的打电话。
<3>TCP的三次握手：
第一次握手：建立连接时，客户端发送syn包
第二次握手：服务器收到数据包
第三次握手：客户端收到服务器
（5）UDP特点：
<1>非面向连接
<2>传输不可靠
<3>数据可能丢失
<4>占用系统资源少，效率高
比如现实世界的发短信。
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
