Java基础知识点总结

Java基础知识总结

配置环境变量：

  1. 在系统配置中新建
    变量名：“JAVA_HOME”
    变量值：“C:\Program Files (x86)\Java\jdk1.6.0_21”(jdk安装路径)

  2. 在系统配置中新建
    变量名：“CLASSPATH”
    变量值："."

  3. 在系统变量中编辑Path变量
    添加"%JAVA_HOME%\bin;" //注意：加分号结束

  4. 测试：运行–> cmd -->java/ javac命令回车，看到配置信息为正确(java -version查看jdk版本)
    提示：“不是内部或外部指令”为失败

语言基础

一、HelloWorld：Class–>班级 Java中Class–>类

  1. 创建以.java结尾的源文件。
  2. class：类（代码的容器）。
  3. main：主函数，程序执行的入口，一个类当中，只能有一个主函数。
  4. 一行只写一句代码，以 ; 结束。
    Writer once Run anywhere
    JVM（Java Virtual Machine）Java虚拟机 VM Virtual Box

二、编译、运行：

  1. 编译：javac 源文件名称.java 例：javac A.java --> HelloWorld.class
  2. 运行：java 类名 例：java HelloWorld

三、类的基本阐述：

  1. 在一个源文件中，可以定义多个类，编译后，每个类都会生成独立的 字节码文件。
  2. 在一个类中，只能有一个主函数。
  3. 公开类（public class）的类名要和文件名完全相同。
  4. 在一个源文件中，只能有一个公开类。

四、Package（包）：

  1. 作用：管理类、区分类。
  2. 语法：package 包名;（必须在源文件的首行）
  3. 带包编译：javac -d . 源文件名称.java（自动生成目录结构）
  4. 带包运行：java 包名.类名 （全限定名）
  5. 采用域名倒置的规则：http://www.yangxianyang.top
    top.yangxianyang.java.class63.group1.project2.utility

五、编码规范：

  1. 良好的注释习惯：
    I. 注释不参与编译。
    II. 单行注释： //单行
    III. 多行注释： /* 多行 /
    IV. 文档注释： /    * 文档 */ javadoc指令生成外部说明文档
    例：javadoc -d . 源文件名称.java

  2. 良好的标识符命名规范：
    I. 硬性：
    1). 数字、字母、_ 、$ ，数字不能开头。
    2). 不能与关键字、保留字重名。

II. 软性：（约定俗成）
1). 望文生义、见名知义。
2). 类名可以由一个或多个单词组成，每个单词的首字母大写 （Pasacl帕斯卡命名法）
3). 函数、变量由一个或多个单词组成，首单词首字母小写，拼接 词首字母大写（Camel驼峰命名方法）
4). 包名全小写，只能用特殊字符" . “，并且不能以”.“开头或结尾。
5). 常量全大写，多个单词通过”_"拼接。

bit Byte KB MB GB TB PB EB ZB YB BB NB CB XB
六、变量：

  1. 一个存储空间的表示，也是存储数据的基本单元。

  2. 语法：
    I. 声明：数据类型 变量名;
    赋值：变量名 = 值;
    II. 声明并赋值：数据类型 变量名 = 值;
    III. 同时声明多个变量：数据类型 名1,名2,名3=值;

七、数据类型：HotSpot 1.3.1 iadd isub imul idiv badd bsub

  1. 基本数据类型（原始、简单）：8种
    I. 整数：
    1). byte 1个字节 -2^7 ~ 2^7-1 -128 ~ 127 0111 1111
    2). short 2个字节 -2^15 ~ 2^15-1 -32768 ~ 32767
    3). int 4个字节 -2^31 ~ 2^31-1 -2147483648 ~ 2147483647
    4). long 8个字节 -2^63 ~ 2^63-1 “add L”

II. 小数（浮点）：近似值（1bit符号位、8bits指数位、23bits尾数位）
1). float 4个字节 1.4E-45 ~ 3.4E38 add F IEEE754标准
2). double 8个字节 4.9E324 ~ 1.7E308

III. 字符：无符号数（取值范围从0 ~ 65535）
1). char 2个字节 \u0000 ~ \uFFFF ‘A’ 65 ‘\u0041’ ASCII编码
2). 转义字符： \t \n \ ’ "

IV. 布尔：
1). boolean 取值范围：true / false

  1. 引用数据类型（对象）：N种
    I. 字符串：String “abc” “HelloWorld”

八、类型转换：

  1. 自动类型转换：
    I. 两种类型相互兼容。
    II. 目标类型大于源类型。

  2. 强制类型转换：
    I. 整数长度合适，数据完整。
    II. 整数长度不适，数据截断。
    III. 小数强转整数，失去精度，如，整数长度不适，则再次数据截断。
    IV. 字符整数互转，数据完整，如，整数为负数，则转型成"?"
    V. boolean的取值只有true、false，无法转换。

九、表达式：

  1. 概念：使用运算符连接的变量或字面值，并可以得到一个最终结果。

  2. 自动类型提升：
    I. 两个操作数，有一个为double，其结果提升为double。
    II. 如果没有double，有一个为float，其结果提升为float。
    III. 如果没有float，有一个为long，其结果提升为long。
    IV. 如果没有long，有一个为int，其结果提升为int。
    V. 如果没有int，也会自动提升为int。
    VI. 任何类型与String相加（+）时，实为拼接，则提升为String。

十、运算符：

  1. 算数运算符：+ - * / % ++ –
  2. 赋值运算符：= += -= *= /= %= …
  3. 关系运算符：> < >= <= == !=
  4. 逻辑运算符：
    I. && 与（并且）：两个条件同时为真，结果为真。（短路）
    II. || 或（或者）：两个条件有一个为真，结果为真。（短路）
    III. ! 非（不是）：取反。
  5. 三元运算符：布尔表达式? 结果1 : 结果2;

十一、控制台输入：

  1. 导包：import java.util.Scanner;
  2. 创建Scanner变量并赋值：Scanner input = new Scanner(System.in);
  3. 通过控制台获取不同内容：
    I. nextInt(); //获取整数
    II. nextDouble(); //获取小数
    III. next(); //获取字符串
    IV. next().charAt(0); //获取单个字符
    注：如果输入了不匹配的数据，java.util.InputMismatchException

十二、选择结构：

  1. 基本if选择结构：
    if(布尔表达式){
    //表达式结果为true，则执行此代码块
    }

  2. if else选择结构：
    if(布尔表达式){ //程序猿、程序媛
    //表达式结果为true，则执行此代码块
    }else{
    //否则，执行此代码块
    }

  3. 多重if选择结构：
    if(布尔表达式){
    }else if(布尔表达式){
    }else if(布尔表达式){
    }else{}
    注：相互排斥，当有一个条件被满足时，其他均不再执行。适用于区 间判断，保证升降的书写顺序。

十三、分支结构：

  1. switch分支：
    switch(byte、short、int、char){ //JDK7之后可以判断String
    case 1:
    //执行代码
    break;
    case N:
    //执行代码
    break;
    default:
    //执行代码
    break;
    }

  2. break关键字：中断、中止、跳出当前swithc分支结构。

  3. 注：适用于等值判断，所有case的选项不可重复，并不会在满足某个 选项后自动跳出switch，必须手动添加break中断。

十四、局部变量：

  1. 概念：声明在函数内部的变量，必须先赋值再使用。
  2. 作用范围：定义行开始到包含它的代码块结束。
  3. 命名冲突。

循环结构

一、循环：

  1. 概念：通过某个条件，使一段代码周而复始的执行。
  2. 组成：初始部分、循环条件、循环操作、迭代部分。
  3. 分类：
    I. while循环：
    while(布尔表达式){
    }
    特点：先判断，再执行。
    应用场景：循环次数明确。
    例：1、2、3、4、5 ~ 100总和的统计

II. do while循环：
do{
}while(布尔表达式);
特点：先执行，再判断。
应用场景：循环次数不明确。
例：先完成作业，再检查结果。

III. for循环【重点】：
for(1.初始部分; 2.循环条件; 4.迭代部分){
//3.循环操作
}
特点：先判断，再执行。
应用场景：循环次数明确。
例：阶乘。

二、流程控制语句：

  1. break：中止、跳出switch或循环结构。
  2. continue：结束本次、进入下一次循环。

三、嵌套循环：

  1. 概念：在一个完整的循环结构当中，嵌套另一个完整的循环结构。
  2. 图形：外层控制行数，内层控制列数。
  3. 其他：外层控制循环次数，内层控制单次循环操作。

函数(方法)

一、概念：实现特定功能一段代码，可反复使用。

二、语法：
public static 返回值类型 函数名称( 形式参数列表 ){
//函数主体
[ return value; ] //返回值
}

三、组成：

  1. 函数名称：望文生义（camel命名法）
  2. 函数主体：逻辑代码，完成特定功能。
  3. 形式参数：即是函数的局部变量，可声明0~N个，调用时完成赋值。
  4. 返回值类型：基本数据类型、引用数据类型、void。
  5. 返回值：
  6. return value;//结束当前函数，并伴有返回值，返回到函数调用处。
  7. return;//单独出现，只代表结束当前函数，返回到函数调用处。
  8. 规定：一个函数只能有一个返回值，至多是一个返回值。
  9. 注意：当函数存在分支语句时，要保证所有分支都具有正确的返回 值。

四、调用：

  1. 无参调用：函数名称();
  2. 有参调用：函数名称(实际参数…);//为形参赋予实际的值，类型、个数、 顺序必须与形参列表完全匹配。
  3. 数据接收：数据类型 变量名 = 函数名称(实参列表); //当所调用的函 数具有返回值时，可通过声明与返回值类型匹配的变量进行接收。
  4. 执行机制：调用函数时，程序会跳转到函数的定义位置，并优先执行 函数内部内容；执行完毕之后，会携带返回值，返回到函数调用位置。

五、总结：

  1. 一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套。
  2. 一个函数只做一件事儿。（单一职能原则）//粒度
  3. 减少冗余代码、提高复用性、提高可读性、提高可维护性、方便协同 合作。

六、递归：

  1. 将大问题拆分成小问题，解决方案一致，有固定的规律，则可实现递归。
  2. 函数自己调用自己（每调用一次，等于重新调用了另外一个函数）。
  3. 递归中一定包含判断表达式，设定出口条件，否则产生无穷递归。
    StackOverflowError //JVM栈空间溢出错误

数组

一、概念：一组连续的存储空间，存储多个相同数据类型的值。

二、语法：

  1. 数据类型[] 数组名; //声明数组
    数组名 = new 数据类型[ 长度 ]; //分配空间

  2. 数据类型[] 数组名 = new 数据类型[ 长度 ]; //声明并分配空间

  3. 数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,…} //显示初始化

  4. 数据类型[] 数组名 = {值1,值2,值3,…} //显示初始化（不能分行书写）

三、访问：

  1. index（索引、下标），有效值：0 ~ length - 1
  2. 数组名[下标] ，进行数组元素的访问。
  3. 长度：数组名.length //动态获取长度。
  4. 遍历：从头到尾逐一访问数组的元素。
  5. 注意：避免数组下标越界错误（java.lang.ArrayIndexOutOfBoundsException）

四、默认值：

  1. int 0
  2. double 0.0
  3. boolean false
  4. chara \u0000
  5. String null （所有的引用数据类型，默认值都是null）

五、应用：

  1. 统计一组元素的总和。

  2. 数组扩容：
    I. 声明：在原数组长度的基础之上，重新声明新数组。
    II. 赋值：（复制）
    1). 通过循环将原数组中的每个元素，依次复制给新数组的每个元 素。
    2). System.arraycopy(原数组名,原数组起始下标,新数组名,新数组起 始位置,长度);
    3). dataType[] java.util.Arrays.copyOf(原数组名,新长度);

  3. 增删元素：
    I. 将插入位置起的所有元素，依次后移一位。
    II. 将删除位置后的所有元素，依次前移一位。

六、排序：

  1. 冒泡排序：相邻的两个数值比较大小、互换位置（升序：前小后大）
    规则：外层length-1，内层length-1-i

  2. 选择排序：固定值和其他值依次比较大小，互换位置。
    规则：内层 int j = i + 1;

  3. 快速排序：java.util.Arrays.sort(数组名); //JDK提供（只能做升序）
    规则：如需降序，自行实现reverse

七、二维数组：

  1. 概念：一维数组的一维数组，一维数组的元素，还是数组。

  2. 语法：
    I. 数据类型[][] 数组名;
    数组名 = new 数据类型[高维长度][低维长度];

II. 数据类型[][] 数组名 = new 数据类型[高维长度][];//不规则矩形
注意：低维数组必须自行通过new语句创建。

III. 数据类型[][] 数组名;
数组名 = new 数据类型[][]{ {v1,v2,v3},{v4,v5},{v6,v7,v8,v9} };

面向对象

一、面向对象思想（Object Oriented Programming）：

  1. 一切客观存在的事物都是对象，万物皆对象。
  2. 对象一定具有自己的特征（属性）和行为（方法）。

二、类：

  1. 概念：
    I. 在一组相同或类似的对象中，抽取出共性的特征和行为。
    II. 类是对象的模板。
    现实生活中的对象–（抽象）–>程序中的模板（类）–>
    创建程序中的对象–>解决现实问题
    类是对象的抽象，对象是类的实例

  2. 组成：
    I. 属性：（代表对象有什么）
    1). 实例变量（成员变量）:声明在类的内部，函数的外部，当通过 类构建对象的同时，所有成员变量都成为当前对象不可分割的 特征。
    2). 语法：数据类型 属性名;
    局部变量 成员变量
    定义位置 函数或函数中的结构中 类的内部、函数的外部
    默认值 无 字面常量（与数组相同）
    使用范围 从定义行到代码块结束 本类有效
    命名冲突 不允许与局部变量重名 可与局部变量重名，但局部变量优先

注：如成员变量的声明和赋值分开完成，则赋值语句必须在函数内部。

II. 方法：（代表对象能做什么）
访问修饰符 返回值类型 方法名称( 形式参数列表 ){
//方法主体
[return value;] //返回值
}

III. 方法重载（Overload）：
1). 概念：方法名称相同、参数列表不同（类型、个数、顺序）。
2). 屏蔽使用的差异、灵活、便利。

IV. 构造方法（Constructor）：
1). 没有返回值类型。
2). 构造方法名称必须与类名完全相同。
3). 创建对象时，触发构造方法的调用，不可通过句点手动调用。
4). 注意：
a. 在类中，如没有显示定义构造方法，则编译器默认提供无参 构造方法。
b. 如显示定义过构造方法，则无参构造方法不再默认提供。
c. 构造方法可以重载，遵循重载规则。
d. 通过关键字new对象时，根据传入不同的参数，调用对应的 构造方法，完成对象的创建。
e. 有参构造方法可在创建对象的同时，为各个属性赋值，或完 成必要的初始行为。

三、对象：

  1. 概念：
    I. 具有多个特征和行为的实体。
    II. 对象是类的实例。

  2. 创建对象：
    I. 语法：数据类型 对象名 = new 数据类型();
    II. 空间的分配：栈分配局部变量空间，堆分配对象空间。
    III. 属性默认值：基本为对应的零值，引用为null。

四、访问属性和方法：

  1. 引用（存储对象的局部变量）中保存的是对象的具体地址。（reference）
  2. 通过引用访问对象的属性和方法：
    Dog d1 = new Dog();
    d1.breed = “拉布拉多”;//赋值
    d1.breed //取值
    d1.eat(); //调用方法

五、this关键字：

  1. 当前实例，当成员变量与局部变量重名时，如需使用成员变量，应增 加this.前缀。例如：this.name this.age
  2. 通过this()或this(实参)调用本类中的其他构造方法，但必须是构造方 法的首行。
  3. 构造方法之间可以相互调用，但最终产生的对象只有一个。每new一 次，只有一个对象。

六、数据的传递（赋值）：

  1. 值传递：基本数据类型，传递的是值，一方改变不会影响另乙方。
  2. 引用传递：引用数据类型，传递的是地址，一方改变另一方也会变。

面向对象三大特性

一、封装：

  1. 概念：尽可能的隐藏类的内部实现细节，从而控制用户对类的修改及 访问的权限。

  2. 实现步骤：
    I. 私有属性：private修饰属性名称。
    II. 访问方法：public修饰setXXX()、getXXX()方法。

  3. 访问形式：
    I. 封装前：
    1). 赋值：s1.age = 30000;
    2). 取值：s1.age
    II. 封装后：
    1). 赋值：s1.setAge(30000);
    2). 取值：s1.getAge();

二、继承：

  1. 概念：类与类满足is a的关系，子类（派生类）是一种父类（超类、 基类）。

  2. 父类的抽象：
    I. 父类：在一组相同或类似的类中，抽取共性的特征和行为。
    II. 功能越精细、重合点越多，越贴近直接父类。
    III. 功能越粗略、重合点越少，越贴近Object类。
    IV. 将多个子类中共性的特征和行为，定义在父类中实现重用。

  3. 继承语法：子类 extends 父类{}

  4. 产生继承关系后，子类可以使用父类中所声明的属性和方法，也可定 义子类独有的属性和方法。

  5. Java为单继承：一个类只能有一个直接父类，但可以多级继承。

  6. 不可继承：
    I. private修饰的私有属性和方法。
    II. 构造方法。
    III. 非同包时，由default修饰的属性和方法。

  7. 访问修饰符（访问可见性）：
    本类 同包 非同包 子类 其他
    private yes
    default yes yes
    protected yes yes yes
    public yes yes yes yes

注意：default：管理的范围是包（package），只要在同一个包中即可 访问。

  1. 方法覆盖（Override 重写）：
    I. 当父类提供的方法无法满足子类需求时，可在子类中声明和父类完 全相同的方法进行覆盖。
    II. 子类覆盖父类方法后，在实际调用中，优先调用子类覆盖后的方法。
    III. 子类覆盖父类方法时，访问修饰符必须与父类相同或比父类更宽 泛。

  2. super关键字：
    I. 在子类中，可以通过super.访问父类中所定义的属性和方法。
    II. super()或super(实参)在子类构造方法中，显示调用父类构造方法， 但必须是构造方法的首行。
    III. 子类构造方法中如没有显示调用父类构造方法，则编译器默认提供 super()，调用父类无参构造方法。

  3. 继承关系的初始化：构造子类对象时，先构建父类对象
    I. 分配空间。
    II. 初始化父类属性
    III. 执行完毕父类构造方法
    IV. 初始化子类属性
    V. 执行完毕子类构造方法

三、多态：

  1. 概念：父类引用指向子类对象，从而产生多种形态。

  2. 语法：父类类型 引用名称 = new 子类类型();
    注：仅可调用父类中所声明的属性和方法、而不可调用子类独有的属 性和方法。

  3. 应用方式（1.继承、2.覆盖）：
    I. 使用父类作为方法形参，实现多态。（可以让一个方法的参数类型 的个数更宽泛）
    II. 使用父类作为方法返回值，实现多态。（返回值可以是任意子类类 型）

  4. 作用：
    I. 屏蔽子类间的差异。
    II. 灵活、耦合度低。

  5. 对象间的类型转换：
    I. 父类引用中保存子类的真实实例，称为向上转型（装箱）。
    例如：Animal a = new Dog(); Vehicle veh = new Bus();

II. 将父类引用中的真实子类实例，强制转换回其本身类型，称为向下 转型（拆箱）
例如：Dog dog = (Dog)a; Bus bus = (Bus)veh;

III. 向下转型时，如子类真实类型与目标类型不匹配，则发生类型转换 异常（ClassCastException）

  1. instanceof关键字：
    I. 语法：父类引用 instanceof 子类类型
    II. 语义：布尔表达式判断引用中的对象是否与子类类型匹配

三个修饰符

一、static（静态）：

  1. 概念：
    I. static修饰符表示类成员、全类所有对象共享的成员。
    II. 不必创建对象，可直接通过类名调用。

  2. 静态属性、静态方法（类属性、类方法）：
    I. 全类共享（不属于某一个对象）。
    II. 访问方式：类名.静态成员名称。
    //Math.random()、Math.sqrt()、System.out、Arrays.copyOf()、 Arrays.sort()、System.arraycopy()
    III. 所有引用调用的静态属性和方法都会自动转换成类名调用。

  3. 静态方法可以继承，没有多态。

  4. 静态方法不能直接访问非静态的成员：
    I. 原因1：当访问静态方法时，可能还没有对象的产生。
    II. 原因2：实例属性和方法都默认拥有this前缀，代表当前实例，然 而静态方法不属于某个实例。

  5. 静态代码块：
    I. 类加载时被执行一次，不能手动调用。
    II. 类加载（ClassLoading）：
    1). JVM首次使用（new对象、调用静态成员、使用子类时、 Class.forName(“全限定名”);）某个类时，通过CLASSPATH查找该 类的.class文件。
    2). 将.class文件中所有的描述信息（属性、方法、构造方法）加载 到内存中，进行保存。
    3). 优先加载，可为静态属性赋值，或任何程序必要的初始行为。

  6. 类加载以及创建对象的十步操作：
    I. 类级别：
    1). 父类静态属性
    2). 父类静态代码块
    3). 子类静态属性
    4). 子类静态代码块
    II. 对象级别：
    5). 父类实例属性
    6). 父类动态代码块
    7). 父类构造方法
    8). 子类实例属性
    9). 子类动态代码块
    10).子类构造方法

二、abstract（抽象）：

  1. 修饰类：不能new对象（往往父类是不该被创建成对象的）。
  2. 修饰方法：只有方法声明，没有方法实现的（必须包含在一个抽象类 中）
  3. 注意：
    I. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
    II. 子类继承抽象类后，必须实现父类中所有的抽象方法，否则子类还 是抽象类。

三、final（最终）：

  1. 修饰类：此类不能被继承。（String、Math、System）
  2. 修饰方法：此方法不能被覆盖。
  3. 修饰变量：此变量的值不可改变（常量）。
    I. 没有初始值，必须手动赋值。
    II. 实例常量：显示初始化、动态代码块、构造方法（创建对象完成前）
    III. 静态常量：显示初始化、静态代码块（类加载完成前）
    IV. 常用public static final联合修饰的变量，称为公开静态常量。
    V. 基本数据类型：值不可变；引用数据类型：地址不可变。

接口

一、概念：相当于特殊的抽象类，接口是一种能力，接口是一种约定。(抽象类的抽象)

二、语法：

  1. 定义接口：interface 接口名称{}
  2. 实现接口：implements 接口名称{}

三、与抽象类的异同：
I. 相同：
1). 不能new对象。
2). 都可以编译成字节码文件。
3). 都可以作为引用类型。
II. 不同：
1). 所有属性都是公开静态常量，隐式使用public static final修饰。
2). 接口中所有方法都是公开抽象方法，隐式使用public abstract修饰
3). 没有构造方法、没有动态、静态代码块。

四、关系：

  1. 类与类：单继承
  2. 类与接口：多实现
  3. 接口与接口：多继承
    注意：一个类在继承父类的同时，还可以实现多个接口。

五、规范：

  1. 任何类在实现接口的同时，必须实现接口中所有的抽象方法，否则该 类还是抽象类。
  2. 实现接口中的抽象方法，访问修饰符必须是public。

六、应用场景：Java为单继承，当父类提供的方法个数无法满足子类需求时， 可以通过实现接口来扩充子类的能力。

七、接口引用：

  1. 接口引用指向实现类对象，仅可调用接口中所声明的方法。
  2. 使用接口作为方法形参，可更自然的使用多态。

八、接口回调：先有接口的使用者，后有接口的实现者。

九、好处：

  1. 设计与实现完全分离。
  2. 更容易搭建程序框架。
  3. 更容易更换实现。
  4. 程序的耦合降低。

常用类

一、内部类：

  1. 概念：
    I. 在类的内部再定义一个类。
    II. 内部类编译之后会生成字节码文件。
    III. 内部类可以访问外部类的私有成员、而不破坏封装。

  2. 分类：
    I. 成员内部类【了解】：
    1). 是外部类的一个部分，创建内部类对象时，必须依赖外部类对 象。
    2). 可直接访问外部类的私有成员。
    3). 通过“外部类类名.this”访问外部类的成员变量。
    4). 语法：
    a. 创建：
    Outer out = new Outer();
    Outer.Inner in = out.new Inner();
    b. 访问：
    Outer.this.field //访问外部类的成员变量

II. 静态内部类【了解】：
1). 不依赖外部类对象，可直接创建内部类对象，或通过类名访问 内部类的静态成员。
2). 只能访问外部类的静态成员。
3). 语法：
a. 创建：
Outer.Inner in = new Outer.Inner();
b. 访问：
Outer.field //直接访问外部类静态成员

III. 局部内部类【重要】：
1). 当访问外部类的局部变量时，因无法保证二者的生命周期一致， 所以必须为局部变量增加final修饰符。
2). 作用范围和创建对象的范围仅在方法内部，隐藏类的信息。

IV. 匿名内部类【重要】：
1). 没有类名的局部内部类。
2). 必须继承一个父类或者实现一个接口。
3). 定义类、实现类、创建对象三步的语法合并。
4). 生命周期内只能创建一个对象。

API（Application Programming Interface）应用程序编程接口，帮助文档。

二、Object类：

  1. 概念：
    I. 超类、基类、所有类直接或间接的父类，位于继承树的顶层。
    II. 任何类，如没有书写extends显示继承，则默认直接继承Object。
    III. Object所定义的方法，是所有对象有具有的方法。
    IV. Object类型可以存储任何对象，作为参数、可接收任何对象；作为 返回值，可返回任何对象。

  2. 方法：
    I. public final Class<?> getClass() //返回对象的运行时类型（真实类型）
    比较两个对象的真实类型是否一致 a1.getClass() == a2.getClass()

II. public int hashCode() //根据对象的物理地址、字符串、整数部分进 行计算，最终得到一个int类型的结果。哈希码并不唯一，它是一 种算法，尽量保证不同对象返回不同哈希码。

III. public String toString() //返回该对象的字符串表示。
可根据自己的业务需求，选择性覆盖父类中的toString()。

IV. public boolean equals(Object obj) //比较两个对象是否相同
Object实现策略为“==”比较地址。
如需判断地址不同，内容相同的两个对象，则需要自行覆盖。

V. protected void finalize() ：
I. 垃圾回收：销毁垃圾对象，释放存储空间。
II. 垃圾对象：没有任何引用指向对象，为垃圾对象。
III. 垃圾收集器（Garbage Collect）:

  1. 自动：JVM内存耗尽，自动回收。
  2. 手动：System.gc()，通知JVM执行回收（优先级较低）。

三、包装类：

  1. 概念：
    I. 8种基本数据所对应的引用数据类型。
    II. Object可统一所有数据，默认值为null。

  2. 匹配：
    byte —> Byte
    short —> Short
    int —> Integer
    long —> Long
    float —> Float
    double —> Double
    char —> Character
    boolean —> Boolean

  3. 类型转换：
    I. Number父类中继承到的6个转型方法。
    II. 构造方法。
    III. parseXXX(String s) //静态方法，将字符串转换成基本类型
    IV. valueOf() //静态方法，将基本或字符串转换成包装类型
    V. 注意兼容类型，避免NumberFormatException异常。
    VI.JDK5之后，自动装箱、拆箱。包装类型与基本类型可自动转换。

四、String：

  1. 概念：
    I. 字符串是常量，创建之后不可改变。
    II. 字符串字面值存储在字符串池中，可以共享。

  2. 创建：
    String s1 = “abc”;
    String s2 = new String(“abc”);

  3. 方法：
    public char charAt(int index) //返回index所对应的字符
    public String concat(String str)
    public boolean contains(CharSequence s) // CharSequence就是字符串 String
    public boolean endsWith(String suffix)
    public boolean startsWith(String suffix)
    public int indexOf(String str)
    public int lastIndexOf(String str)
    public String replace(char oldChar,char newChar)
    public String[] split(String regex)
    public String substring(int beginIndex)
    public String toLowerCase() //将字符串转换成大写
    public String toUpperCase()
    public String trim()

  4. 可变字符串：
    I. StringBuffer：JDK1.0推出，操作速度慢、线程安全。
    II. StringBuilder：JDK5推出，操作速度快、线程不安全。
    III. 常用方法：append(?); //追加

集合框架

一、概念：

  1. 对象的容器，存储对象的对象，大多数情况下，可代替数组。
  2. 位置：java.util.*;
  3. 结构：

二、Collection体系集合详解：

  1. Collection父接口：
    I. 特点：存储所有Object数据。
    II. 方法：
    boolean add(Object o) //向集合中添加一个对象
    void clear() //清空集合中的对象
    boolean contains(Object o) //检查集合中是否包含o对象
    boolean remove(Object o) //将o对象从集合中移除
    int size() //返回集合中元素的个数
    Object[] toArray() //将集合转换成Object数组。

  2. List子接口：for、forEach、Iterator
    I. 特点：有序、有下标、元素可以重复。
    II. 方法：
    void add(int index, E element) //在指定位置插入元素
    E get(int index) //返回指定位置的元素
    E remove(int index) //通过下标移除元素
    E set(int index, E element) //在指定位置替换元素
    List subList(int fromIndex,int toIndex) //返回fromIndex与toIndex 之间的元素

III. 实现类：
1). ArrayList【重点】：
a. 数组结构存储。
b. JDK 1.2推出 操作速度快，线程不安全。
c. 查询快、增删慢。

2). Vector【了解】：
a. 数组结构存储。
b. JDK 1.0推出 操作速度慢，线程安全。

3). LinkedList【了解】：
a. 链表结构存储。
b. 查询慢、增删快。
c. 实现栈Stack，Last In First Out(LIFO)后进先出
d. 实现队列Queue，Last In Last Out(LILO)后进后出->先进先出

三、泛型集合【重点】：

  1. 参数化类型、类型安全的集合，限制元素的类型必须一致。
  2. 编译期即可检查数据类型。
  3. 访问时，不必拆箱。
  4. 不同泛型之间不可相互赋值，泛型不存在多态。
    E = Element / K = Key / V = Value / U = Utility Unit / R = Result / T = Type

四、Collections工具类：
public static void sort(List list) //升序排序
public static void reverse(List<?> list) //倒置
public static void shuffle(List list) //乱序、洗牌

五、Set子接口：forEach、Iterator

  1. 特点：无序、无下标、元素不可重复。
  2. 方法：全部继承自Collection。
  3. 实现类：
    I. HashSet【重点】：
    1). 将自定义类对象存入HashSet时，无法保证元素内容不重复。
    2). 覆盖equals方法，保证内容相同的对象，比较结果为true。
    3). 为触发equals的调用，必须覆盖hashCode方法：
    a. 确保相同对象返回相同哈希码。
    b. 尽量保证不同对象返回不同哈希码。

II. LinkedHashSet【了解】：保留元素的插入顺序。

III. TreeSet【了解】：
1). 实现了SortedSet接口，对集合元素自动排序。
2). 元素对象的类型必须实现Comparable接口中的compareTo方法， 指定排序的规则。
3). 希望this靠前，则返回负数；希望this靠后，则返回正数；返回 则代表相等。
4). TreeSet通过compareTo方法的结果进行排序，如果结果为“零”， 则可以指定次要排序列。
4. 迭代方式：
I. Iterator迭代器：
1). 获取当前集合的专属迭代器。
Iterator<?> it = set.iterator();
2). 循环判断是否存在下一个元素，并获取下一个元素。
while(it.hasNext()){//判断
it.next();//获取
}

II. forEach遍历：
for(数据类型 局部变量名 : 容器){
//将容器中的每个对象临时保存在局部变量中
//循环体内容完成对当前对象的操作
}

六、Map接口：

  1. 特点：存储一对数据（key-value），无序、无下标，键不能重复、值 可以重复。通过建访问值（通过key访问value）。

  2. 方法：
    V put(K key, V value) //将关联的键和值一并存储
    V get(Object key) //通过建访问值
    V remove(Object key) //通过键移除整个键值对
    Set keySet() //获取所有的键
    Collection values() //获取所有的值
    Set entrySet() //获取所有的键加值（格式为：“key=value”）

  3. 实现类：
    I. HashMap【重点】：
    1). 允许使用null作为key或value，重复键会覆盖原有键值对。
    2). JDK 1.2推出 操作速度快、线程不安全。

II. Hashtable【了解】：
1). 不允许使用null作为key或value。
2). JDK 1.0推出 操作速度慢、线程安全。

III. TreeMap【了解】：
1). 实现SortedMap接口，自动对key排序。
2). 作为key的对象，必须实现Comparable接口。

IV. Properties【了解】：
1). Hashtable的子类，存取时的参数必须是String类型。
2). 可以直接在流（IO）中加载内容。

异常

一、概念：程序在运行中发生的特殊情况。

二、异常分类：
Throwable：
|- Error：错误，硬件、JVM、执行逻辑错误，不能手动处理。
|- Exception：异常，程序在运行或配置中产生的问题，可处理。
|- RuntimeException：运行时异常，编译期不检查，可处理可不处理
|- CheckedException：受查异常，编译期检查，必须处理。

三、异常的产生：

  1. 自动抛出：程序在运行时遇到不符合规范的代码或结果，则产生异常。
  2. 手动抛出：throw 异常对象;
  3. 异常产生的结果：相当于遇到了return语句，导致程序因异常而中止。

四、异常的传递：按照方法的调用链进行反向传递m3->m2->m1->main->JVM

五、异常的处理：

  1. 作用：发生异常时，为提高代码的容错性，避免程序中止，执行预判 的处理代码。从而尽量减少程序因异常带来的损失。

  2. 方式：
    I. 消极处理：throws 声明异常，修饰在方法参数列表的后端。
    public void method() throws Exception{}
    注：

  3. 显示告知调用者，此方法可能出现的异常。

  4. 只有异常的传递，而没有捕获异常，程序仍旧会因异常而中 止。

II. 积极处理【重点】：捕获、处理异常。
try{
//可能发生异常的代码
}catch(Exception e){ //将捕获到的异常对象赋值给局部变量e
e.getMessage(); //获取异常发生的原因、消息
e.printStackTrace(); //打印堆栈跟踪信息
//异常处理代码
}finally{
//最终：无论是否发生异常，此代码块一定会执行。
//常用于释放资源。
}

III. 常用异常结构：
1). try{}catch{}
2). try{}catch{}catch{}…
3). try{}catch{}finally{}
4). try{}catch{}catch{}…finally{}
5). try{}finally{}

六、自定义异常：

  1. 继承Exception或Exception的子类，常用RuntimeException。
  2. 继承受查异常之后，抛出的异常通常不直接处理，以throws声明异常 的形式，告知调用者处理。

七、带有异常声明的方法覆盖：

  1. 遵循覆盖语法。
  2. 子类覆盖父类带有异常声明的方法时，不可抛出比父类更宽泛的异常。
    子类可以声明的异常必须 <= 父类声明的异常

I/O框架

一、流：（Input / Output）

  1. 概念：流（对象）是在内存与存储设备之间传输数据的通道。

  2. 分类：
    I. 方向：
    1). 输出流：用以将<内存>中的数据写入到<存储设备>中。
    2). 输入流：用以将<存储设备>中的数据读入到<内存>中。

II. 单位：
1). 字节流：可以读写所有数据。
2). 字符流：只能读写文本数据。

III. 功能：
1). 节点流：实际传输数据。
2). 过滤流：增强节点流功能（处理流、装饰类）。

二、字节流：

  1. 字节流父类：
    I. OutputStream（输出流）
    II. InputStream（输入流）

  2. 字节节点流【重点】：
    I. FileOutputStream：
    public void wirte(int b) //一次写一个字节
    public void write(byte[] b) //一次写多个字节（b.length个）

II. FileInputStream：
public int read() //一次读一个字节
public int read(byte[] b) //一次读多个字节（最多b.length个）

  1. 字节过滤流：
    I. DataOutputStream / DataInputStream：
    1). 直接读写8种基本数据类型。
    2). 直接读写String。（writeUTF()、readUTF()）

II. BufferedOutputStream：
1). 缓冲流，提高IO效率，减少访问硬盘的次数。
2). 数据存储到缓冲区，关闭前，需使用flush或close一次性写入 到文件中，并清空缓冲。

III. ObjectOutputStream / ObjectInputStream【重点】：
1). 读写对象（序列化、反序列化），要求对象必须实现 java.io.Serializable接口，以启动序列化功能。
2). 序列化对象时，必须保证其所有属性均可序列化。
3). transient修饰为临时属性，不参与序列化。
4). java.io.EOFException表示到达文件末尾，可处理。

三、字符编码：

  1. ISO-8859-1 除收录ASCII外，还包括西欧、希腊、泰国、阿拉伯、 希伯来对应的文字符号。
  2. UTF-8 针对Unicode的可变长字符编码。
  3. GB2312 简体中文。陶喆（陶吉吉）
  4. GBK 简体中文扩充版。
  5. BIG5 台湾繁体中文。
  6. 注意：字符编码和字符解码不一致时，可能造成乱码。

四、字符流：

  1. 字符流父类：
    I. Wrietr（输出流）
    II. Reader（输入流）

  2. 字符节点流【重点】：
    I. FileWriter：
    public void write(String str) //一次写一个字符串
    II. FileReader：
    public int read() //一次读一个字符
    public int read(char[] c) //一次读一组字符

  3. 字符过滤流：
    I. PrintWriter / BufferedReader：缓冲流，支持一次写一行、读一行。
    II. OutputStreamWriter / InputStreamReader：
    桥转换流：用以将字节流转换成字符串，并设置编码格式。

  4. 使用步骤：
    I. 创建节点流。
    II. [ 包装过滤流 ]。
    III. 读写数据。
    IV. 关闭流。

五、File对象：

  1. 概念：File代表物理盘符下的一个文件或者文件夹。
  2. 方法：参考API。
    I. public Files[] listFiles();//获取当前路径下的所有File对象。
    II. public Files[] listFiles(FileFilter filter); //文件过滤器
  3. FileFilter接口：
    实现：boolean accept(File file) //使满足条件的文件对象，出现在listFile() 方法的返回值中（File数组）。

多线程

一、进程：

  1. 概念：
    I. 程序是静止的概念，而进程是程序的实体，在CPU执行时，才被 赋予生命，只有当程序真正的running时，被称为进程。
    II. 在任何时间点、时间戳，只能有一个进程在执行，宏观并行、微观 串行。

二、线程：

  1. 概念：
    I. 轻量级进程（Light Weight Process LWP），代表进程中一个单一的 顺序控制流程。
    II. CPU调用的基本单位是线程（调用某一进程中的某一线程）。
    III. 在单个进程中“同时”运行多个线程完成不同的工作，交替执行， 称为多线程。

  2. 组成：
    I. CPU：操作系统分配时间片（Windows：520ms、Linux：5800ms）。
    II. 数据：堆空间共享（对象），栈空间独立（变量）。

III. 代码：
1). 继承Thread类：
a. 覆盖run方法。
b. 创建子类对象： Thread t1 = new MyExtendsThread();
c. 启动线程： t1.start();

2). 实现Runnable接口：
a. 覆盖run方法。
b. 创建子类对象： Runnable r = new MyImplRunnable();
c. 创建线程对象： Thread t2 = new Thread®;
d. 启动线程： t2.start();

3). 常用方法：（造成阻塞）
public static void sleep(long millis) //当前线程休眠
public static void yield() //放弃、让出时间片
public final void join() //将其他线程加入到自身线程中，优先执行

三、线程同步【重点】：

  1. 线程不安全：当多线程并发访问临界资源时，如果破坏原子操作，可 能造成数据不一致。
    I. 临界资源：共享资源（同一对象）。
    II. 原子操作：不可分割的多个步骤，被视为一个整体，其顺序不可打 乱或缺省。

  2. 互斥锁标记：每个对象都有一个互斥锁标记，用来分配给线程的。

  3. 锁池：每个对象都有一个锁池，用来存储等待该对象锁标记的线程的

  4. 同步方式【重点】：
    1). 同步代码块：
    synchronized(临界资源){ //可为临界资源加锁
    //原子操作
    }

2). 同步方法：
synchronized 返回值类型 方法名称(形参列表){
//原子操作
}
注:在调用同步方法时，需要对象的锁标记，而调用非同步方法时， 不需要锁标记，可直接访问。

ArrayList操作速度快，线程不安全（支持并发访问，非同步方法）
Vector 操作速度慢，线程安全（同步方法）
synchronized add()
remove()

死锁、生产者消费者、哲学家进餐

反射

一、概念：

  1. 类的对象：基于某个类new出来的一个实例，也称为实例对象。new Dog

  2. 类对象：封装了一个类的所有信息（包名、类名、父类、接口、属性、 方法、构造方法…）。Student.class
    注意：类对象就是一个.class文件，当中包含了一个类的所有信息！

  3. 获取类对象：
    //1.通过类型直接获取类对象
    Class c1 = Student.class;//类对象

//2.以静态方法的形式获取类对象
Class c2 = Class.forName(“ref.Student”);

//3.通过类的实例对象获取类对象
Student stu = new Student();
Class c3 = stu.getClass();

  1. 反射的应用：
    //1.获取父类Class对象
    Class superClass = c.getSuperclass();
    //2.获取所有接口的Class对象
    Class[] interfaces = c.getInterfaces();
    //3. 获取所有公开的属性（包括父类属性）
    Field[] fields = c1.getFields();
    //4. 获取所有自身声明的属性（包括私有）
    Field[] fields = c1.getDeclaredFields();
    //5. 获取所有公开的方法（包括父类方法）
    Method[] methods = c1.getMethods();
    //6. 获取所有自身声明的方法（包括私有）
    Method[] methods = c1.getDeclaredMethods();
    //7.通过类对象创建实例对象
    public Object newInstance()
    //8.获取单个公开方法（包括父类）
    Method pm = c.getMethod(“方法名称”,“可边长形参类型”);
    //9.获取单个自身方法（包括私有）
    Method sm = c.getDeclaredMethod(“方法名称”,“可边长形参类型”);
    //8. 执行Method对象：
    method.invoke(“此方法隶属于的对象”,“可变长实参”);

四、单例模式：

  1. 概念：一个类，只能有一个对象。
  2. 实现方式：
    I. 饿汉式（类加载时创建，天生线程安全）
    II. 懒汉式（使用时创建，线程不安全，需添加同步）

`

posted @ 2018-11-07 23:12  AlbertYang666  阅读(124)  评论(0)  编辑  收藏  举报
AlbertYang