Java基础知识点总结

网友投稿 611 2022-05-29

Java基础知识总结

配置环境变量:

语言基础

循环结构

函数(方法)

数组

面向对象

面向对象三大特性

三个修饰符

接口

常用类

集合框架

异常

I/O框架

多线程

反射

配置环境变量:

在系统配置中新建

变量名:“JAVA_HOME”

变量值:“C:\Program Files (x86)\Java\jdk1.6.0_21”(jdk安装路径)

在系统配置中新建

变量名:“CLASSPATH”

变量值:"."

在系统变量中编辑Path变量

添加"%JAVA_HOME%\bin;" //注意:加分号结束

测试:运行–> cmd -->java/ javac命令回车,看到配置信息为正确(java -version查看jdk版本)

提示:“不是内部或外部指令”为失败

语言基础

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

创建以.java结尾的源文件。

class:类(代码的容器)。

main:主函数,程序执行的入口,一个类当中,只能有一个主函数。

一行只写一句代码,以 ; 结束。

Writer once Run anywhere

JVM(Java Virtual Machine)Java虚拟机 VM Virtual Box

二、编译、运行:

编译:javac 源文件名称.java 例:javac A.java --> HelloWorld.class

运行:java 类名 例:java HelloWorld

三、类的基本阐述:

在一个源文件中,可以定义多个类,编译后,每个类都会生成独立的 字节码文件。

在一个类中,只能有一个主函数。

公开类(public class)的类名要和文件名完全相同。

在一个源文件中,只能有一个公开类。

四、Package(包):

作用:管理类、区分类。

语法:package 包名;(必须在源文件的首行)

带包编译:javac -d . 源文件名称.java(自动生成目录结构)

带包运行:java 包名.类名 (全限定名)

采用域名倒置的规则:http://www.yangxianyang.top

top.yangxianyang.java.class63.group1.project2.utility

五、编码规范:

良好的注释习惯:

I. 注释不参与编译。

II. 单行注释: //单行

III. 多行注释: /* 多行 /

IV. 文档注释: /* 文档 */ javadoc指令生成外部说明文档

例:javadoc -d . 源文件名称.java

良好的标识符命名规范:

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

六、变量:

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

语法:

I. 声明:数据类型 变量名;

赋值:变量名 = 值;

II. 声明并赋值:数据类型 变量名 = 值;

III. 同时声明多个变量:数据类型 名1,名2,名3=值;

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

基本数据类型(原始、简单):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

引用数据类型(对象):N种

I. 字符串:String “abc” “HelloWorld”

八、类型转换:

自动类型转换:

I. 两种类型相互兼容。

II. 目标类型大于源类型。

强制类型转换:

I. 整数长度合适,数据完整。

II. 整数长度不适,数据截断。

III. 小数强转整数,失去精度,如,整数长度不适,则再次数据截断。

IV. 字符整数互转,数据完整,如,整数为负数,则转型成"?"

V. boolean的取值只有true、false,无法转换。

九、表达式:

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

自动类型提升:

I. 两个操作数,有一个为double,其结果提升为double。

II. 如果没有double,有一个为float,其结果提升为float。

III. 如果没有float,有一个为long,其结果提升为long。

IV. 如果没有long,有一个为int,其结果提升为int。

V. 如果没有int,也会自动提升为int。

VI. 任何类型与String相加(+)时,实为拼接,则提升为String。

十、运算符:

算数运算符:+ - * / % ++ –

赋值运算符:= += -= *= /= %= …

关系运算符:> < >= <= == !=

逻辑运算符:

I. && 与(并且):两个条件同时为真,结果为真。(短路)

II. || 或(或者):两个条件有一个为真,结果为真。(短路)

III. ! 非(不是):取反。

三元运算符:布尔表达式? 结果1 : 结果2;

十一、控制台输入:

导包:import java.util.Scanner;

创建Scanner变量并赋值:Scanner input = new Scanner(System.in);

通过控制台获取不同内容:

I. nextInt(); //获取整数

II. nextDouble(); //获取小数

III. next(); //获取字符串

IV. next().charAt(0); //获取单个字符

注:如果输入了不匹配的数据,java.util.InputMismatchException

十二、选择结构:

基本if选择结构:

if(布尔表达式){

//表达式结果为true,则执行此代码块

}

if else选择结构:

if(布尔表达式){ //程序猿、程序媛

//表达式结果为true,则执行此代码块

}else{

//否则,执行此代码块

}

多重if选择结构:

if(布尔表达式){

}else if(布尔表达式){

}else if(布尔表达式){

}else{}

注:相互排斥,当有一个条件被满足时,其他均不再执行。适用于区 间判断,保证升降的书写顺序。

十三、分支结构:

switch分支:

switch(byte、short、int、char){ //JDK7之后可以判断String

case 1:

//执行代码

break;

case N:

//执行代码

break;

default:

//执行代码

break;

}

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

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

十四、局部变量:

概念:声明在函数内部的变量,必须先赋值再使用。

作用范围:定义行开始到包含它的代码块结束。

命名冲突。

循环结构

一、循环:

概念:通过某个条件,使一段代码周而复始的执行。

组成:初始部分、循环条件、循环操作、迭代部分。

分类:

I. while循环:

while(布尔表达式){

}

特点:先判断,再执行。

应用场景:循环次数明确。

例:1、2、3、4、5 ~ 100总和的统计

II. do while循环:

do{

}while(布尔表达式);

特点:先执行,再判断。

应用场景:循环次数不明确。

例:先完成作业,再检查结果。

III. for循环【重点】:

for(1.初始部分; 2.循环条件; 4.迭代部分){

//3.循环操作

}

特点:先判断,再执行。

应用场景:循环次数明确。

例:阶乘。

二、流程控制语句:

break:中止、跳出switch或循环结构。

continue:结束本次、进入下一次循环。

三、嵌套循环:

概念:在一个完整的循环结构当中,嵌套另一个完整的循环结构。

图形:外层控制行数,内层控制列数。

其他:外层控制循环次数,内层控制单次循环操作。

函数(方法)

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

二、语法:

public static 返回值类型 函数名称( 形式参数列表 ){

//函数主体

[ return value; ] //返回值

}

三、组成:

函数名称:望文生义(camel命名法)

函数主体:逻辑代码,完成特定功能。

形式参数:即是函数的局部变量,可声明0~N个,调用时完成赋值。

返回值类型:基本数据类型、引用数据类型、void。

返回值:

return value;//结束当前函数,并伴有返回值,返回到函数调用处。

return;//单独出现,只代表结束当前函数,返回到函数调用处。

规定:一个函数只能有一个返回值,至多是一个返回值。

注意:当函数存在分支语句时,要保证所有分支都具有正确的返回 值。

四、调用:

无参调用:函数名称();

有参调用:函数名称(实际参数…);//为形参赋予实际的值,类型、个数、 顺序必须与形参列表完全匹配。

数据接收:数据类型 变量名 = 函数名称(实参列表); //当所调用的函 数具有返回值时,可通过声明与返回值类型匹配的变量进行接收。

执行机制:调用函数时,程序会跳转到函数的定义位置,并优先执行 函数内部内容;执行完毕之后,会携带返回值,返回到函数调用位置。

五、总结:

一个类中可以定义多个函数,函数之间属于并列关系,不可嵌套。

一个函数只做一件事儿。(单一职能原则)//粒度

减少冗余代码、提高复用性、提高可读性、提高可维护性、方便协同 合作。

六、递归:

将大问题拆分成小问题,解决方案一致,有固定的规律,则可实现递归。

函数自己调用自己(每调用一次,等于重新调用了另外一个函数)。

递归中一定包含判断表达式,设定出口条件,否则产生无穷递归。

StackOverflowError //JVM栈空间溢出错误

数组

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

二、语法:

数据类型[] 数组名; //声明数组

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

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

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

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

三、访问:

index(索引、下标),有效值:0 ~ length - 1

数组名[下标] ,进行数组元素的访问。

长度:数组名.length //动态获取长度。

遍历:从头到尾逐一访问数组的元素。

注意:避免数组下标越界错误(java.lang.ArrayIndexOutOfBoundsException)

四、默认值:

int 0

double 0.0

boolean false

chara \u0000

String null (所有的引用数据类型,默认值都是null)

五、应用:

统计一组元素的总和。

数组扩容:

I. 声明:在原数组长度的基础之上,重新声明新数组。

II. 赋值:(复制)

1). 通过循环将原数组中的每个元素,依次复制给新数组的每个元 素。

2). System.arraycopy(原数组名,原数组起始下标,新数组名,新数组起 始位置,长度);

3). dataType[] java.util.Arrays.copyOf(原数组名,新长度);

增删元素:

I. 将插入位置起的所有元素,依次后移一位。

II. 将删除位置后的所有元素,依次前移一位。

六、排序:

冒泡排序:相邻的两个数值比较大小、互换位置(升序:前小后大)

规则:外层length-1,内层length-1-i

选择排序:固定值和其他值依次比较大小,互换位置。

规则:内层 int j = i + 1;

快速排序:java.util.Arrays.sort(数组名); //JDK提供(只能做升序)

规则:如需降序,自行实现reverse

七、二维数组:

概念:一维数组的一维数组,一维数组的元素,还是数组。

语法:

I. 数据类型[][] 数组名;

数组名 = new 数据类型[高维长度][低维长度];

II. 数据类型[][] 数组名 = new 数据类型[高维长度][];//不规则矩形

注意:低维数组必须自行通过new语句创建。

III. 数据类型[][] 数组名;

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

面向对象

一、面向对象思想(Object Oriented Programming):

一切客观存在的事物都是对象,万物皆对象。

对象一定具有自己的特征(属性)和行为(方法)。

二、类:

概念:

I. 在一组相同或类似的对象中,抽取出共性的特征和行为。

II. 类是对象的模板。

现实生活中的对象–(抽象)–>程序中的模板(类)–>

创建程序中的对象–>解决现实问题

类是对象的抽象,对象是类的实例

组成:

I. 属性:(代表对象有什么)

1). 实例变量(成员变量):声明在类的内部,函数的外部,当通过 类构建对象的同时,所有成员变量都成为当前对象不可分割的 特征。

2). 语法:数据类型 属性名;

局部变量 成员变量

定义位置 函数或函数中的结构中 类的内部、函数的外部

默认值 无 字面常量(与数组相同)

使用范围 从定义行到代码块结束 本类有效

命名冲突 不允许与局部变量重名 可与局部变量重名,但局部变量优先

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

II. 方法:(代表对象能做什么)

访问修饰符 返回值类型 方法名称( 形式参数列表 ){

//方法主体

[return value;] //返回值

}

III. 方法重载(Overload):

1). 概念:方法名称相同、参数列表不同(类型、个数、顺序)。

2). 屏蔽使用的差异、灵活、便利。

IV. 构造方法(Constructor):

1). 没有返回值类型。

2). 构造方法名称必须与类名完全相同。

3). 创建对象时,触发构造方法的调用,不可通过句点手动调用。

4). 注意:

a. 在类中,如没有显示定义构造方法,则编译器默认提供无参 构造方法。

b. 如显示定义过构造方法,则无参构造方法不再默认提供。

c. 构造方法可以重载,遵循重载规则。

d. 通过关键字new对象时,根据传入不同的参数,调用对应的 构造方法,完成对象的创建。

e. 有参构造方法可在创建对象的同时,为各个属性赋值,或完 成必要的初始行为。

三、对象:

概念:

I. 具有多个特征和行为的实体。

II. 对象是类的实例。

创建对象:

I. 语法:数据类型 对象名 = new 数据类型();

II. 空间的分配:栈分配局部变量空间,堆分配对象空间。

III. 属性默认值:基本为对应的零值,引用为null。

四、访问属性和方法:

引用(存储对象的局部变量)中保存的是对象的具体地址。(reference)

通过引用访问对象的属性和方法:

Dog d1 = new Dog();

d1.breed = “拉布拉多”;//赋值

d1.breed //取值

d1.eat(); //调用方法

五、this关键字:

当前实例,当成员变量与局部变量重名时,如需使用成员变量,应增 加this.前缀。例如:this.name this.age

通过this()或this(实参)调用本类中的其他构造方法,但必须是构造方 法的首行。

构造方法之间可以相互调用,但最终产生的对象只有一个。每new一 次,只有一个对象。

六、数据的传递(赋值):

值传递:基本数据类型,传递的是值,一方改变不会影响另乙方。

引用传递:引用数据类型,传递的是地址,一方改变另一方也会变。

面向对象三大特性

一、封装:

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

实现步骤:

I. 私有属性:private修饰属性名称。

II. 访问方法:public修饰setXXX()、getXXX()方法。

访问形式:

I. 封装前:

1). 赋值:s1.age = 30000;

2). 取值:s1.age

II. 封装后:

1). 赋值:s1.setAge(30000);

2). 取值:s1.getAge();

二、继承:

概念:类与类满足is a的关系,子类(派生类)是一种父类(超类、 基类)。

父类的抽象:

I. 父类:在一组相同或类似的类中,抽取共性的特征和行为。

II. 功能越精细、重合点越多,越贴近直接父类。

III. 功能越粗略、重合点越少,越贴近Object类。

IV. 将多个子类中共性的特征和行为,定义在父类中实现重用。

继承语法:子类 extends 父类{}

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

Java为单继承:一个类只能有一个直接父类,但可以多级继承。

不可继承:

I. private修饰的私有属性和方法。

II. 构造方法。

III. 非同包时,由default修饰的属性和方法。

访问修饰符(访问可见性):

本类 同包 非同包 子类 其他

private yes

default yes yes

protected yes yes yes

public yes yes yes yes

注意:default:管理的范围是包(package),只要在同一个包中即可 访问。

方法覆盖(Override 重写):

I. 当父类提供的方法无法满足子类需求时,可在子类中声明和父类完 全相同的方法进行覆盖。

II. 子类覆盖父类方法后,在实际调用中,优先调用子类覆盖后的方法。

III. 子类覆盖父类方法时,访问修饰符必须与父类相同或比父类更宽 泛。

super关键字:

I. 在子类中,可以通过super.访问父类中所定义的属性和方法。

II. super()或super(实参)在子类构造方法中,显示调用父类构造方法, 但必须是构造方法的首行。

III. 子类构造方法中如没有显示调用父类构造方法,则编译器默认提供 super(),调用父类无参构造方法。

继承关系的初始化:构造子类对象时,先构建父类对象

I. 分配空间。

II. 初始化父类属性

III. 执行完毕父类构造方法

IV. 初始化子类属性

V. 执行完毕子类构造方法

三、多态:

概念:父类引用指向子类对象,从而产生多种形态。

语法:父类类型 引用名称 = new 子类类型();

注:仅可调用父类中所声明的属性和方法、而不可调用子类独有的属 性和方法。

应用方式(1.继承、2.覆盖):

I. 使用父类作为方法形参,实现多态。(可以让一个方法的参数类型 的个数更宽泛)

II. 使用父类作为方法返回值,实现多态。(返回值可以是任意子类类 型)

作用:

I. 屏蔽子类间的差异。

II. 灵活、耦合度低。

对象间的类型转换:

I. 父类引用中保存子类的真实实例,称为向上转型(装箱)。

例如:Animal a = new Dog(); Vehicle veh = new Bus();

II. 将父类引用中的真实子类实例,强制转换回其本身类型,称为向下 转型(拆箱)

例如:Dog dog = (Dog)a; Bus bus = (Bus)veh;

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

instanceof关键字:

I. 语法:父类引用 instanceof 子类类型

II. 语义:布尔表达式判断引用中的对象是否与子类类型匹配

三个修饰符

一、static(静态):

概念:

I. static修饰符表示类成员、全类所有对象共享的成员。

II. 不必创建对象,可直接通过类名调用。

静态属性、静态方法(类属性、类方法):

I. 全类共享(不属于某一个对象)。

II. 访问方式:类名.静态成员名称。

//Math.random()、Math.sqrt()、System.out、Arrays.copyOf()、 Arrays.sort()、System.arraycopy()

III. 所有引用调用的静态属性和方法都会自动转换成类名调用。

静态方法可以继承,没有多态。

静态方法不能直接访问非静态的成员:

I. 原因1:当访问静态方法时,可能还没有对象的产生。

II. 原因2:实例属性和方法都默认拥有this前缀,代表当前实例,然 而静态方法不属于某个实例。

静态代码块:

I. 类加载时被执行一次,不能手动调用。

II. 类加载(ClassLoading):

1). JVM首次使用(new对象、调用静态成员、使用子类时、 Class.forName(“全限定名”);)某个类时,通过CLASSPATH查找该 类的.class文件。

2). 将.class文件中所有的描述信息(属性、方法、构造方法)加载 到内存中,进行保存。

3). 优先加载,可为静态属性赋值,或任何程序必要的初始行为。

类加载以及创建对象的十步操作:

I. 类级别:

1). 父类静态属性

2). 父类静态代码块

3). 子类静态属性

4). 子类静态代码块

II. 对象级别:

5). 父类实例属性

6). 父类动态代码块

7). 父类构造方法

8). 子类实例属性

9). 子类动态代码块

10).子类构造方法

二、abstract(抽象):

修饰类:不能new对象(往往父类是不该被创建成对象的)。

修饰方法:只有方法声明,没有方法实现的(必须包含在一个抽象类 中)

注意:

I. 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类。

II. 子类继承抽象类后,必须实现父类中所有的抽象方法,否则子类还 是抽象类。

三、final(最终):

修饰类:此类不能被继承。(String、Math、System)

修饰方法:此方法不能被覆盖。

修饰变量:此变量的值不可改变(常量)。

I. 没有初始值,必须手动赋值。

II. 实例常量:显示初始化、动态代码块、构造方法(创建对象完成前)

III. 静态常量:显示初始化、静态代码块(类加载完成前)

IV. 常用public static final联合修饰的变量,称为公开静态常量。

V. 基本数据类型:值不可变;引用数据类型:地址不可变。

接口

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

二、语法:

定义接口:interface 接口名称{}

实现接口:implements 接口名称{}

三、与抽象类的异同:

I. 相同:

1). 不能new对象。

2). 都可以编译成字节码文件。

3). 都可以作为引用类型。

Java基础知识点总结

II. 不同:

1). 所有属性都是公开静态常量,隐式使用public static final修饰。

2). 接口中所有方法都是公开抽象方法,隐式使用public abstract修饰

3). 没有构造方法、没有动态、静态代码块。

四、关系:

类与类:单继承

类与接口:多实现

接口与接口:多继承

注意:一个类在继承父类的同时,还可以实现多个接口。

五、规范:

任何类在实现接口的同时,必须实现接口中所有的抽象方法,否则该 类还是抽象类。

实现接口中的抽象方法,访问修饰符必须是public。

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

七、接口引用:

接口引用指向实现类对象,仅可调用接口中所声明的方法。

使用接口作为方法形参,可更自然的使用多态。

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

九、好处:

设计与实现完全分离。

更容易搭建程序框架。

更容易更换实现。

程序的耦合降低。

常用类

一、内部类:

概念:

I. 在类的内部再定义一个类。

II. 内部类编译之后会生成字节码文件。

III. 内部类可以访问外部类的私有成员、而不破坏封装。

分类:

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类:

概念:

I. 超类、基类、所有类直接或间接的父类,位于继承树的顶层。

II. 任何类,如没有书写extends显示继承,则默认直接继承Object。

III. Object所定义的方法,是所有对象有具有的方法。

IV. Object类型可以存储任何对象,作为参数、可接收任何对象;作为 返回值,可返回任何对象。

方法:

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):

自动:JVM内存耗尽,自动回收。

手动:System.gc(),通知JVM执行回收(优先级较低)。

三、包装类:

概念:

I. 8种基本数据所对应的引用数据类型。

II. Object可统一所有数据,默认值为null。

匹配:

byte —> Byte

short —> Short

int —> Integer

long —> Long

float —> Float

double —> Double

char —> Character

boolean —> Boolean

类型转换:

I. Number父类中继承到的6个转型方法。

II. 构造方法。

III. parseXXX(String s) //静态方法,将字符串转换成基本类型

IV. valueOf() //静态方法,将基本或字符串转换成包装类型

V. 注意兼容类型,避免NumberFormatException异常。

VI.JDK5之后,自动装箱、拆箱。包装类型与基本类型可自动转换。

四、String:

概念:

I. 字符串是常量,创建之后不可改变。

II. 字符串字面值存储在字符串池中,可以共享。

创建:

String s1 = “abc”;

String s2 = new String(“abc”);

方法:

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()

可变字符串:

I. StringBuffer:JDK1.0推出,操作速度慢、线程安全。

II. StringBuilder:JDK5推出,操作速度快、线程不安全。

III. 常用方法:append(?); //追加

集合框架

一、概念:

对象的容器,存储对象的对象,大多数情况下,可代替数组。

位置:java.util.*;

结构:

二、Collection体系集合详解:

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数组。

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)后进后出->先进先出

三、泛型集合【重点】:

参数化类型、类型安全的集合,限制元素的类型必须一致。

编译期即可检查数据类型。

访问时,不必拆箱。

不同泛型之间不可相互赋值,泛型不存在多态。

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

特点:无序、无下标、元素不可重复。

方法:全部继承自Collection。

实现类:

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接口:

特点:存储一对数据(key-value),无序、无下标,键不能重复、值 可以重复。通过建访问值(通过key访问value)。

方法:

V put(K key, V value) //将关联的键和值一并存储

V get(Object key) //通过建访问值

V remove(Object key) //通过键移除整个键值对

Set keySet() //获取所有的键

Collection values() //获取所有的值

Set entrySet() //获取所有的键加值(格式为:“key=value”)

实现类:

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:受查异常,编译期检查,必须处理。

三、异常的产生:

自动抛出:程序在运行时遇到不符合规范的代码或结果,则产生异常。

手动抛出:throw 异常对象;

异常产生的结果:相当于遇到了return语句,导致程序因异常而中止。

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

五、异常的处理:

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

方式:

I. 消极处理:throws 声明异常,修饰在方法参数列表的后端。

public void method() throws Exception{}

注:

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

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

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{}

六、自定义异常:

继承Exception或Exception的子类,常用RuntimeException。

继承受查异常之后,抛出的异常通常不直接处理,以throws声明异常 的形式,告知调用者处理。

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

遵循覆盖语法。

子类覆盖父类带有异常声明的方法时,不可抛出比父类更宽泛的异常。

子类可以声明的异常必须 <= 父类声明的异常

I/O框架

一、流:(Input / Output)

概念:流(对象)是在内存与存储设备之间传输数据的通道。

分类:

I. 方向:

1). 输出流:用以将<内存>中的数据写入到<存储设备>中。

2). 输入流:用以将<存储设备>中的数据读入到<内存>中。

II. 单位:

1). 字节流:可以读写所有数据。

2). 字符流:只能读写文本数据。

III. 功能:

1). 节点流:实际传输数据。

2). 过滤流:增强节点流功能(处理流、装饰类)。

二、字节流:

字节流父类:

I. OutputStream(输出流)

II. InputStream(输入流)

字节节点流【重点】:

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个)

字节过滤流:

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表示到达文件末尾,可处理。

三、字符编码:

ISO-8859-1 除收录ASCII外,还包括西欧、希腊、泰国、阿拉伯、 希伯来对应的文字符号。

UTF-8 针对Unicode的可变长字符编码。

GB2312 简体中文。陶喆(陶吉吉)

GBK 简体中文扩充版。

BIG5 台湾繁体中文。

注意:字符编码和字符解码不一致时,可能造成乱码。

四、字符流:

字符流父类:

I. Wrietr(输出流)

II. Reader(输入流)

字符节点流【重点】:

I. FileWriter:

public void write(String str) //一次写一个字符串

II. FileReader:

public int read() //一次读一个字符

public int read(char[] c) //一次读一组字符

字符过滤流:

I. PrintWriter / BufferedReader:缓冲流,支持一次写一行、读一行。

II. OutputStreamWriter / InputStreamReader:

桥转换流:用以将字节流转换成字符串,并设置编码格式。

使用步骤:

I. 创建节点流。

II. [ 包装过滤流 ]。

III. 读写数据。

IV. 关闭流。

五、File对象:

概念:File代表物理盘符下的一个文件或者文件夹。

方法:参考API。

I. public Files[] listFiles();//获取当前路径下的所有File对象。

II. public Files[] listFiles(FileFilter filter); //文件过滤器

FileFilter接口:

实现:boolean accept(File file) //使满足条件的文件对象,出现在listFile() 方法的返回值中(File数组)。

多线程

一、进程:

概念:

I. 程序是静止的概念,而进程是程序的实体,在CPU执行时,才被 赋予生命,只有当程序真正的running时,被称为进程。

II. 在任何时间点、时间戳,只能有一个进程在执行,宏观并行、微观 串行。

二、线程:

概念:

I. 轻量级进程(Light Weight Process LWP),代表进程中一个单一的 顺序控制流程。

II. CPU调用的基本单位是线程(调用某一进程中的某一线程)。

III. 在单个进程中“同时”运行多个线程完成不同的工作,交替执行, 称为多线程。

组成:

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() //将其他线程加入到自身线程中,优先执行

三、线程同步【重点】:

线程不安全:当多线程并发访问临界资源时,如果破坏原子操作,可 能造成数据不一致。

I. 临界资源:共享资源(同一对象)。

II. 原子操作:不可分割的多个步骤,被视为一个整体,其顺序不可打 乱或缺省。

互斥锁标记:每个对象都有一个互斥锁标记,用来分配给线程的。

锁池:每个对象都有一个锁池,用来存储等待该对象锁标记的线程的

同步方式【重点】:

1). 同步代码块:

synchronized(临界资源){ //可为临界资源加锁

//原子操作

}

2). 同步方法:

synchronized 返回值类型 方法名称(形参列表){

//原子操作

}

注:在调用同步方法时,需要对象的锁标记,而调用非同步方法时, 不需要锁标记,可直接访问。

ArrayList操作速度快,线程不安全(支持并发访问,非同步方法)

Vector 操作速度慢,线程安全(同步方法)

synchronized add()

remove()

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

反射

一、概念:

类的对象:基于某个类new出来的一个实例,也称为实例对象。new Dog

类对象:封装了一个类的所有信息(包名、类名、父类、接口、属性、 方法、构造方法…)。Student.class

注意:类对象就是一个.class文件,当中包含了一个类的所有信息!

获取类对象:

//1.通过类型直接获取类对象

Class c1 = Student.class;//类对象

//2.以静态方法的形式获取类对象

Class c2 = Class.forName(“ref.Student”);

//3.通过类的实例对象获取类对象

Student stu = new Student();

Class c3 = stu.getClass();

反射的应用:

//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(“此方法隶属于的对象”,“可变长实参”);

四、单例模式:

概念:一个类,只能有一个对象。

实现方式:

I. 饿汉式(类加载时创建,天生线程安全)

II. 懒汉式(使用时创建,线程不安全,需添加同步)

`

Java 数据结构

版权声明:本文内容由网络用户投稿,版权归原作者所有,本站不拥有其著作权,亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容,请联系我们jiasou666@gmail.com 处理,核实后本网站将在24小时内删除侵权内容。

上一篇:Kubernetes集群调度器原理剖析及思考
下一篇:A*基础介绍
相关文章