问题

回答和思考

实际例子备注和加分点、容易混淆的点

怎样做好一个好的程序员

1. 好的学习方法

   1. 合格的程序员俩个能力

      1. 很好的指法速度（敲代码快）

         1. 练到肌肉记忆

         2. 金山打字通

      2. 好的编程思想，练就解决实际问题思路

         1. 不要照抄代码，一点没用，没有灵魂和思路

         2. 结论验证法

            1. 听课过程笔记记录下来，记忆重点结论

            2. 写自己程序，想一切办法推翻结论或者验证结论

      3. 兴趣驱动，对生活有激情，有好奇心

      4. 走出舒适区，不断学习，解决有挑战的问题，高效质量

1. 方法论：三棱镜，五WHY

2. 合格的程序员俩个能力，怎样提升

   1. 练习打字，编写代码

   2. 有兴趣，像打游戏一样

   3. 挑战自己

JAVA技术是什么以及主要版本

这个技术的优缺点

1. JAVA基础： 1.1 JAVA基础（内部类，static，成员局部变量）

   1. 是什么：

      1. Java是一门面向对象编程语言，Java语言具有功能强大和简单易用两个特征。

      2. 是最受欢迎的面向对象的编程语言，在中国超过80%都是JAVA程序员

      3. 由一系列的计算机软件和规范组成的技术体系，提供了完整的用于软件开发和跨平台部署支持环境，广泛用于嵌入式系统，移动终端，企业服务器，大型机等

      4. Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称，用于后端开发的强语言类型，Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

2. JAVA的技术体系

   1. JVM、JRE和JDK的关系

      1. JVM(Java Virtual Machine)是JAVA的虚拟机：Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言实现跨平台。

         1. java编译程序面向虚拟机，虚拟机理解的代码叫字节码（.class文件）

            1. JAVA代码被JDK的编译器编译成JVM可执行的JVM字节码

         2. JVM的解释器再把字节码编译成机器码执行

            1. JVM字节码被JVM的解释器编译成机器可执行的二进制机器码，然后程序正常开始运行

         3. 主要的组成部分：JDK用于支持JAVA程序开发的最小环境，Java Development Kit是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等

      2. JRE是支持JAVA程序运行的标准环境：包括Java虚拟机和Java程序所需的核心类库，

         1. Java Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包。

      3. JDK是Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE

3. JAVA20年的发展史

   1. 1994年3月JAVA的前身Oak项目启动，在冰箱，收音机上的程序架构

   2. 1995年5月23日：Oak更名为JAVA，第一次提出“Write Once，Run Anywhere”

   3. 1998年12月4日：里程碑重要版本，Sun把JDK1.2把JAVA技术分为三个方向：J2EE，J2SE，J2ME

   4. 1999年4月27日，HotSpot诞生，Sun收购公司，成为JDK1.3及之后所有JDK版本默认JAVA 虚拟机

   5. JAVA的未来

      1. 新一代编辑器和向Native迈进

      2. 灵活的胖子HotSpot

4. JAVA的竞争对手和优势

   1. Java和C++的区别

      1. JAVA是单继承，但C++是多继承，JAVA中用接口实现多继承

      2. JAVA是解释类型语言，源码经过一次编译，成为.calss中间码（字节码），中间码再被JVM解释器成机器码，C++是编程语言，编码一次编译，在编译过程中链接变成机器码。所以JAVA可跨平台，C++执行速度快

      3. C++里有指针，JAVA里有引用

      4. C++需要自己管理内存，用析构函数。JAVA的JVM有自己的GC机制，自动回收超过作用域的内存，JAVA有object的finalize方法。

      5. JAVA是面相对对象语言，所有代码（变量，方法）在类中定义，C++中面向过程的全局变量和全局函数

   2. 优势

      1. 面向对象编程:一门结构严谨，面向对象编程，面向对象（封装，继承，多态）

      2. JAVA创造的绝对优势：虚拟机编译字节码运行，跨平台的特性。摆脱平台束缚，实现一次编写，到处运行。

         1. 实现原理：JAVA编译的后的.class文件只面向JAVA虚拟机，不面向运行系统，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。

      3. 提供相对安全的内存管理和访问机制，JVM避免绝大部分的内存泄漏和指针越界

      4. 多线程和高性能：支持多线程（多线程机制使应用程序在同一时间并行执行多项任务）

      5. 安全性和健壮性：（Java语言的强类型机制、异常处理、垃圾的自动收集安全性等）

      6. 开源的语言

      7. 简单易学（Java语言的语法与C语言和C+语言的语法与C语言和+语言很接近），支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的）

      8. JAVA还有个比较重要的是虚拟机编译字节码运行，跨平台的特性。

   3. 缺点

      1. 针对微服务开始捍卫一次编译导出运行的初衷，不需要那么繁重的编译工作

Java和C++的区别

1. java发展历史？

2. JAVA是什么？

3. JVM、JRE和JDK的关系

4. JDK和openJDK的区别

   1. 使用过LINUX的人都应该知道，在大多数LINUX发行版本里，内置或者通过软件源安装JDK的话，都是安装的OpenJDK，OpenJDK是JDK的开放原始码版本，以GPL(General Public License)协议的形式放出(题主提到的open就是指的开源)。在JDK7的时候，OpenJDK已经作为JDK7的主干开发，SUN JDK7是在OpenJDK7的基础上发布的，其大部分原始码都相同，只有少部分原始码被替换掉。使用JRL(JavaResearch License，Java研究授权协议)发布。至于OpenJDK6则更是有其复杂的一面，首先是OpenJDK6是JDK7的一个分支，并且尽量去除Java SE7的新特性，使其尽量的符合Java6的标准。关于JDK和OpenJDK的区别，可以归纳为以下几点：

   2. 授权协议的不同：OpenJDK采用GPL V2协议放出，而SUN JDK则采用JRL放出。两者协议虽然都是开放源代码的，但是在使用上的不同在于GPL V2允许在商业上使用，而JRL只允许个人研究使用。OpenJDK不包含Deployment（部署）功能：部署的功能包括：Browser Plugin、Java Web Start、以及Java控制面板，这些功能在OpenJDK中是找不到的。

   3. OpenJDK源代码不完整：这个很容易想到，在采用GPL协议的OpenJDK中，SUN JDK的一部分源代码因为产权的问题无法开放给OpenJDK使用，其中最主要的部份就是JMX中的可选元件SNMP部份的代码。因此这些不能开放的源代码 将它作成plug，以供OpenJDK编译时使用，你也可以选择不要使用plug。而Icedtea则为这些不完整的部分开发了相同功能的源代码 (OpenJDK6)，促使OpenJDK更加完整。

   4. 部分源代码用开源代码替换：由于产权的问题，很多产权不是SUN的源代码被替换成一些功能相同的开源代码，比如说字体栅格化引擎，使用Free Type代替。

   5. OpenJDK只包含最精简的JDK：OpenJDK不包含其他的软件包，比如Rhino Java DB JAXP……，并且可以分离的软件包也都是尽量的分离，但是这大多数都是自由软件，你可以自己下载加入。

   6. 不能使用Java商标：这个很容易理解，在安装OpenJDK的机器上，输入“java-version”显示的是OpenJDK，但是如果是使用Icedtea补丁的OpenJDK，显示的是java。

5. JAVA的竞争对手区别：优势缺点

   1. Python语言基于ABC语言，面向对象解释型语言，简洁和清晰的语法 特点，可扩展性和清晰语法。

   2. 易读，易维护，大量用户欢迎，用途广泛的语言

6. 高级语言的运行机制

   1. JAVA属于特殊的高级语言，它具有解释型语言和编译型特征，他经过先编译，后运行

   2. 解释型：ruby,python

   3. 编译型：C,C++，pascal

7. java开发环境搭建（path是运行命令行和classpath是运行命令行的路径：classLader）

8. JDK

JAVA基础语法核心

自己整理资料：1.1 JAVA基础（内部类，static，成员局部变量）

1. 第一章

   1. java的怎样运行（编译过程，运行过程JVM），

   2. java开发环境搭建（path是运行命令行和classpath是运行命令行的路径：classLader）

   3. 公共类和类的区别：一个类中可有很多类，不必须有主方法，但运行java.exe，必须有主方法

2. 第二章

   1. 标识符规范（JAVA区分大小写，大驼峰，小驼峰，见名释义，规则 ）：编写起名

      1. JAVA修饰符

         1. 访问修饰符

         2. 非访问修饰符

      2. 成员变量与局部变量的区别有哪些

         1. 成员变量：方法外部，类内部定义的变量，作用域：针对整个类有效。有默认初始值。

            1. 存储位置：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。

         2. 局部变量：类的方法中的变量，作用域：某个范围内有效(一般指的就是方法,语句体内)，没有默认初始值，使用前必须赋值。

            1. 存储位置：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结束后，就自动释放。

         3. 在使用变量时需要遵循的原则为：就近原则，首先在局部范围找，有就使用；接着在成员位置找。

   2. 关键字：特殊字符序列，全部小写

   3. 字面值：基本类型值，字符串，

   4. 变量：变量存储具体数据，有具体类型一致，数据类型 变量名 = 字面值；

      1. 字面值，就是数据，''只能放单字符

      2. =赋值运算符，先算右边的运算符

      3. 顺序执行，

      4. 同一个作用域：大括号之内，变量名不能重复

      5. 局部变变量：方法体之内，成员变量:方法体之外；就近原则，俩个变量名称一致

         1. 成员变量：默认值一切向看齐，

      6. 基本类型（二进制，10进制，16进制）：数字型头一位是正负，计算机只识别基本数据类型,char没负数，可以存储一个中文字符

         1. 不同编码会乱码：文字char,英文对照表，二进制对照关系，字符编码ASICC,26个二进制。

            1. 解码‘a’编为 01100001：解码，

            2. 01100001 按照ASCII编码 编码

            3. 同一个对照表

         2. 表示中文很困难，对照表很庞大

      7. JAVA底层unicode实现，unicode(utf-8)>GB2321

      8. 转义字符：/n,/t(制表符)，//转义特殊字符，/u表示unicode编码 ，native2ascii(中文对应的编码)

   5. 数据类型：八大基础类型：六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

      1. 整数数据类型：byte8（1位内存），short16，char16，int32，float32（4位内存），long64 ，double64，boolean

         1. 数值默认是INT类型，容易考类型转换long x= 1000;int的1000转为long，面试题

         2. 强制转换：存储数据是补码形式：10000000补码变为原码，先减一然后取反1

            1. 原码，反码，补码。原码+1，取反是反码。

            2. long k = 76:int 76 转为long类型

            3. long k = 2147483648L 结果是-2147483648 截成八位补码形式在变为变为原码

            4. 整数字面值没有超过byte，short,char取值范围，可以编译通过

      2. 浮点型

         1. dubbo精度相对太低，财务系统用java.math.bigDecimal引用数据类型

            1. SE类库字节码：C:\Program Files\Java\jre1.8.0_144\lib\rt.jar

            2. SE类库源码：C:\Program Files\Java\jre1.8.0_144\src.zip

         2. dubbo的位数大于float,存储的是近似值。有限资源存储无限数据

      3. 布尔类型 ，boolean:true/false(C语言0和1表示假和真)；逻辑运算和条件控制语句

      4. 转换规则，先转换在运算，注意优先级

         1. 八种数据类型除布尔都可以类型转换

         2. 小容量转为大容量，自动转换：byte 8 short -32768-3276(16)（char0-65535）16 int(32) long (32)float (32) dubbo(64)

         3. 大容量转为小容量强制类型转换，容易损失精度，加强制转换符，

         4. 整数字面值没有超过byte，short,char的取值范围，可以直接赋值给byte,short,char类型变量

         5. byte,short，char混合运算， 各自转换成int在做运算，注意：byte y=（byte）(short)10/3报错

         6. 多种数据类型运算，先转换成最大类型进行运算

      5. 引用数据类型

         1. 类（对象）

         2. 接口

         3. 数组

3. 第三章：运算符

   1. 算数运算符：加减乘除，取模，

      1. ++/--可以出现变量前，先自加1，然后在进行赋值运算

      2. ++/--也可以变量前，先赋值，然后再自加运算

         1. 直接打印（S++）打印S的值

   2. 关系运算符：结果是布尔，基本类型==比较的是值

   3. 逻辑运算符：

      1. 与或非异&俩边true，|一个true,!取反,^两边不一样

      2. &&,||短路与或 前面满足，直接返回结果，（x<y && ++x<y）

   4. 位运算符：2变为8最快的方法

      1. 面试题2>>2

   5. 赋值类运算符，不改变运算结果类型

      1. 基本：=先运行由标的

      2. 扩展赋值运算：+=，-=，*=，/=,%=；注意损失精度

         1. byte i+= 5 等同于i=（byte）i+5 但语法报错,

   6. 字符串连接运算符（+）

   7. 三木运算符：布尔表达式？表达式1：表达式2；

      1. sys(true？“男”：‘女’)只有打印时可以运行，表达式会报错

4. 控制语句

   1. 三大基本结构

      1. 顺序

      2. 选择、分支结构

         1. if，if/else：省略大括号时，注意只执行一行

         2. switch：选择结构：数据条件比较明确：后面只能是int（char自动转成int）和String类型数据，注意case穿透合并

            1. +，-，*，/；春夏秋冬，星期几等固定，分数范围

      3. 循环：最快适合循环方式的场景？

         1. 当型结构

         2. 直到型循环

         3. while：布尔表达式（先判断执行结果，语法直接检查不能写死），下边是循环体，可能一次都不执行

         4. do/while：执行1-n次，至少一次

         5. for循环：for：里面i变量作用域：三个表达式都非必须，但必须有分号；（初始，布尔，满足条件）

            1. 累加思想

            2. for循环嵌套：从里往外看，九九乘法表

         6. 嵌套循环;控制循环

            1. break：中断最近的循环嵌套可以给for起名，使用较少

            2. continue：跳过本次满足循环体条件

         7. foreach（遍历数组和集合）

         8. 递归是调用本身方法，条件里必须终止方法

5. 方法

   1. 是什么：

      1. 方法是一个完成特定功能并且被重复利用的代码；c语言叫函数，注意局部变量的作用域

   2. 定义方式：[修饰符列表] 返回值类型 方法名（形式参数列表）{方法体}

      1. 主方法中String[]里面内容不是必须的

      2. 返回值：空写void,不是空必须返回类型数据，return 返回方法执行结果，该方法结束；

   3. 怎样加载

      1. 先把代码片段放到方法区当中，存储xxx.class字节码文件，这个空间最先有数据

      2. 栈内存：

         1. 每个方法执行需要的内存空间（存储局部变量）

         2. 方法调用：压栈（在栈中分配空间）

         3. 方法执行结束：弹栈（方法占用空间释放，局部变量内存释放）

6. 深入了解数组

   1. 数组的优点和缺点，并且要理解为什么

      1. 数组特点

         1. 空间存储内存地址是连续的

         2. 每个空间占用大小相同

         3. 知道首元素的内存地址

         4. 通过下标可以计算偏移量

      2. 优点：检索效率高

      3. 缺点：随机增加删除效率低，无法存储大的数据量

      4. 注意：最后一个元素的增删效率不受影响

   2. 静态初始化数组：直接赋值int【】 arr = {1,2,3};

   3. 动态初始化数组:先初始化长度，然后再赋值，有默认值

   4. 一维数组的遍历

   5. 二维数组的遍历

   6. 数组对象存储堆内存中，当数组是对象数组，会先生成序号对象，然后在数组中直接引用该对象。

   7. 数组的拷贝：System.arraycopy()方法

      1. 数组的特点就是长度一旦确定，不可变

      2. 所有扩容时需要新建大数组，小数组被垃圾回收

   8. 数组的内存图：链形的

   9. 数组工具类

      1. 算法常见面试题

         1. 冒泡

         2. 选择排序

         3. 查找算法二分法

      2. 工具类Arrays，大部分都是静态的

         1. sort()

1. java的怎样运行（编译过程，运行过程JVM），

   1. 内存加载

      1. 先加载Object父类静态代码块，然后代码块，最后构造器，

      2. 方法区最先存储代码块

      3. 栈内存存储基本类型变量，或者引用类型变量地址

      4. 堆内存存储引用类型数据，或者链接引用类型地址

2. 八大基本类型（二进制，10进制，16进制）转换：

   1. 数字型头一位是正负，计算机只识别基本数据类型,char没负数，可以存储一个中文字符

   2. 成员变量的默认值

   3. long i = 89;存在类型转换

3. 强制类型转换的原理：精度为何损失

   1. 原码，反码，补码。原码+1，取反是反码。

   2. dubbo精度（近似值）相对太低，财务系统用java.math.bigDecimal引用数据类型

   3. byte8（1位内存），short16（-32768-32767(16)），char16(0-65535)，int32，float32（4位内存），long64 ，double32，boolean

4. 静态static,修饰后变成里类独有的

   1. （内部类，static，成员局部变量）需要补充下

   2. 静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。

5. UML图

6. 数组的内存分配

7. 控制语句

8. for循环

JAVA面向对象

面向对象三大特性：抽象，继承，封装，多态

1. 面向对象和面向过程

   1. 面向过程：实现功能的步骤和因果关系

      1. 优点：小型项目效率较高，不用建模，

      2. 缺点：耦合度高，扩展性差

   2. 面向对象：更符合人类思考方式

      1. 将现实分割不同对象：驱动，让每个对象驱动起来  b

2. 开发过程

   1. OOA（面向对象分析）、

   2. OOD（面向对象设计）、

   3. OOP（面向对象编程）

   4. 实现一个软件过程OO贯通

      1. 分析（A）——>设计（D）——>编程(P）

3. 类和对象是什么

   1. 类是对象的抽象（对象抽取为类）：类的表达式[修饰符] class 类名{构造器，成员变量，方法}

      1. 修饰符：public、final、abstract、省略

      2. 类的成员：

         1. 构造器

            1. 构造方法的作用:默认有无参构造方法（缺省构造器，也需要手动写出来）

               1. 创建对象，给属性变量赋值，默认值

               2. 实例完成，创建对象初始化

         2. 成员变量：[修饰符] 类型 成员变量名[=默认值]

            1. [修饰符]public，protected ,private，省略和static,final组合起来修饰变量

            2. 构造实例化时会给成员变量赋默认值

         3. 方法[修饰符] 方法返回值类型 方法名[形参列表]

            1. [修饰符]public，protected ,private，省略和final,abstract与static组合起来修饰方法

            2. 返回值：支持基本类型和引用类型

            3. 形参列表：同一类型多个参数值，可在最后加三个点

            4. 传参转换的内存，利用一个temp

         4. 成员变量和局部变量：作用域，存储位置区别

         5. 重载和重写的区别？ 方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现

            1. 重写在继承的基础上俩个类，子类方法覆盖父类方法，方法名和参数类型，个数，返回值都要求相同

            2. 方法重载，方法名相同（参数类型，个数，顺序）是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

               1. 重载是实现同一个功能的代码逻辑

               2. 递归是方法调用自己，里面一定要有条件，防止栈内存溢出（可以手动调整栈内存大小）

   2. 对象是类的实例（类变为对象叫实例化），类是对象的抽象，

   3. 类=属性➕方法，对象.方法（参数）

      1. 里面的名称是属性，描述状态

      2. 动词是方法，描述动作和行为

4. 面向对象的特征：抽象、继承、 封装、多态、

   1. 三大特性

      1. 封装：对象转态信息隐藏在内部：get和set都是实例方法不带static，实例方法调用必须先new对象

         1. 使用访问控制符：private（本身类）,default(包),protected（子类）,public

         2. 包：package,import,import static

      2. 继承：extend表示子类对父类的扩展，复用代码

         1. 继承最大缺点是强耦合，破坏了封装，

         2. 使用组合优化继承，UML图变为重新实现父类方法

            1. 私有引用父类，重新实现父类方法，

         3. 最佳实践

            1. 隐藏父类数据。成员变量变为private，不让子类访问

            2. 不让子类访问修改父类方法，优先private修饰，如果子类必须访问，但不允许重写，使用final修饰、最小访问控制符，默认protected修饰，子类可以修改。

            3. 不在父类构造器中调用子类重写方法

      3. 多态：编译时类型静态绑定（父类）和运行时类型动态绑定（子类）不一致都有重写相应的方法，所谓多态

         1. 向上转型：子类是特殊的父类，子类对象直接付给父类引用变量，子类转换成父类

         2. 向下转换：父类转换子类，强制转换，需要加强制转换符（子类特有方法）

            1. instanceof关键字判断对象是否该类的实例

   2. JAVA8的包装类

      1. 8个基本类型在JDK1.5支持自动装箱和拆箱

         1. String转成数值

            1. (Integer).parseXXX()，String转换成对应包装类型

         2. 引用类型转成字符串

            1. String提供多个重载ValueOf(),基本类型变量转成字符串；

            2. 对应的数值+""

         3. 自动装箱对比俩个数值，注意缓存大小，缓存内的相等，缓存外的不相等

         4. 包装类compare方法，比较俩个类型值，true>false：前面大输出1，相等0，前面小-1

   3. Object对象的通用方法

      1. 打印对象的toString方法，类名+@+hashCode

      2. ==和equal方法

         1. ==基本类型只比较数值，引用类型时比较引用对象是否相等

         2. equal比较的数值

         3. 常量池：专门用于管理编译时保存已编译。class中的数据（类，方法，接口中常量和字符串常量）

         4. String new String("hello")会产生俩个字符串对象

   4. 几个重要的关键字

      1. static静态变量：可修饰方法和成员变量，内部类（接口和枚举），初始化块，表示属于类本身，而不是某个实例/对象。

         1. 不能修饰构造器，

         2. static是静态，可修饰方法和成员（内部类，初始化块），表示属于类本身，而不是某个实例/对象。

            1. 用static修饰的叫类变量和类方法，直接通过类访问。其余的叫实例变量，实例方法

         3. null对象可以访问类成员，不会报空指针异常

      2. 单例类：一个类只能创建一个实例，这个类被称为单例类（一个窗口管理器，一个打印机）

         1. 使用一个类变量缓存创建实例

         2. 提供一个静态方法返回实例，判断没有时创建，有返回

      3. this关键字表示当前对象：

         1. 一个引用，保存内存地址指向自身

         2. 在实例方法使用，可省略（在构造方法不能省略），注意主方法是静态方法

         3. 出现实例方法中代表当前对象

         4. 不能使用在静态方法中

         5. 大部分可省略，但区分局部变量和实例变量时不能省略

         6. 第一行可以直接this("参数")调用本类其它构造方法，目的复用

      4. super关键字表示父类对象：在重写场景中访问父类原有方法，会在子类构造器省略显示；

         1. 作用，通过子类访问父类

            1. 访问父类属性：super.属性名

            2. 访问父类的方法：super.方法名（实参）

            3. 访问父类的构造器：super(实参)

         2. 特征

            1. 能出现在实例方法和构造方法中

            2. 不能使用在静态方法中（对象的）

            3. 可以省略，在构造器第一行

            4. 不可省略场景，父类和子类有同名方法或者同名属性，子类访问父类，super.不能省略

      5. 实例变量和静态变量总结(看省略的是this还是类名)

         1. 实例相关依赖对象，通过对象.来访问，默认加this

         2. 静态相关属于类本身，采用类名.来访问，发现static会默认在前面加类名

         3. 负责调用的对象和被调用方法在同一类中，this和类名可以被省略

      6. final关键字：修饰的类，变量，方法不在允许重新赋值；增加安全性

         1. final修饰的类无法继承（不可有子类）

         2. final修饰的方法不能重写，但可以重载：子类不允许覆盖final方法，final不能派类，

         3. 成员变量（类变量和实例变量）：一旦获取初始值，该final变量值不能重新赋值，

         4. 修饰引用对象时，不能在指定其它对象，注意引用对象数据可以修改

         5. final修饰的实例变量必须手动初始化，不能采用系统默认值

         6. 修饰的变量和static同时使用称为常量

         7. 不可变类：8个包装类加上String都是不可变类，不可变类实现原则String源码

            1. 使用private和final修饰符修饰该类的成员变量

            2. 提供带参构造器，根据传入参数初始化类里成员变量

            3. 只为该类成员变量提供getter方法，不提供Setter方法

            4. 有必要重写Object的HashCode方法和equals()方法

            5. 注意：设计不可变类，如果其中有引用类型的成员变量，需要采取措施保证该引用类型变量不可被修改

         8. 实现缓存实例的不可变类

            1. Integer如果两次ValueOf生成是同一个对象，但只缓存-128-127的对象

      7. abstract定义抽象方法和抽象类：

         1. 抽象类：类和类之间共同特征抽取，类本身不存在，所以抽象类无法创建对象（无法实例化）

            1. 抽象类属于引用类型

            2. 语法：修饰符列表 abstract class 类名{}

            3. 抽象类无法实例化，用于子类继承

            4. final和static对立不能同时修饰方法

            5. 抽象类子类可以是抽象类，也可以是非抽象类

            6. 抽象类无法实例化，但有构造方法，给子类使用

            7. 抽象类不一定有抽象方法，但抽象方法必须在抽象类中

            8. 非抽象类继承抽象类，必须把抽象方法重写实现

         2. 抽象方法:public abstract void doSome();

            1. 抽象方法只有方法的签名，没有方法的具体实现

            2. 有抽象方法的类必须是抽象类，抽象类里可没有抽象方法，抽象类不能创建实例

            3. 利用抽象类和抽象方法优势，可以更好的发挥多态的优势

            4. 当使用abstract修饰时，表示这个类只能被继承，修饰方法时，表示子类必须实现重写；（final和abstract修饰方法不能同时使用）

         3. 注意，源码中有native修饰的方法体，表示调用JVM本地程序（C++），并不是抽象类。

      8. 接口（JAVA8改进）:[修饰符] interface 接口名 extends 父接口1，父接口2

         1. 接口的组成

            1. {1.常量:自动为接口增加public static final 修饰符

            2. 2.抽象方法:系统自动为普通方法加public abstract修饰符，不能有方法同

            3. 3.内部类，接口，枚举

            4. 4，默认方法或者类方法}：必须有方法体

               1. java8允许接口定义默认方法，默认方法必须default修饰，

               2. java8允许接口定义类方法，必须使用static修饰

         2. 接口的优点：面向接口编程，降低耦合度，提高程序扩展力，符合OCP编程思想

         3. 接口的特征

            1. 接口是一种引用数据类型，编译后也是字节码

            2. 接口是完全抽象的，抽象方法不能有方法体

            3. 接口可实现多继承（一个类实现多个接口）

            4. 接口只包含厂里和抽象方法

            5. 接口中所有元素都是public定义的

            6. 抽象方法:系统自动为普通方法加public abstract修饰符，可省略

            7. 常量:自动为接口增加public static final 修饰符，可省略

            8. 一个非抽象类实现接口，必须实现所有方法

            9. 一个类可是实现多个接口，

            10. 使用接口可以使用多态

            11. 接口里所有方法都是抽象方法，允许接定义默认方法

         4. 抽象类和接口的区别：半抽象和完全抽象

            1. 接口可实现多继承（一个类实现多个接口），抽象类只能单继承（一个类只能继承一个类）

            2. 抽象类可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

            3. 抽象类可以有构造方法，接口中没有

            4. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的

            5. 接口只有抽象方法：中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

            6. 接口表示功能实现like a的区别，抽象类是所属关系 is a的区别（继承），has a 是属性形式关联关系

      9. 内部类：一个类放在另外一个类的内部

         1. 内部类的作用

            1. 内部类提供了更好的封装

            2. 内部类成员可以直接访问外部的私有数据

            3. 匿名内部类适用于创建仅使用一次的类

         2. 内部类的分类：可读性很差，不建议使用

            1. 静态内部类：属于外部类本身，不属于外部类对象

            2. 非静态/实例内部类：不能有静态方法，静态初始化块，静态成员变量等

            3. 局部内部类：局部使用很少

            4. 匿名内部类：局部内部类一种，new 对象时传输属性参数

               1. 缺点:可读性差，不好扩展

               2. new 接口名（）{实现方法体}

               3. 可以新实现一个接口来代替匿名内部类

   5. 普通类和抽象类有哪些区别？

      1. 普通类不能包含抽象方法，抽象类可以包含抽象方法。

      2. 抽象类不能直接实例化，普通类可以直接实例化。

   6. 主流的开发方法

      1. 结构化开发方法分析SA，设计SD，结构化编程SP（C，basic，pascal）:自顶向下，逐步求精，模块化

      2. 面向对象开发方法（C++，C#，JAVA，Ruby）：

   7. JAVA8新特性Lambda表达式：

      1. 定义：支持代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（函数式接口）

      2. 三部分组成

         1. 形参列表；允许省略，当一个参数时，圆括号可省略

         2. 箭头（->）

         3. 代码块：只有一条语句可省略代码花括号，可省略return 关键字

      3. 作用

         1. 可以简化创建的匿名内部类对象

      4. 方法引用和构造器引用

         1. 引用类方法：类名：：类方法

         2. 引用特定对象的实例方法：特定对象：：实例方法

         3. 引用某类对象的实例方法：类名：：实例方法

         4. 引用构造器：类名：：new

   8. 枚举类

      1. JAVA5提供枚举关键字enum定义枚举类

      2. 枚举类和普通类区别

      3. 枚举类的实际使用

         1. 和switch搭配使用，

         2. 枚举类有valuse()方法，返回枚举的所有实例

      4. 枚举类中包含的常用方法

         1. int compare

         2. String name

         3. String to String

      5. 枚举类的成员变量，方法，构造器

      6. 实现接口的枚举类

      7. 包含抽象方法的枚举类

   9. 对象和垃圾回收

      1. 对象在内存中状态

      2. 强制垃圾回收finalize方法

   10. 使用JAR文件

2.面向对象五大基本原则是什么（可选）

1. 单一职责原则SRP(Single Responsibility Principle)

   1. 类的功能要单一，不能包罗万象，跟杂货铺似的。

2. 开放封闭原则OCP(Open－Close Principle)

   1. 一个模块对于拓展是开放的，对于修改是封闭的，想要增加功能热烈欢迎，想要修改，哼，一万个不乐意。

3. 里式替换原则LSP(the Liskov Substitution Principle LSP)

   1. 子类可以替换父类出现在父类能够出现的任何地方。比如你能代表你爸去你姥姥家干活。哈哈~~

4. 依赖倒置原则DIP(the Dependency Inversion Principle DIP)

   1. 高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。就是你出国要说你是中国人，而不能说你是哪个村子的。比如说中国人是抽象的，下面有具体的xx省，xx市，xx县。你要依赖的抽象是中国人，而不是你是xx村的。

5. 接口分离原则ISP(the Interface Segregation Principle ISP)

   1. 设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好的多。

1. 程序员就是把现实世界问题转成软件的实际解决方式，作为网络和现实世界的桥梁

2. JVM创建类时的内存分配

   1. 栈：对象的引用地址

   2. 堆内存，存储对象：new时分配地址，然后会初始化成员变量，生成对象的实例变量（几个new会生成几个）

   3. 先加载Object父类静态代码块，然后代码块，最后构造器，

3. 类， 方法，成员变量的组成

4. 三大特性：继承、 封装、多态、

5. 自动装箱和拆箱：基本类型和包装类型

6. Object对象的通用方法toString，equal,hashCode

7. 重要的关键字

   1. static

   2. final

   3. 抽象类

   4. 接口

   5. 单例

   6. this和super

   7. 内部类

8. JAVA新特性Lambda表达式

JAVA基础类库

1. Scanner键盘输入

   1. 主方法的arg参数可以通过java 运行类 后加命令的打印

2. 系统相关类

   1. System

      1. gc垃圾回收

      2. getenv,getProperties,getProperty打印环境变量

      3. 获取系统时间：currentTimeMillis，nanoTime

      4. 标准输入，标准输出，错误输出流：in,out,err,setIn，setErr

   2. Runtime:JAVA运行时环境

      1. 通知系统回收垃圾:runFinalization

      2. Load,LoadLibrary:加载文件和动态链接库

      3. 处理器数量，内存信息

      4. 启动程序

3. 常用类

   1. Object类，所有类的父类

      1. equals:判断引用地址是否相等

      2. finalize：没有引用时，垃圾回收器回收

      3. getClass：返回该对象

      4. hashCode

      5. toString:运行时类名@十六进制hashCode值

      6. 控制线程的：wait,notify,notifyAll

      7. clone:克隆方法，实现Cloneable很高效

   2. 和新增的Objects类：提供工具方法操作对象

      1. 工具类通常加个s:例如：Arrays,Collections

   3. String,StringBuffer,Stringbuilder都实现CharSequence接口，

      1. String是java修饰不可变类

      2. StringBuffer:是字符串序列可变化的字符串：线程安全的类，但性能略低

         1. 可使用append,insert,reverse,setCharAt,setLength改变，

         2. 一旦确定该对象用toString方法改变

      3. JAVA1.5新增了StringBuilder：线程不安全的类，相对于stringBuffer但性能略低

   4. Math类：复杂的数值运算

   5. Random类：生成一个伪随机数，两个构造器，一个以当前时间为种子，另一个需传输一个Long数组

      1. 由于种子相同产生结果相同，产生的是伪随机数

      2. Random rand = new Random(System.currentTimeMillis())

      3. 多线程使用ThreadLocalRandom

   6. BigDecimal类:float和dubbo精度缺失，该类提供更精确的运算

4. 日期时间类

   1. Data类

   2. Calendar类：抽象类，表示日历

   3. JAVA新增的日期时间包java.time

5. 正则表达式

6. 国际化和格式化

7. JAVA新增日期，时间格式器

JAVA1.5增加泛型

1. 泛型：Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

   1. 定义：让集合记住其元素的数据类型

      1. 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

   2. 作用：指定集合的类型

   3. 分类

      1. JAVA7引入菱形语法，省略对应类型eg List<String> str = new ArrayList<>

      2. java 中泛型标记符：

         1. * E - Element (在集合中使用，因为集合中存放的是元素)

         2. * T - Type（Java 类）

         3. * K - Key（键）

         4. * V - Value（值）

         5. * N - Number（数值类型）

         6. * ？ - 表示不确定的 java 类型

   4. 实际使用场景

      1. 定义泛型类和接口和泛型方法：允许在定义类，接口方法时使用类型形参

      2. 泛型类派生子类：需要为子类指定实际类型

         1. 泛型类即使类型不同，但他们的getClass结果相同

      3. 类型通配符：？

         1. 基础使用：类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。

         2. 类型通配符的上限：List<? extends Shape>表示是Shape子类就可以

         3. 类型通配符的下限：List<? super Type>表示是Type的本身或者type的父类

      4. 泛型的擦除和转换：

   5. 泛型方法

      1. 定义泛型方法

      2. 泛型方法和类型通配符的区别

      3. JAVA7中的菱形语法和泛型构造器

      4. 泛型和数组转换，向上转型object时,需要加instanceof代码判断，防止classCastException

Annotation(注释)

1. JAVA的基本Annottion（注释）注解

   1. @Override：限定重写父类方法，只能修饰方法

   2. @Deprecated：标记已过时，修饰类和方法

   3. @Suppress Waenings：抑制编译器警告

   4. @SafeVarargs：Java7中的堆污染，抑制警告方法和构造器

   5. @FunctionalInterface：JAVA8函数接口为Lambda表达式准备，只能修饰接口

2. JDK元Annotion

   1. @Retention:修饰注解，用于指定注解保留多长时间

      1. RetentionPolicy.CLASS：记录在class文件中,不可获取注解信息，这是默认值

      2. RetentionPolicy.RUNTIME：记录在class文件中，可获取注解信息，通过反射获取

      3. RetentionPolicy.SOURCE：记录只保留源代码中，编译器直接丢弃注解

   2. @Target:用于指定被修饰的注解能用于修饰那些程序单元

   3. @ducumented：被JavaDoc工具提取出文档

   4. @Inherited:指定修饰的注解具有继承性

3. 自定义Annotion

   1. 使用@interface自定义注解，可初始化变量

类加载机制和反射

1. 类加载，连接，初始化

   1. 系统在第一次使用某个类时加载该类，可能采用预加载机制加载某个类

   2. 当调用java命令，会启动Java虚拟机进程，他们都使用一个JVM进程区，处于不同进程的（类变量++。第二次访问内存值不会变化）

   3. 类的加载：当程序使用某个类，类还未加载到内存中，JVM把类加载或者初始化（加载，连接，初始化）、

      1. 加载，JVM提供类加载器加载，通常为系统类加载器，同时可以继承ClassLoader基类创建自定义的类加载器，读入内存中，并生成.class对象

         1. 不同的类加载器，从不同来源加载类的二进制数据（本地文件系统，JAR包，网络，源文件动态编译）

      2. 连接，连接阶段负责把类的二进制数据合并到JRE中，连接分三个阶段

         1. 验证：验证加载的类有正确的内部结构，和其它类协调一致

         2. 准备：负责为类的类变量分配内存，并设定默认值

         3. 解析：将类的二进制数据中的符号引用替换成直接引用

      3. 初始化：主要对类的变量进行初始化

         1. 在JAVA类中对类变量制定初始的俩种方式

            1. 声明类变量时指定初始化

            2. 使用静态初始化块为类变量制定初始值

         2. JVM初始化一个类的主要步骤

            1. 假如这个类还没有被加载和连接，则程序先加载并连接该类

            2. 假如该类的直接父类还没有初始化，则先初始化其直接父类，父类重复执行，Object最先被JVM初始化

            3. 假如类中有初始化语句，系统依次执行这些初始化语句

         3. 类初始化的时机：6种方式使用类或者接口，系统就会初始化

            1. 创建类的实例

               1. 使用New来创建

               2. 通过反射来创建

               3. 通过反序列化方式创建

            2. 调用类方法（静态方法）

            3. 访问某个类或接口的类变量，或为类变量赋值

            4. 使用反射强制创建某个类或接口的Class对象：Class.forName("")

            5. 初始化某个类的子类

            6. java.exe命令运行某个主类

            7. 注意：被final修饰的宏变量使用时不会初始化类，相当于使用常量

2. 类加载器:会标识加载的类不会重复，通过包名判断

   1. 类加载器种类

      1. 根类加载器;加载JAVA核心类，

      2. 扩展加载器：负责加载JRE的扩展目录

      3. 系统类加载器：java命令指定的的JAR包或者类路径

      4. 自定义类加载器:

         1. 扩展ClassLoader子类，重新子类方法实现自定义类加载器

            1. loadClass()，重写实现逻辑复杂

            2. findClass():可以避免类加载器的父类委托，缓冲机制

         2. URL ClassLoader:是系统类加载器和扩展类加载器的父类

   2. 类加载器机制

      1. 全盘负责

      2. 父类委托

      3. 缓存机制

   3. 类加载器加载CLASS的8个步骤，826页

3. 通过反射查看类信息

   1. 程序需要在运行时发现对象和类的真实信息：编译时类型和运行时类型

      1. 假设都知道可以使用instanceof判断，转换成运行的类型变量

      2. 编译时根本无法预知该对象和类属于哪些类，只能依靠运行时信息发现该对象真实信息，必须使用反射

   2. 获得CLASS对象的三个方式:类加载后为该类生成Class对象，通过class对象可以访问JVM中的这个类

      1. 使用Class类的forName（"类名"）方法

      2. 调用某个类的Class属性获取该类对应的Class对象

      3. 调用某个对象的GetClass方法

   3. 从Class对象的方法获取更多信息

      1. 获取Class对应类所包含的构造器

      2. 获取对应类所包含方法

      3. 获取对应类上所包含的Annotation

      4. 对应类包含的内部类

      5. 对应类包含的接口

      6. 对应类的修饰符，所在包，类名

4. 使用反射生成并操作对象

   1. 通过反射创建对象有俩种方式

      1. 使用Class对象的newInstance()方法，要求Class对象有相应的构造器，通过构造器创建默认实例

      2. 先使用class对象获取指定的Constructor对象，在调用Constructor的newInstance()方法创建该类实例，指定构造器创建实例

   2. 调用方法

      1. getMethods()方法返回类对象的Method数组

      2. getMethod()返回Method对象

      3. Object invoke(obj,args)主调，和形参

   3. 访问成员变量值

   4. 操作数组

5. 使用反射生成JDK动态代理

   1. 代理

      1. 代理的概念，中介

         1. a和c之间创建个代理b，a通过b访问c

         2. 实际的例子

            1. 登录，注册有验证码，手机短信就是（联通的关联公司实现）

      2. 代理的作用

         1. 功能增强：在原有基础增加功能，完成方法调用后，可以加增强逻辑

         2. 控制访问：代理到真正的访问地址

      3. 代理的实现

         1. 静态代理：

            1. 优点

               1. 实现简单

               2. 容易理解

            2. 缺点：

               1. 当目标类增多，代理类增多

               2. 实现多个方法时，多个代理类都需要修改

         2. 动态代理：静态代理目标类很多，避免静态代理缺点

            1. 特点

               1. 静态代理目标类即使很多，代理类数目可以很少，修改接口方法时不影响代理类

               2. 创建JAVA对象能力，让你不用创建类，就能创建代理对象

            2. 定义：在程序执行过程中，使用JDK的反射机制，创建代理对象，动态执行执行的代理目标对象

               1. 动态：程序执行时，调用JDK提供的方法才能创建代理对象

   2. JAVA的Reflect包下提供Proxy类和InvocationHandler接口创建动态类

   3. cglib动态代理（了解）：通过继承实现，父类只需要继承就可以了

      1. Spring和mybatic框架都有实现

   4. 动态代理和AOP

6. 反射和泛型

   1. 使用泛型避免了强制类型转换

7. 总结

JAVA高级特性集合框架

1.3 JAVA集合框架的深入原理（待整理）

JAVA多线程和并发编程

1.4 JAVA的多线程编程和锁（待整理）

JAVA异常处理

1.5 JAVA异常处理（待整理）

JAVA的IO流

1.6 JAVA的IO流还需要继续整理

JAVA的新版JDK1.8特性

2.7 JAVA的JDK1.8的新特性（待整理）

面向对补充

一、类的构造

实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

【修饰符：public，final，abstract】class 类名

{

1. 构造器：该类的实例，通过new调用构造器【修饰符】构造器名必须和类相同 【形参】

   1. 修饰符：public，protected，private

2. 成员变量：【修饰符】类型 成员变量名称 【=默认值】；

   1. 修饰符：public，protected，private出现一个搭配static，final组合起来修饰成员变量

   2. 类型可以是基本类型和引用类型

3. 方法：【修饰符】方法返回值类型 方法名（形参裂变）

   1. public，protected，private出现一个，abstract，final组合起来修饰，搭配static（修饰的成员属于类本身），

}

二、包装类：8种基本类型的引用类（为解决8种数据类型的变量不能当作Object类型变量使用问题：方法返回Object类型参数，但实际是具体基本类型）

int和char特殊:对应Integer和Character

自动装箱和拆箱简化

基本变量和String转换，

三、疑难的修饰符的使用

static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！

static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。

因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。

因此比较常见的static应用场景有：

1、修饰成员变量 2、修饰成员方法 3、静态代码块 4、修饰类【只能修饰内部类也就是静态内部类】 5、静态导包

内部类？内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

内部类的优点

我们为什么要使用内部类呢？因为它有以下优点：

一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！

内部类不为同一包的其他类所见，具有很好的封装性；

内部类有效实现了“多重继承”，优化 java 单继承的缺陷。

匿名内部类可以很方便的定义回调。

目前用Lambar代替了使用匿名内部类：

equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

四、常使用的包

java.lang：这个是系统的基础类；Object所有对象的根：八大包装类，String类代表字符串。StringBuffer线程安全，可变的字符序列。StringBuilder一个可变的字符序列。

java.io：这里面是所有输入输出有关的类，比如文件操作等；通过数据流，序列化和文件系统提供系统输入和输出

java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；定义缓冲区，它们是数据容器，并提供其他NIO包的概述。的解码器和编码器

java.net：这里面是与网络有关的类；Socker套接字。

java.util：这个是系统辅助类，特别是集合类；包含集合框架，旧集合类，事件模型，日期和时间设施，国际化和其他实用程序类（字符串tokenizer，随机数生成器和位数组）

java.sql：这个是数据库操作的类。