Java基础知识点总结！精华版！

转载自：https://blog.csdn.net/Song_JiangTao/article/details/80642188如有侵权，请及时联系。本文内容基于jdk1.7文章目录思维导图（完善中...有想一起协作的，请联系我）Java基础概览图1、Java起源2、Java三个平台：3、JavaAPI4、Java语言的特性：5、JDK & JRE & JVM6、配置环境变量（在任

平安喜乐Alice

279人浏览 · 2020-10-30 11:12:36

平安喜乐Alice · 2020-10-30 11:12:36 发布

转载自：https://blog.csdn.net/Song_JiangTao/article/details/80642188

如有侵权，请及时联系。

本文内容基于jdk1.7

文章目录

思维导图（完善中…有想一起协作的，请联系我）

Java基础概览图

在这里插入图片描述

1、Java起源

java Sun公司的，后期被甲骨文收购。
Java之父，詹姆斯高斯林， Java语言早起名字叫做：Oak，由C++演变而来；
Java 版本：jdk6 /7 最常用；

2、Java三个平台：

JavaSE（标准版，用于桌面应用开发）
JavaEE(企业版，用于企业级应用开发)
JavaME（微缩版，用于早期嵌入式开发）

3、JavaAPI

即Java应用程序接口
Java API 1.6中文手册下载
Java API 1.8中文手册下载 提取码：y1f9
常用API
- StringBuffer和StringBuilder用法
  - StringBuilder(线程不安全)/StringBuffer(线程安全)是可变长度字符串
  - 使用append方法拼接字符串，效率高
  - 默认有16位缓冲区
  - 使用capacity方法获取真实长度，length方法获取字符个数； append方法拼接字符串；
  - S t r i n g 类型和 S t r i n g B u f f e r 的主要性能区别： \color{red}{String 类型和StringBuffer的主要性能区别：}String类型和StringBuffer的主要性能区别：
    - String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。
    - 使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。
    - 在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。
      - 性能效率：StringBuilder>StringBuffer>String。
- Math相关
  - round(double d) 四舍五入取整返回long/int
  - floor(double d) 向下取整返回double
  - ceil(double d) 向上取整返回double
  - abs(double/int )获取绝对值
  - random()获取0-1之间随机小数，大于等于 0.0 且小于 1.0
- Random随机数
  - nextInt(int i)获取0-i之间的随机整数边界：[0,i)
  - nextDouble()获取0-1之间随机小数，边界：[0.0d,1.0d)
- java.math.BigDecimal
  - 比double更精确的一种类型；常用于操作金额，汇率等；
  - 常用方法：
    - add
    - subtract
    - multiply
    - divide
    - setScale
- SimpleDateFormat用法
  - format(日期对象) 将日期格式化为指定格式字符串
  - parse(指定格式的日期字符串)将字符串转为Date 注意：格式必须跟SimpleDateFormat指定格式一致否则：ParseException
- java.util.Date
  - 将1999-10-10格式字符串转为日期对象
  - new Date()获取当前系统时间
  - getTime()获取毫秒数
- java.sql.Date
  - 只用于获取系统当前时间
- Calendar
  - 在Calendar类中，月份的值为实际的月份值减1
  - 获得的星期的值和Date类不一样。在Calendar类中，周日是1，周一是2，周二是3，依次类推
    
    总之多查 A P I \color{red}{总之多查API}总之多查API

4、Java语言的特性：

面向对象、
可移植性（一处编译，多处执行）、
跨平台性、
安全性(1、摒弃指针 2、GC垃圾回收机制：自动释放回收长时间不使用对象的内存)、
- 点击深入了解GC
并发性(支持多线程)、

5、JDK & JRE & JVM

JDK(Java Development Kit Java开发工具包)，JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)、执行工具(java.exe)等
JRE(Java Runtime Environment Java运行环境) ，包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
JVM (Java Virtual Machine) 是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。
JDK，JRE，JVM的关系

6、配置环境变量（在任何位置都可以找到java环境）

最简单配置方式：
- 系统环境变量：PATH：C:\Program Files\Java\jdk1.7.0_13\bin; 后面保留
- CLASSPATH：C:\Program Files\Java\jdk1.7.0_13\lib;.后面保留
或者：
- PATH: %JAVA_HOME%\bin;
- CLASSPATH:%JAVA_HOME%\lib;.
也可以设置JAVA_HOME
JAVA_HOME :C:\Program Files\Java\jdk1.7.0_13

验证是否配置成功：进入命令行窗口，执行java -version，成功显示版本号即成功配置

7、开发工具：

Eclipse
MyEclipse
IntelliJ IDEA

8、Java程序的执行过程

java源文件，编译器(javac命令)进行编译
生成class文件(存放的字节码)
然后解析器（执行java命令）解析class文件
最后生成计算机识别的二进制编码

9、Java有两种数据类型：

1、引用数据类型： 数组、类、接口。
2、基本数据类型：
- 整型：byte、short、int、long （8位1个字节、16/2 、32/4、64/8）
- 浮点型：float、double(32/4 、64/8)
- 字符型：char(16/2)
- 布尔类型：boolean
级别从低到高为： byte,char,short(这三个平级)–>int–>float–>long–>double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；

Java中默认整数为int类型，小数为double类型；
字符char是否可以存放一个汉字？可以，因为一个字符占2个字节，一个汉字两个字节；
整型初始值默认0 浮点型默认0.0 布尔类型默认false 引用数据类型默认null

10、java中是否有goto？有，是保留字

11、标识符命名规则：

可以由数字、字母、下划线、$符号组成，但是不能是关键词，不能以数字开头
全局变量(成员变量、类变量)
- 可以供当前类的多个方法使用；
- 定义在类中；
- 成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。
局部变量
- 定义在方法中或者方法参数
- 只能作用于当前方法
- 没有初始值
- 局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。
常量： 只能声明在类中，使用final关键词声明，必须赋初始值，不能再次赋值；

12、Java中数据类型转换：

隐式转换： 系统默认将其转换为我们需要的数据类型；
强制转换：=号两边数据类型不同时，可以通过,前面加(类型)转换
- 例如：int j=10;float f=100.123; int j=(int)f;
基本数据类型之间规则：
- (1)整型之间数据类型强制转换规则：long->int->short->byte
- (2)浮点型之间：double->float
- (3)char和整型 : 整型->char
- (4)char和浮点型: 浮点型->char
- (5)浮点型和整型 : (double/float)->(long/int/short/byte) 且小数点舍去

13、运算符：

+
-
*
/
%
- 任何整数模2不是0就是1， 所以只要改变被模数就可以实现开关运算。
位运算符:用于操作二进制位的运算符。
- & | ^ << >> >>>(无符号右移)
注意：
- (1)+号拼字符串：“字符串”+数字+数字和"字符串"+(数字+数字)
- (2)分母不可以为0 否则报异常：ArithmeticException
- (3)java中数值运算时，位数多的与位数少的，做运算，最终结果类型为位数多的（long+double 返回double）整型和浮点型运算，此时返回浮点型
- (4)j a v a 中 1 / 2 值为多少？ 0 \color{red}{java中1/2值为多少？0}java中1/2值为多少？0
- (5)2 的三次幂如何计算？ 2 < < 2 ; \color{red}{2的三次幂如何计算？ 2<<2;}2的三次幂如何计算？2<<2;
i++ 表示i先参与运算，然后在自身加1
++i 表示i先自身加1，然后在参与运算

记忆技巧：i在前先运算。在后后运算

类似的 --i，i--运算也是一样的

注意 ! \color{red}{注意!}注意! 下面程序是否有错？

short i=10; i=i+1;(错误，因为需要强转 short+int结果还是int类型) i+=1;（正确）
逻辑运算符（也叫作短路运算符）：
- ||
  
  或，两边条件有一个满足true，则结果为true
- &&
  
  与， &&两边条件必须返回boolean类型，两边同时为true则结果为true
例如：
```
int n=10;
int m=100;
boolean f_2=(n>m)&&((n=100000)<100); 
System.out.println(n);//n的值还是10
boolean f_3=(m>n)||((n=100000)<100); //n的值还是10
```
- 1
- 2
- 3
- 4
- 5
下表为优先级顺序，优先级高的在上部，同一行优先级相同
第三行中的“+”“-”为正负的含义

14、判断语句&循环语句break&continue

判断语句
- if(条件){}
- switch选择判断语句点击查看更多
循环语句
- for(;条件;){循环体}
- while(){}
- do{}while()
break 表示退出整个循环或者判断
continue 只能用于循环体中，表示退出当前循环，继续下一次循环

15、Java的核心包：即java.lang包

lang包下的String类，是不可以被继承的
在这里插入图片描述
查API可以发现，String类是final类

16、包装类：即基本数据类型所对应的类；

int/double/float/byte/long/char/boolean 是一种值表示；
Integer/Double/Float/Byte/Long/Character/Boolean 包装类
常用方法：
- valueOf("")
- valueOf(int i)
- toString（）
- parseInt("");
- 注意异常 ! \color{red}{注意异常!}注意异常! NumberFormatException

17、==比较和equals比较

==比较即比较内容也比较地址是否相同；
equals方法，比较两个对象内容是否相同

注意：

（1）字符串比较，不允许用== ，只能通过equals方法

（2）如果Integer和Integer/int比较具体是否相等，此时绝对不允许使用==

补充：127 128 问题：

Integer a = 127;
Integer b = 127;
System.out.println(a==b);true
//超一个字节会重新分配空间
Integer c = 128;
Integer d = 128;
System.out.println(c==d);false

（3）注意：数字，和字符串比较是否相等；

String str="10";
Integer m=10;

System.out.println(m.equals(str));//false
System.out.println(m.toString().equals(str));//true

更多详情点击查看第5点

18、数组：

先定义、开辟空间、赋值在使用
java中数组长度不可变
数组下标从0开始
数组的定义：
- （1） String[] items_0=null;//先定义 items_0=new String[4];//开辟空间
- （2）String[] items_1=new String[4];
- （3）String[] items_2={"JONES","SMITH","XIAOMING","SMI"};
- （4） String[] items_3=new String[]{"SMITH","JINES","DSFDSF"};
如何不通过第三个变量交换两个变量的值？ \color{red}{如何不通过第三个变量交换两个变量的值？}如何不通过第三个变量交换两个变量的值？
```
int a=10;
int b=20;
a=a+b;//a:30 b:20
b=a-b;//a:30 b:10
a=a-b;//a:20 b:10
```
- 1
- 2
- 3
- 4
- 5

二维数组：

String[][] items=new String[2][3];
//items[0]={"","",""};错误的
// items[0]=new String[4];对

数组的复制
- System.arraycopy(strArr,0, strArr1, 0, 3);//从左到右参数意义：从哪个数组，从哪开始复制，复制到哪？开始位置，复制多长
- System.out.println("copyOf复制："+Arrays.toString(Arrays.copyOf(strArr, 3)));
数组的排序
- Arrays.sort(strArr1);

19、类：是一类事物的描述，程序中为class；

属性：即一类事物具有的共有特点或者特性；程序中为全局变量（成员变量)
方法：一类事物具有的动作；
类的定义和使用
- class 类名称{
  属性
  方法
  }
- 使用关键字new就可以创建类对象，使用对象.方法，对象.属性就可完成调用
- 创建一个对象都在内存中做了什么事情？ \color{red}{创建一个对象都在内存中做了什么事情？}创建一个对象都在内存中做了什么事情？
  - 1：先将硬盘上指定位置的class文件加载进内存。
  - 2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。
  - 3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new
  - 4：在该实体空间中进行属性的空间分配，并进行了默认初始化。
  - 5：对空间中的属性进行显示初始化。
  - 6：进行实体的构造代码块初始化。
  - 7：调用该实体对应的构造方法，进行构造方法初始化。（）
  - 8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)
抽象类: abstract
- 抽象类的特点：
  - 1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
  - 2：抽象方法只定义方法声明，并不定义方法实现。非抽象的方法可以定义方法实现
  - 3：抽象类不可以被创建对象(实例化)。
  - 4：只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
- 抽象类的细节：
  - 1：抽象类中是否有构造方法？有，用于给子类对象进行初始化。
  - 2：抽象类中是否可以定义非抽象方法？可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象方法。而且比一般类少了一个创建对象的部分。
  - 3：抽象关键字abstract和哪些不可以共存？final ,private , static
  - 4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
  - 5：抽象类中可以有普通的成员变量
  - 6：抽象类中可以有静态方法
接口：interface
- 接口的特点：
  - 1、接口是特殊抽象类，所有方法都是抽象方法，都是public访问权限，数据成员都是public，static，final 注意：1.8以后接口中是可以定义普通的方法，也是可以有方法体的
  - 2、不能被实例化，方法abstract关键词可以省略，但实际上还是抽象方法
  - 3、变量都是是常量，省略final关键词；
  - 4、接口不能被实例化，只能通过implements来实现接口，一个实现类，可以实现多个接口
  - 5、接口可以继承接口。
  - 6、实现以后要重写所有抽象方法，包括接口继承接口中的抽象方法
  - 7、接口中不能有构造方法
- 接口的好处：
  - 1、java由于单继承，接口可以弥补无法多继承的缺点
  - 2、好的程序要求高内聚低耦合，接口可以实现程序的解耦
  - 3、定义一种规范
抽象类和接口的区别：
- 抽象类只能被继承，而且只能单继承。
- 接口需要被实现，而且可以多实现。
- 抽象类中可以定义非抽象方法，子类可以直接继承使用。
- 接口中都有抽象方法，需要子类去实现。
- 抽象类使用的是 is a 关系。
- 接口使用的 like a 关系。
摘自java编程思想

- 抽象类的成员修饰符可以自定义。 - 接口中的成员修饰符是固定的。全都是public的。
- 抽象类可以有构造方法，接口中不能有构造方法
- 抽象类中可以有普通成员变量，接口中没有普通成员变量

面向对象：面向对象是一种思想，是基于面向过程而言的，面向对象即分析某一个事件中有哪些对象，分析他们的动作，具有的属性特点，通过这种方式来解决问题；
面向过程：侧重点在于步骤，通过一步一步调用方法来实现操作

面向对象的问题详情请点击查看第1点！

对象实例化： new 类（），即对象的创建；

20、static

static 声明方法为静态方法（静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）），声明属性为静态属性；
static 关键词：
- 1、static 修饰方法，该方法叫做静态方法（也叫做类方法），可直接通过这个类的类名打点直接调用；
- 2、静态方法中不能使用this/super关键词，静态方法不能直接调用当前类中的非静态方法（或非静态属性），必须通过new实例化后在调用。
- 3、static声明的方法和属性，该对象已经被实例化，且只能被实例化一次(单例模式)
- 4、static修饰的属性，被相同类的不同实例所共享；
成员变量（没有特殊修饰）和静态变量的区别：
- 1、生命周期的不同：
  成员变量随着对象的创建而存在随着对象的回收而释放。
  静态变量随着类的加载而存在随着类的消失而消失。
- 2、调用方式不同：
  成员变量只能被对象调用。
  静态变量可以被对象调用，也可以用类名调用。（推荐用类名调用）
- 3、别名不同：
  成员变量也称为实例变量。
  静态变量称为类变量。
- 4、数据存储位置不同：
  成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据。
  静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

21、this

this关键字只能在方法内部使用，表示对“调用方法的那个对象的引用”

表示当前类的对象， \color{red}{表示当前类的对象，}表示当前类的对象，不能用于static声明的方法中， 常用于区分全局变量和局部变量同名

22、super

（1）使用super关键字, s u p e r 代表父类对象 \color{red}{super代表父类对象 }super代表父类对象，只能用在子类中
（2）可在子类构造方法中调用且必须是该方法中第一句
（3）不能使用在static修饰的方法中
（4）super的用处
- 访问父类构造方法
  - super();
  - super(name);
- 访问父类属性
  - super.name;
- 访问父类方法
  - super.print();

23、final

1.修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。
2.修饰方法

下面这段话摘自《Java编程思想》第四版第143页：

使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。

因此，如果只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final的。

注：类的 p r i v a t e 方法会隐式地被指定为 f i n a l 方法。 \color{blue}{注：类的private方法会隐式地被指定为final方法。}注：类的private方法会隐式地被指定为final方法。
3.修饰变量

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

更多细节访问点击这里

24、访问修饰符：

这里写图片描述

25、面向对象三个过程：

OOA面向对象分析
OOD面向对象设计
OOP面向对象编程

26、面向对象三个特性(属性)

继承
- 继承就是类之间的继承，使用extends来实现，从而实现代码的复用
多态
- 某一种事物有不同的具体的体现就是多态。
- 多态体现在：重写、重载、对象实例化。
- 多态的好处：提高了程序的扩展性。
- 多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
封装
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 好处：将变化隔离；便于使用；提高重用性；安全性。
- 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

27、构造方法

该方法与类名相同；没有返回值也不可以使用void 声明
默认public修饰
任何一个类，都有一个无参数的构造方法；对象实例化时被执行
构造方法和普通方法的区别
- 构造方法是在对象创建时，就被调用，构造方法常用于初始化成员变量，而且初始化动作只执行一次。
- 一般方法，是对象创建后，需要调用才执行，可以被调用多次。

如果说你编写了自己的构造方法，那么必须编写默认的无参构造方法 \color{red}{如果说你编写了自己的构造方法，那么必须编写默认的无参构造方法}如果说你编写了自己的构造方法，那么必须编写默认的无参构造方法

引用Java编程思想中的片段：

class Bush {
	Bush(int i) {}
	Bush(double d) {}
}

现在，假若使用下述代码：

new Bush();

编译程序就会报告自己找不到一个相符的构建器。就好象我们没有设置任何构建器，编译程序会说：“你看来似乎需要一个构建器，所以让我们给你制造一个吧。”但假如我们写了一个构建器，编译程序就会说：“啊，你已写了一个构建器，所以我知道你想干什么；如果你不放置一个默认的，是由于你打算省略它。”

28、程序的执行过程

单一类中：
- 1.初始化块2. 静态初始化块3.构造方法
- 执行顺序： 静态初始化块（永远只被执行一次）初始化块构造方法
父类和子类中都有静态代码块，非静态代码块，构造方法时。
- 初始化子类对象时，调用顺序： 父类静态，子类静态，父类非静态，父类构造，子类非静态，子类构造
静态域
- 其实最先初始化的并不是静态块，而是静态域，而静态域中包含静态变量、静态块和静态方法，其中需要初始化的是静态变量和静态块。而他们两个的初始化顺序是靠他们俩的位置决定的!
例如：
```
public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
测试结果：构造块构造块静态块构造块

29、方法重载：overload

当前类中方法名相同，参数个数或者参数类型不同；
public String student(String name,int age){…}
public void student(int age,String name){…}
这个也是重载
为什么重载，重载有什么好处？
- 了解：好处便于记忆筛选，体现了java的多态

30、方法重写：override

发生在子类中，子类的方法与父类方法名、参数个数、参数类型，返回值类型完全相同，并且访问权限不能严于父类
什么时候使用重写？
1、当父类方法无法满足子类需求，此时可以在子类中重写父类方法
2、如果开发时，需要对父类方法功能拓展，此时还不想修改父类程序
则使用继承(定义一个类继承父类)，然后通过子类重写该方法，
然后其他类进行调用这个子类方法；

31、继承：

子类继承父类，可以继承父类中非私有的方法和属性；
构造方法无法被继承；
final修饰的类无法被继承；
Java中是单继承，所有类的超类（父类/基类）是java.lang.Object类
如果一个类既继承了一个类又实现了接口，那么次序是，先继承，后实现！！ \color{red}{如果一个类既继承了一个类又实现了接口，那么次序是，先继承，后实现！！}如果一个类既继承了一个类又实现了接口，那么次序是，先继承，后实现！！
子类被实例化时，先实例化父类对象
- java中是单继承，即一个类只能有一个父类；所有类的父类（超类）是java.lang.Object
- 继承的好处：
  - 1、简化子类代码
  - 2、使用继承可以不修改父类程序前提，完成对父类方法的拓展
- 缺点：
  - 1、打破了封装（封装的目的是隐藏），父类向子类暴露了细节
  - 2、过多的继承，会导致程序不便于维护
  - 3、白盒重用，因为基类的内部细节通常对子类是可见的

32、所有类的父类Object类

Object位于java.lang包下面
其中常用的方法有：
- toString(); 返回当前对象本身的有关信息，按字符串对象返回
- equals(); 比较两个对象是否是同一个对象，是则返回true
- hashCode(); 返回该对象的哈希代码值
- getClass(); 获取当前对象所属的类信息，返回Class对象
equals方法的重写：
- 什么时候重写equals方法？
  - 比较两个对象时候，需要重写equals方法，重新定义比较规则
toString方法重写：
- 重写toString方法的目的是：让对象以某个字符串形式表示

33、主方法的分析

public static void main(String[] args){}
1）保证该类的独立运行。
2）它是程序的入口。
3）它被jvm调用。
- Public：访问权限最大。
- static：不需要对象，直接类名即可。
- void：主方法没有返回值。
- main：主方法特定的名称。
- (String[] args)：主方法的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。
注意：主方法的存在，仅为该类是否需要独立运行，如果不需要，主方法是不用定义的。

34、Java内存的总结

java分了5片内存
- 1：寄存器。
- 2：本地方法区。
- 3：方法区。
- 4：栈。
- 5：堆。
栈：存储的都是局部变量 ( 方法中定义的变量，方法上的参数，语句中的变量 )；只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
- 1：每一个实体都有内存首地址值
- 2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
- 3：垃圾回收机制。

35、自动装箱，自动拆箱

Java有8种基本类型，每种基本类型又有对应的包装类型。在Java中，一切都以对象作为基础，但是基本类型并不是对象，如果想以对象的方式使用这8中基本类型，可以将它们转换为对应的包装类型。基本类型和包装类型的对应
可以直接将整型赋给Integer对象，由编译器来完成从int型到Integer类型的转换，这就叫自动装箱。
与此对应的，自动拆箱就是可以将包装类型转换为基本类型，具体的转换工作由编译器来完成。
其他几种基本类型的转换也是类似的

36、异常和错误

异常
- 异常即exception
- 异常：可以预知、可以通过修改程序来弥补"错误",可避免的
错误
- 错误：error
- 错误：无法预知的，系统级别的，程序员修改程序是无法修复的；例如：系统宕机，JVM挂掉了
Java中的异常
异常的种类：
- 1、编译时异常(非运行时异常)
  - 程序编译过程中产生的，如果有异常，则不会通过编译，必须手动的捕获异常或者继续抛出该异常；
- 2、运行时异常：
  - 程序在运行过程中产生的，不需要手动抛出或者捕获，系统自动报出；
  异常种类及其介绍详情，第9点
异常的处理
- 功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个。
- 特殊情况：try对应多个catch时，如果有父类的catch语句块，一定要放在下面。
throws 和throw
- throws 方法声明时使用，表示该方法可能产生的异常，抛出，谁调用谁捕获处理，throws用在函数上。
- throw方法体中使用，表示抛出一个具体的异常对象，谁调用谁捕获处理，throw用在函数内。
catch中存在return，此时finally中是否被执行?执行，但是finlly外面程序不会继续执行

37、泛型

了解泛型：泛指一种某一种数据类型；

一些常见符号的含义：

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

T - Type（Java 类）

K - Key（键）

V - Value（值）

N - Number（数值类型）

？ - 表示不确定的java类型

S、U、V - 2nd、3rd、4th types

Object跟这些标记符代表的java类型有啥区别呢？

Object是所有类的根类，任何类的对象都可以设置给该Object引用变量，使用的时候可能需要类型强制转换，但是用使用了泛型T、E等这些标识符后，在实际用之前类型就已经确定了，不需要再进行类型强制转换

Java泛型深入理解

38、集合

对线性表，链表，哈希表这些常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。因此，我们一般的程序员不必自己开发相关的方法
集合（框架）：java提供了一组对数组、链表数据结构操作的API，这组API即集合；存在于java.util
Collection接口有两个子接口：
- Set 接口有两个常用实现类：
  - 1、TreeSet
    - 基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。(来自jdk1.6)
      - 自然排序：
        >自然排序就是按字母书序排序，
        比如 a->b->c…
        0->1->2->3…
        如果是字符串那么会按一个个的字母排序如果相等就比较下一个位置的字符，知道比出大小位置
        比如 abc->acd->ace->ade…
  - 2、HashSet(Set最常用的实现类)
    - 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。(来自jdk1.6)
  - Set接口特点：
    - Set 接口数据不重复（使用HashMap实例存储的，将存储对象作为key，通过equals方法比较，以及hashcode确认是否相同)
    - Set 接口数据无序；
  - 常用方法：add(E e)添加元素， iterator()获取迭代器
- List 接口有三个常用实现类
  - 1、ArrayList
    - List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。 (来自jdk1.6)
  - 2、LinkedList
    - List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。 (来自jdk1.6)
  - 3、Vector
    - Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。 (来自jdk1.6)
  - List接口的特点：
    - 数据有序，数据允许重复的集合
    - LinkedList:链表实现，插入，删除元素效率高，查询效率低，线程不安全
    - ArrayList:数组实现, 插入，删除元素效率低，查询效率高，线程不安全
    - Vector:数组实现，线程安全
  - 常用方法：
    - add(对象)添加元素
    - get(下标)默认从0开始，获取元素
    - remove(int index) remove(Object obj) 根据下标或者元素移除某一个对象
    - addAll(Collection cl)将某个集合中元素，合并到当前集合中
    - size()该集合长度 contains(Object obj)判断某个元素在该集合中是否存在
- 将 L i s t 集合转为数组 ? \color{red}{将List集合转为数组?}将List集合转为数组?
  - list.toArray()
- 将数组转为 L i s t 集合 ? \color{red}{将数组转为List集合?}将数组转为List集合?
  - Arrays.asList(objct …a)
Map接口有两个常用实现类：
- HashMap
  - 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。(来自jdk1.6)
- HashTable
  - 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。 (来自jdk1.6)
- map接口的特点
  - Map接口不是Cllection的子接口
  - Map实现：key value 键值对形式存储数据
  - HashTable:键值对不能为空，线程安全，效率低
  - HashMap:键值对可以为空，线程不安全，效率高
- 常用方法
  - boolean containsKey(Object key) //测试指定对象是否为此哈希表中的键。
  - put(key,value)//存放数据
  - get(key)//获取元素
  - m a p 效率 “ 最高 ” 的遍历方式： \color{red}{map效率“最高”的遍历方式：}map效率“最高”的遍历方式：(在java8以后可以利用stream来遍历)
```
Set<Map.Entry<String, Object> > entrySet=map.entrySet();
Iterator<Map.Entry<String, Object>> ite=entrySet.iterator();
while(ite.hasNext()){
	Map.Entry<String, Object> obj= ite.next();
	String key=obj.getKey();
	Object value=obj.getValue();
	System.out.println(key+":"+value);
}
```
    - 1
    - 2
    - 3
    - 4
    - 5
    - 6
    - 7
    - 8

39、IO流

流：
- 流是一组有序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。
Java中流的分类：
- 按照数据流向分：
  - 输入流：相对于内存，向内存中写入；
  - 输出流：相对于内存，从内存往外读；
- 按照流的数据传输的格式：
  - 字节流：以字节为单位读取；一般用于读写文件,读写诸如图象或声音等的二进制数据。
  - 字符流：以字符为单位读取；一般用于读写文件中文本内容

40、XML解析

XML是一种可拓展文本标记语言；
常用于：数据存储、作为项目配置文件，系统之间数据传输的某种数据格式；
解析方式有：
- DOM
  - jdk自带的解析方式，事件驱动，不灵活，解析大文件效率低
- SAX
  - jdk自带的解析方式，树形结构方式解析操作xml，灵活，大文件效率高
- JDOM
  - 第三方工具包
- DOM4J：第三方工具包，最常用的一种解析方式
  - DOM4J教程补充！

41、JDBC数据库连接

java提供的一组操作数据库的API；
常用接口有：
- Connection、
- ResultSet、
- PreparedStatement、
- Statement
常用数据库驱动程序和url格式
- Oracle数据库:
  - 驱动程序包名：ojdbc5.jar
    - 驱动程序包名有可能会变
  - 驱动类的名字：oracle.jdbc.driver.OracleDriver
  - JDBC URL：jdbc:oracle:thin:@d b i p \color{red}{dbip}dbip:p o r t \color{red}{port}port:d a t a b a s e n a m e \color{red}{databasename}databasename
    - JDBC URL中黑色字体部分必须原封不动的保留，为该驱动识别的URL格式。红色字体部分需要根据数据库的安装情况填写。其中各个部分含义如下：
      - dbip 为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1
      - port 为数据库的监听端口，需要看安装时的配置，缺省为1521
      - databasename 为数据库的SID，通常为全局数据库的名字
      - 例如：jdbc:oracle:thin:@localhost:1521:XE
- Mysql数据库
  - 驱动程序包名：mysql-connector-java-5.1.26-bin.jar
    - 说明：驱动程序包名有可能会变
  - 驱动类的名字：com.mysql.jdbc.Driver
  - JDBC URL：jdbc:mysql://d b i p \color{red}{dbip}dbip:p o r t \color{red}{port}port/d a t a b a s e n a m e \color{red}{databasename}databasename
    - JDBC URL中黑色字体部分必须原封不动的保留，为该驱动识别的URL格式。红色字体部需要根据数据库的安装情况填写。其中各个部分含义如下：
      - dbip –为数据库服务器的IP地址，如果是本地可写：localhost或127.0.0.1
      - port –为数据库的监听端口，需要看安装时的配置，缺省为3306
      - databasename –数据库的名字。
      - 例如：jdbc:mysql://localhost:3306/XE
下面是一般的jdbc连接执行流程代码示例
- 加载驱动
- 打开连接
- 执行查询
- 处理结果
- 清理环境
```
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JDBCtest {

    public static void main(String[] args) {
        String sql = "SELECT * from student";
        // 当前的数据库链接；
        Connection connection = null;
        // 用于向数据库发送sql语句
        Statement statement = null;
        // 结果集，封装了从数据库查询的数据
        ResultSet resultSet = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/dbName", "root", "password");
            statement = connection.createStatement();
            resultSet = statement.executeQuery(sql);
            while (resultSet.next()) {
                System.out.print(resultSet.getInt("id") + " ");
                System.out.print(resultSet.getString("name") + " ");
                System.out.print(resultSet.getString("password") + " ");
                System.out.print(resultSet.getString("email") + " ");
                System.out.println();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                resultSet.close();
                statement.close();
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    }

}
```
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44