JAVA基础知识点总结（新手开发必备）

Java

配置开发环境：

1. 安装JDK。
   1. JDK:可以开发，编译及运行JAVA应用程序的工具。
   2. JRE:可以运行JAVA应用程序的工具。
2. 环境变量：不区分大小写，环境变量使用半角的分号分隔。
   1. Path:JDK的bin路径。
   2. Classpath:一个点
3. 开始运行cmd
   1. java -version
   2. javac

1. JavaSE(J2SE)
2. JavaEE(J2EE)
3. JavaME(J2ME)

1. 类名：首字母大写，其它均为小写。如果由多个单词组成，每个单词首字母大写，其它均为小写。Person,User
2. 变量名：均为小写。如果由多个单词组成从第二个单词开始，每个单词首字母大写其它均为小写。userName,password
3. 方法名：命名规则与变量名一致。selectEmpById();
4. 包名：均为小写。oracle.jdbc.driver.OracleDriver
5. static final修饰的常量：均为大写，如果由多个单词组成，每个单词之间使用下划线分隔。
6. 泛型名：一个大写字母。

1. Java的数据类型：只有两种类型：基本数据类型、引用数据类型（应用数据类型都是对象）。
2. 基本数据类型：8种
   1. 整数：Java中没有无符号的数字。Java可以表示十进制，八进制的整数 (用0开头),十六进制的整数(用0X或0x开关)，用0b开头可以表示二进制，1.7版本加入的。
      1. byte:1个字节，-27—27-1
      2. short:2个字节，-215—215-1
      3. int:4个字节，-231—231-1，Java中整数默认为int类型。
      4. long:8个字节，-263—263-1，在整数的后面加L或l表示long。
   2. 浮点数：浮点数进行算术运算时会产生误差（缺点）。
      1. float:4个字节，在浮点数的后面加F或f。
      2. double:8个字节。Java中浮点数默认为double类型。
   3. 字符类型：char,值必须出现在单引号中。单引号中只能有一个字符。Java使用Unicode字符集。所有字符均为两个字节。
   4. 布尔类型：boolean。只有两个值：true/false。Java中boolean类型不能转换为其它类型。
   5. 
      
3. 变量
   1. 格式：数据类型 变量名[=值];
   2. Java是强类型的语言（声明变量的时候必须给变量有类型）。
   3. 标识符（类名，变量名，方法名，包名等）命名规则：
      1. 标识符只能由字母，数字，下划线，美元符组成。
      2. 不能使用数字开头。
      3. 不能使用关键字（Java中关键字均为小写）。Goto,const都是java的关键字
   4. 当变量没有赋值时，变量不能使用。否则编译失败。
   5. 同一个范围中不能出现同名的变量。
4. 常量（最终变量）
   1. 使用final关键修饰的变量。
   2. 常量：只能赋值一次。
5. 基本数据类型的类型转换
   1. 基本数据类型比较大小：先比较精度（小数位），如果精度相同时，比较字节数。
   2. 自动转换：Java会自动将小类型的数据转换为大类型的类型。
   3. 手动转换：使用手动的方法将大类型的数据转换为小类型的数据。
6. 运算符：
   1. 算术运算符：+，-，*，/，%（取余数），++，--
      1. 算术运算结果的类型：
         1. 当参与算术运算的元素类型相同时，结果的类型一定与参与运算元素的类型保持一致。
         2. 当参与算术运算的元素类型不相同时，结果的类型与参与运算元素中大类型的元素的类型相同。
      2. ++/--
         1. ++/--可以出现在变量的前面或后面。
         2. 无论++/--出现在变量的前面/后面，代码执行后变量一定会加1/减1。
         3. ++/--出现在后面时：先取值，再运算。
         4. ++/--出现在前面时：先运算，再取值。
   2. 比较运算符：>,>=,<,<=,==(判断是否相等),!=
      1. 比较运算的结果一定为boolean类型。
      2. Java中不是所有的数据类型都可以使用比较运算符进行比较运算。如：基本数据类型与引用数据类型。boolean不能与其它类型进行比较运算。
   3. 逻辑运算符：结果一定为boolean类型。
      1. 逻辑与(&),逻辑或(|)

• • 2. 短路与（&&，当第一个表达式为false时，不执行第二个表达式，直接返回false）短路或（||，当第一个表达式为true时，不执行第二个表达式，直接返回true）
    3. 逻辑非：!，取反。
  • 三元运算符：x ? y : z ;当x为true时，返回y的值。当x为false时，返回z的值。
• 接收用户输入：java.util.Scanner类。
• 流程控制
  1. 顺序结构，选择结构，循环结构
  2. 选择结构：if语句，switch语句
  3. if语句
     1. 格式

• 2. if语句条件的结果必须为boolean类型。
  3. 一个if语句中可以有0个或多个else if语句。
  4. 一个if语句中可以有0个或1个else语句。
  5. else语句必须出现在if语句的最后。
  6. 当if语句匹配到一个分支后，不再匹配其它的分支，直接跳转到if语句的结束。
  7. if语句的大括号可以省略，如果省略if语句的作用范围只有一行Java代码。
• switch语句
  1. 格式：

• 2. case后面的值不能重复。
  3. case后面只能为常量或字面值。
  4. case后面可以为表达式。
  5. switch中的变量只能为byte,short,char,int。从JDK1.5开始可以使用枚举。从JDK1.7开始可以使用String。
  6. 当switch匹配到一个分支后，会从此分支开始自顶向下执行所有的分支，直到switch的结束或遇到第一个break为止。
  7. default的功能与if中的else是一致的。
  8. default可以出现在switch语句的任意位置。
  9. 无论default出现在哪，switch都会先匹配所有的case分支，当没有匹配到任何case分支时，switch才会匹配并执行default分支。
• 循环结构：while循环，do..while循环，for循环
  1. while循环
     1. 格式:

• 2. while循环条件的结果必须为boolean类型。
  3. 通常，不确定循环次数时建议使用while循环。
  4. while循环：先判断，再循环。
• do..while循环
  1. 格式:

• 2. 循环条件的结果必须为boolean类型。
  3. 大括号不能省略，必须以分号表示结束。
  4. do..while循环：先循环，再判断，至少会循环一次。
• for循环
  1. 格式:

• • 2. for循环的三部分都可以省略。
    3. 第一部分声明的变量是循环中的局部变量，在循环外不能使用。
    4. 第一部分可以声明多个类型相同的变量。
    5. 当确定循环次数时，建议使用for循环。
  • 中断循环：
    1. break:不能单独使用，只能出现在switch或循环语句中。在循环中的作用：立即结束所在循环。
    2. continue:不能单独使用，只能出现循环语句中。作用：使所在循环立即结束本次循环，直接执行下一次循环。
• 一维数组：
  1. 数组：多个类型相同数据的集合。
  2. 声明一维数组：在栈中开辟一个空间，用于保存数组的引用。声明数组时不能指定数组的长度。
     1. 格式：数据类型[] 数组名;/数据类型 数组名[];
  3. 创建一维数组：在堆中开辟连续的空间，用于保存数组的元素。创建数组时必须指定数组的长度。

• 4. Java中数组都是引用数据类型。但数组中的元素可以为基本数据类型，也可以为引用数据类型

• 5. 通过下标访问或设置数组中的元素。下标从0开始，最大下标：数组长度减1.
  6. 使用.length属性获得数组的长度。
  7. 数组的长度确定后不能修改。
  8. 数组的长度可以为0，但不能为负数。
  9. 数组的默认值：byte,short,int默认为0，long默认为0L，float默认为0.0F，double默认为0.0，char类型默认为’\u0000’（表示一个空字符），boolean默认为false，引用数据类型默认为null。
  10. 数组与循环
      1. foreach循环：遍历集合，不能向集合中放数据，只能取数据。因为foreach没有下标。
         1. 格式：

• • 2. 通常用于从集合中取数据。
• 与数组相关的工具类：java.util.Arrays类

1. 类中的成员
   1. 成员变量（全局变量，属性，字段，域等）：在类中直接声明的变量。用于描述类的特征。
   2. 成员变量有默认值（与数组的默认值一致），所以成员变量可以直接使用。

• 3. new关键字：在堆中开辟空间，创建类的实例（对象）。
  4. 成员方法：用于描述类的行为（动作）。
     1. 基本格式：

• 2. 如果方法不需要返回类型，使用void关键字表示。
  3. return关键字：
     1. 结束方法。当方法没有返回类型时，也可以使用return关键字结束方法。
     2. 返回数据。
• 方法的重载：在类中有多个名字相同，但参数不同的方法。参数不同：个数不同，类型不同，顺序不同。
  1. 方法的重载与访问权限和返回类型无关。
• 方法参数的传递：实参会将栈中的内容传递给形参。
  1. 形参为基本数据类型：实参将栈中的值传递给形参。形参改变，实参不变。
  2. 形参为引用数据类型：实参将栈中的引用传递给形参。形参改变，实参通常都会改变。
• 构造方法（构造器）
  1. 构造方法的特点：
     1. 构造方法的名字与类名相同(普通方法的名字也可以与类名相同)。
     2. 构造方法没有返回类型，并且不能使用void关键字修饰。
  2. 类一定有构造方法。
  3. 当类中没有显式的构造方法时，JVM会为类添加默认的构造方法。
     1. 默认构造方法的格式：

• 4. 当类中存在显式的构造方法时，JVM不再为类添加默认的构造方法。
  5. 构造方法的作用：初始化类的成员变量。
  6. 构造方法通常只能在new关键字的后面调用。
  7. 构造方法可以重载。
• 面向对象的特征：封装，继承，多态，抽象。
• 类的封装：类中的成员变量为private的，为private的成员变量提供public的get()或set()。
• static关键字：static修饰的成员可以通过类名(接口名)直接调用，也可以通过类的对象调用。
  1. 修饰成员变量：静态变量，类所有的对象共用一份静态变量。静态变量只在第一次使用类时初始化。实例变量（不使用static修饰的成员变量）在每次创建类的对象时，都需要初始化

• 2. 修饰成员方法：静态方法，静态方法只能直接调用当前类中静态的成员，静态方法中不能使用this和super这两个关键字。非静态的方法可以直接调用当前类中静态的成员。Static不能修饰类（可以修饰内部类）
• 包（package）
  1. 包的本质：文件夹。
  2. 包的作用：
     1. 解决类的重名问题。
     2. 管理类。
  3. 当类位于某个包中时，类的首行（注释除外）必须为package语句。
  4. 类可以直接使用同包中的类。
  5. 使用其它包中的类时，需要使用import语句导入类（导包）。
  6. eclipse中直接创建在src(default package)下的类无法使用import语句导入。
  7. java.lang包中的元素JVM会自动导入，不需要手动添加import语句。

1. 继承
   1. Java单继承：一个类只能有一个直接或间接的父类。
   2. extends关键字：表示继承。
   3. 类之间的关系：
      1. 继承:A is B
      2. 依赖:A has B（B是A方法是形参）
      3. 聚合:A+B=C（A和B是C的成员变量）
   4. 父类（根类，基类，超类）
   5. 子类可以继承父类所有的成员变量与成员方法。
   6. 子类可以继承父类private的成员，但不能使用。
   7. 子类不能继承父类的构造方法。
2. 访问权限:普通类（顶层类）只能使用public与默认访问权限修饰。

3. 可变长参数：从JDK1.5开始出现
   1. 格式：数据类型… 参数名
   2. 可变长参数只能用于形参。
   3. 可变长参数的本质：一维数组。
   4. 如果方法有多个参数，可变长参数必须出现在最后。
4. 方法的重写（方法的覆盖）
   1. 子类根据需要重写父类中的方法。
   2. 重写的方法要与被重写的方法具有相同的方法名，参数列表，返回类型。
   3. 重写方法的访问权限要大于等于被重写方法的访问权限。
   4. 重写方法抛出的异常必须小于等于被重写方法抛出的异常。父类的方法抛出了异常，子类重写的方法可以不抛出异常。如果子类重写的方法也抛出了异常，那么抛出的异常必须小于第于被重写方法抛出的异常。
   5. static不能产生重写。
5. 继承中的构造方法
   1. 默认情况下，子类一定在自己构造方法的第一行使用super()调用父类无参的构造方法。
   2. 当父类没有无参的构造方法，而子类没有调用父类有参的构造方法时，编译失败。
6. 多态及引用数据类型的类型转换
   1. 当两个类没有继承关系时，不能相互转换。
   2. 引用数据类型比较大小：父类大，子类小。
   3. 子类可以直接赋给父类（父类的引用指向子类的对象，永远是安全的）。
   4. 多态：父类声明，子类创建。
   5. 多态时只能访问父类的成员。
   6. 父类必须强转才能赋给子类。
   7. 父类只有强转为指向的子类类型才是安全的。否则运行时发生异常。
   8. 多态中的成员：
      1. 多态时调用的属性，一定是父类的。
      2. 多态调用的方法：
         1. 如果子类没有重写父类的方法，调用父类的方法。
         2. 如果子类重写了父类的方法，调用子类的方法(方法的动态绑定).
7. java.lang.Object类
   1. Object类是JAVA中所有类的直接或间接的父类。
   2. ==与equals()
      1. ==：判断栈中的内容是否相等。基本数据类型比较的是值。引用数据类型比较引用。
      2. equals():判断当对象与指定对象的内容（堆中的内容）是否相等。equals()最早出现在Object类中，Object类中的equals()仍然是比较栈中的内容是否相等。如果自定义的类需要判断是否相等，可以重写Object类中的equals()方法。
8. 抽象：absrtact
   1. 修饰类：抽象类，抽象类不能实例化(不能new)。只能使用抽象类的子类。抽象类也有构造方法（子类需要调用父类的构造方法）。
   2. 修饰方法：抽象方法，抽象方法只有方法的声明没有方法实现。子类必须重写父类中所有的抽象方法（如果子类是抽象类时，可以不重写父类中的抽象方法或只重写父类一部分的抽象方法）。抽象方法所在的类必须是抽象类。
   3. 修饰接口
   4. abstract不能与哪些关键字一起使用：private,static,final
   5. final关键字：
      1. 修饰变量：只能赋值一次。
      2. 修饰类：类不能被继承。
      3. 修饰方法：方法不能被重写。
9. 接口（interface）
   1. 接口的作用：使JAVA实现多继承。
   2. 接口是一组常量与抽象方法的集合：
      1. 常量：接口中的变量一定为public static final。static final修饰的常量声明时必须赋值。
      2. 抽象方法：接口中的方法一定为public abstract。
   3. 类与接口的关系是实现(implements)
   4. 一个类可以实现多个接口。
   5. 接口不是类。接口不能实例化(不能new)，只能使用接口的实现类。
   6. 当类实现接口时，类必须重写接口中所有的抽象方法(如果实现类是抽象类时，可以不重写接口中的方法或只重写接口中部分的抽象方法)。
   7. 接口与接口的关系是继承
      1. 一个接口可以继承多个接口。

1. 异常结构

• 1. Throwable类：是JAVA中所有错误与异常的父类。
  2. Error类：是编写程序时不应该捕获或处理的严重的问题。
  3. Exception类：在编写程序时应该捕获与处理的异常。
  4. 非运行时异常：在编写程序时必须捕获或处理的异常，否则.java文件无法编译成.class文件。
  5. RuntimeException及其子类：也称运行时异常，在编写程序时不需要捕获与处理的异常。
• try..catch..finally
  1. 格式

• 2. try块不能单独使用，必须与catch或finally一起使用。
  3. 一个try语句中可以出现0个或多个catch块。
  4. 当try块中的代码发生异常时，try会中止执行，程序跳转到对应的catch块中处理异常。
  5. 可以使用Exception捕获所有的异常。
  6. Exception必须出现在最后一个catch块中。
  7. 工作中不建议在finally块中出现return语句。
• throw与throws关键字：
  1. throw：在方法体内手动执行一个异常。
  2. throws：在方法声明的最后，声明调用此方法可能会发生哪些异常。

1. 数字常用类：
   1. 大数字：
      1. java.math.BigInteger:大整数
      2. java.math.BigDecimal:大浮点数
2. 日期常用类：
   1. java.util.Date类：日期类。通常只用于获得当前时间。
   2. java.util.Calendar类：日历类。抽象类。可以获得日期的详细信息，可以对日期进行计算。
   3. java.text.DateFormat类及其子类：对Date与String类型进行类型转换。

3. 包装类：8个，Byte,Short,Long,Float,Double,Boolean,Integer,Character
   1. 装箱：将基本数据类型转换为包装类。
   2. 拆箱：将包装类转换为基本数据类型。
   3. 从JDK1.5开始可以自动装箱与拆箱。
   4. 使用包装类的parseXXX()可以将String转换为对应的基本数据类型。
   5. 使用包装类的valueOf()可以将String转换为对应的包装类。
4. 字符串：
   1. java.lang.String类：是JAVA中不可变的字符序列。
      1. 每次对String的操作都会产生新的String对象。所以如果需要大量修改字符串时，不建议使用String类。
      2. String重写了Object类中的equals()，用于判断字符串的内容是否相等。
      3. String的方法不会改变自身的内容。
   2. java.lang.StringBuffer类与java.lang.StringBuilder类：是JAVA中可变的字符序列。
      1. 每次对StringBuffer与StringBuilder的操作不会产生的新的字符串对象。如果需要大量修改字符串时，建议使用StringBuffer或StringBuilder。
      2. StringBuffer是线程安全的。
      3. StringBuilder是线程不安全的，速度快。
      4. StringBuffer与StringBuilder的方法会改变自身的内容。
      5. StringBuffer与StringBuilder没有重写Object的equals()方法，不能使用equals()判断内容是否相等。
5. 集合
   1. 常用集合的结构

• 2. 常用集合的特点：
     1. Set集合：不能保存重复值，不保存元素加入的顺序。
     2. List集合：保存重复值，可以保存元素加入的顺序。
     3. Map集合：保存一对键与值（Key-Value），键不能重复，值可以重复。
  3. Set集合：
     1. java.util.TreeSet:创建集合时不能指定集合的长度，集合长度不够时不会根据比例增加集合的长度。集合内的元素升序排序。
     2. java.util.HashSet:创建集合时可以指定集合的长度，集合的长度不够时会根据比例增加集合的长度。集合内的元素根据哈希算法排序。
  4. List集合
     1. java.util.ArrayList类：线性的数据结构。根据索引查询元素时效率高，添加与删除元素时效率低。创建集合时可以指定集合的长度，长度不够根据比例增加长度。
     2. java.util.LinkedList类：链表的数据结构。添加与删除元素时效率高，根据索引查询元素时效率低。创建集合时不能指定集合的长度，长度不够不根据比较增加长度。
     3. java.util.Vector类：功能与ArrayList一致，Vector是线程安全的，ArrayList是线程不安全的。
  5. Map集合
     1. java.util.Hashtable：线程安全的。不允许使用null作为键或值。
     2. java.util.HashMap：线程不安全的。允许使用null作为键或值。
• 泛型
  1. 从JDK1.5开始出现。
  2. 泛型的作用：后期绑定数据类型。
  3. 当不指定泛型时，泛型默认为Object类型。
  4. 为泛型添加约束条件：extends 类