项目生命周期的相关介绍(项目生命周期的内容)
597
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). 都可以作为引用类型。
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小时内删除侵权内容。