【JavaSE 基础知识盲点小结】
一、第一天:
1. 在 cmd 命令窗口问题:
①编译是: javac HelloWorld.java
②运行时是: java HelloWorld (类名 不加 .class)
2. 编码和解码问题:
字符转换为二进制机器语言 是编码 反过来 是解码;
①编码的过程:字符转换为二进制的数值;
②解码的过程:二进制的数值转换为字符
3. 解决乱码问题:
在 cmd 命令窗口编译时: javac -encoding UTF-8
等类似加入 -encoding UTF-8
的操作
①-d
参数表示指定存放文档的目录(javadoc 命令可以自动创建这个目录)
②-encoding
参数可以指定编码字符集
4. 源文件与类名一致问题:
①如果是 public 类的:源文件名与类名保持一致;
②如果不是 public 类的:源文件可以与类名不一致
5. 源文件可以有多个类问题:
一个源文件可以有多个类 编译后生成多个 .class字节码文件;一个源文件只能有一个 public 的类
6. 命名规则问题:
只能使用26个字母 0~9的数字 下划线 美元符号$;
①类名,接口名:XxxYyyZzz ;
②变量,方法名:xxxYyyZzz ;
③包名:xxx.yyy.zzz (包的命名规则还包括:域名倒序.项目名称.模块名称.当前包自己的具体名称);
④常量名:XXX_YYY_ZZZ
二、第二天:
1. 类,接口,数组,属于引用数据类型
2. 常量问题:
①自定义常量:通过 final 关键字来定义
②字面值常量:字符串常量(要用""双引号括起来),整数常量(默认是 int 类型 超过int类型范围末尾加入 L 就以长整型范围输出),浮点常量(默认是 double 类型,加上 F 表示以 float 类型输出),字符常量(要用’ '单引号括起来),布尔常量,空常量。
3. 变量问题:
变量使用前必须初始化
4. 进制的表示问题:
①二进制:0b 或 0B 开头
②八进制:0 开头
③十六进制:0x 或 0X 开头
5. 字节问题:
字节有八位,以 byte 字节类型为例,最高位是符号位1是负号 0是正号
①负数的范围:
1000 0001 是 -1
1000 0000 是 -128(特殊规定)
②正数的范围:
0000 0000 是 0
0111 1111 是 127
6. 原码、补码、反码问题:
计算机存储以补码形式,计算机只有加法,以补码的加法算实际的减法,最高位是符号位,1是负数 0是正数,并有如下规定:
- 正数的补码与反码,原码一样,称为三码合一;
- 负数的补码与反码,原码不一样;
- 负数的原码:把十进制转换为二进制,然后把最高位设置为一;
- 负数的反码:在原码的基础上,最高位不变,其余取反;
- 负数的补码:反码加一;
7. 转义字符问题:
\r; | 回车 覆盖最前方 |
\" | " 双引号 |
\’ | ’ 单引号 |
\b | 删除键 Backspace |
\u | 转为字符的 Unicode 编码值的十六进制型 ‘\u5c1a’ |
8. 字符问题:
直接给 char 类型变量赋值十进制的 0~65535 之间的 Unicode 编码值就可以出现字符
9. 基本数据类型转换问题:
- ①隐式类型转换:
类型 | 占用内存 |
---|---|
byte | 1字节 |
short | 2字节 |
char | 2字节 |
int | 4字节 |
long | 8字节 |
float | 4字节 |
double | 8字节 |
当 byte,short,char 数据类型进行算术运算时,按照 int 类型处理
- ②显式类型转换:
转后类型 变量名 = (转后类型)要转换的数据
- ③特殊的数据类型转换:String 类型 想转换为基本数据类型不能强制类型转换,需要调用包装类型的方法来转换
三、第三天:
1. 取模问题:
取模也叫取余 被取模的数值为负时,取模的结果也为负
取模结果是正数还是负数看被取模的数值是正数还是负数
小数取模结果可能是小数
2. 比较运算符:" instanceof " :
①运算:检查是否是类的对象
②规范:"Hello"instanceof String
③ 结果:true
3. 逻辑运算符:
符号 | 含义 |
---|---|
& | 逻辑与(且) |
或(竖) | 逻辑或 |
^ | 逻辑异或(不同返回true) |
4. 位运算算符:
运算符 | 运算 | 范例 | 运算结果 |
---|---|---|---|
<< | 左移 | 3<<2 | 12 |
>> | 右移 | 4>>1 | 2 |
>>> | 无符号右移 | 3>>>1 | 1 |
& | 按位与 | 6&3 | 2 |
或 | 按位或 | 6 或 3 | 7 |
^ | 按位异或 | 6^3 | 5 |
- | 按位取反 | -6 | -7 |
“或” 是: “|” 符号
运算符 | 运算方式 |
---|---|
<< | 空位补0,被移除的高位丢弃,空缺位补0。 |
>> | 当最高位是0,右移后,空缺位补0,当最高位是1,空缺位补1。 |
>>> | 被移位二进制最高位无论是0或者是1,空缺位都用0补。 |
& | 二进制位进行&运算,只有1&1时结果是1,否则是0; |
“或” | 二进制位进行"或"运算,只有0"或"0时结果是0,否则是1; |
^ | 二进制位相同是0,二进制位不同是1 |
~ | 按补码取反 |
四、第四天:
1. break 的用法:
当一个 switch 语句中出现在循环中,switch 语句中使用 break 只能能对 switch 语句有效,对循环无效。
2. return 的用法:
操作遇到 return 会结束,值遇到 return 会返回值
五、第五天:
1. 介绍 Utility 工具类:
方法的调用方式 | 方法的作用 |
---|---|
Utility.readMenuSelection() | 读取菜单序号:1. 2. 3. 4. … |
Utility.readNumber() | 读取金额数值(数字) |
Utility.readString() | 读取文字(字符串) |
Utility.readConfirmSelection() | 读取确认是否退出时输入的 y 或者 n |
Utility.readKeyBoard(int limit) | 从键盘读取 limit 个字符(限制个数) |
2. IDEA 快捷键:(具体内容参阅【JavaSE 第五天】)
3. 数组的静态创建与动态创建问题:
①动态初始化:数组声明且为数组元素分配空间与赋值的操作分开进行
②静态初始化:在定义数组的同时就为数组元素分配空间并赋值
4. 关于数组问题:
(1)数组本身是引用数据类型,而数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型
(2)创建数组对象会内存中开辟一整块连续的空间,而数组名中引用的是这块连续空间的首地址
(3)按照元素的数据类型区分数组:①基本数据类型元素的数组,②引用数据类型的数组(即对象数组)
(4)数组是引用类型,他的元素相当于类的成员变量,因此数组一经分配空间,其中的每一个元素也被按照成员变量同样的方式被隐式初始化
数组元素类型 | 元素默认初始值 |
---|---|
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
float | 0.0F |
double | 0.0 |
char | 0或写为:‘\u0000’(表现为空) |
boolean | false |
引用类型 | null |
六、第六天:
1. 数组中转移变量问题:
仅仅将变量值中的 地址值 传给了另一个数组所以这时另一个数组也会指向该地址值下的数据(就相当于多了一个访问数据的入口),通过另一个变量访问数组元素仍然可以读取或者是更改数据
2. 数组变量指向新数组对象问题:
就相当与整个变量的地址值更改并抛弃原地址(将来会被垃圾回收,释放掉,数据全部丢失)
3. 多维数组的底层是内存存储结构
4. 多维数组的理解:
在多维数组声明并创建完毕后,需要 new (例如:格式2,格式3… … 另外只有在初始化完成后才能访问具体数据(读,写))低一维度的数组,将他的地址值存入比他高一维度的“堆内存”中,之后就是一级一级的嵌套,直到最后是最终数据在一维数组中(具体内容参阅【JavaSE 第六天】和【JavaSE 第七天】)
5. 二维数组特殊写法情况: x 是一维数组,y 是二维数组:int[] x,y[];
七、第七天:
1. Arrays 工具类的使用:
名称 | 作用 |
---|---|
boolean equals(int[] a,int[] b) | 判断两个数组是否相等 |
String toString(int[] a) | 输出数组信息 |
void sort(int[] a) | 对数组进行排序 |
void fill(int[] a,int vall) | 将指定值填充到数组之中 |
int binarySearch(int[] a,int key) | 对排序后的数组进行二分法检索指定的值 |
2. Java 类及类的成员,面向过程、面向对象的不同称谓:
Field = 属性 = 成员变量, Method = (成员)方法 = 函数
英文名 | 面向过程的角度 | 面向对象的角度 |
---|---|---|
Filed | 成员变量 | 属性 |
Method | 成员函数 | 方法 |
3. 权限修饰符:
修饰符名称 | 含义 | 本类 | 同包其他类 | 子类 | 同工程其他类 |
---|---|---|---|---|---|
private | 私有 | 可以使用 | 不可使用 | 不可使用 | 不可使用 |
default | 缺省 | 可以使用 | 可以使用 | 不可使用 | 不可使用 |
protected | 受保护 | 可以使用 | 可以使用 | 可以使用 | 不可使用 |
public | 公共 | 可以使用 | 可以使用 | 可以使用 | 可以使用 |
对于 class (类) 的权限修饰符只可以用 public 和 default (缺省)
4. 变量的分类:成员变量与局部变量问题:
①在方法体外,类体内声明的变量称为成员变量
②在方法体内部声明的变量称为局部变量
③成员变量包含(①实例变量(不以static修饰)和 ②类变量(以static修饰))
④局部变量包含(①形参(方法、构造器中定义的变量)和 ②方法局部变量(在方法内定义)和 ③代码块局部i变量(在代码块内定义))
成员变量和局部变量的区别:
成员变量 | 局部变量 | |
---|---|---|
声明的位置 | 直接声明在类中 | 方法形参或内部,代码块,构造器等 |
修饰符 | private,public,static,final等 | 不能用权限修饰符修饰,可以用 final 修饰 |
初始化值 | 有默认初始化值 | 没有默认初始化值,必须显式赋值,方可使用 |
内存加载位置 | 堆空间 或 静态域内 | 栈空间 |
5. Math 类的常用方法:
①生成随机数:Math.random()
,返回值类型 double;
②四舍五入取整:Math.round(double d)
,返回值类型 long。
八、第八天:
1. 方法重载的规则限制:
①参数列表要求不同:参数个数和参数类型(二选一不同 或 都不同)(参数类型相同,但顺序不同也可以算重载)
② 不能根据返回值类型判断(不看返回值)
2. 方法可变参数的语法规则:
①声明格式:方法名(参数的类型名...参数名)
②可变参数方法的使用与方法参数部分使用数组是一致的
③方法的参数部分有可变参数,需要放在形参声明的最后
④在一个方法的形参位置,最多只能声明一个可变个数形参
⑤可以将数组传递给可变参数列表
⑥数组作为参数时,不能将多个值传递给数组(解释:数组传递是地址值的传递)(可变参数可以兼容数组参数,但数组参数无法兼容可变参数。当试图使用数组作为参数去实现重载时,会报错,说明可变参数与数组冲突)
⑦方法名相同,一个参数是可变参数,一个参数是一维数组,这两个方法不是重载,因为一个可变参数等价于相应类型的一维数组,就可以对可变参数列表,进行相应的数组操作,比如求长度
⑧可变参数列表所在的方法,是最后被执行访问的。举例:Ⅰ、调用方法 add(5, 3)
Ⅱ、可变参数方法:add(int ... args)
Ⅲ、具体参数方法:add(int i, int j)
【系统会调用这个方法】
2. 方法参数的值传递机制问题:
①Java 的实参值传入方法:值传递(Java 里方法的参数传递方式只有一种:值传递。即将实际参数值的副本(复制品)传入方法内,而参数本身不受影响。)
②Java 中形参值传入方法:Ⅰ、形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参; Ⅱ、形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参
3. 信息的封装和隐藏操作:
Java 中通过将数据声明为私有的(private),再提供公共的(public)方法:getXxx()
和 setXxx()
实现对该属性的操作
4. 构造器的特征:
①它具有与类相同的名称。
②它不声明返回值类型。(与声明 void 不同)
③它不能被 static ,final ,synchronized ,abstract ,native 修饰,不能有 return 语句返回值。
④初始化操作放到构造器里面,由构造器自动完成,程序员就不必在创建对象后还想着对这对象做初始化操作。
⑤一个类可以有多个构造器:根据参数列表的不同,多个构造器之间是重载的关系。
⑥父类的构造器不可被子类继承
5. 类的属性赋值的顺序:
①默认初始化
②显式初始化
③构造器中初始化
④通过 “ 对象.属性 ” 或 “ 对象.方法 ” 的方式赋值
6. JavaBean 是指符合如下标准的 Java 类:
①类是公共的
②有一个无参的公共的构造器
③有私有属性值,针对私有属性设置的公共的 getter()
、setter()
方法
7. this 关键字:
①它在方法内部使用,即这个方法所属的对象的引用;它在构造器内部使用,表示该构造器正在初始化的对象
②this 可以调用类的Ⅰ属性、Ⅱ方法 和 Ⅲ构造器
8. this 调用构造器的规则:
①可以在类的构造器中使用 this (参数列表)
的方式,调用本类中重载的其他构造器
②在构造器中调用其他构造器,this (无/参数列表)
语句必须在第一行
③明确:构造器中不能通过 this (参数列表)
的方式调用自身构造器
④在类的一个构造器中,最多只能声明一个 this (参数列表)
,且不能构成死循环
9. package 关键字:
①格式为:package 顶层包名.子包名;
②package 声明所在包的语句必须是在类的第一行。若缺省该语句,则指定为无名包
10. import 关键字:
①语法格式:import 包名.类名
②精确导入:Ⅰ、在 import 关键字后面指定全类名: import java.util.Scanner;
;Ⅱ、全部导入:在 import 关键字后面指定包名.* :import java.util.*;
③语法规则:Ⅰ、如果导入的类或接口时 java.lang
包下的,或者是当前包下的,则可以省略此 import 语句;Ⅱ、如果已经导入 java.a
包下的类,那么如果需要使用 a 包的子包下的类的话,仍需要导入;Ⅲ、import static
组合的使用,调用指定类或接口下的静态的属性或方法(静态导入。让当前类可以直接调用导入的类中的静态属性或方法,不必写类名。)
九、第九天:
1. 继承后成员变量的特点:
子类和父类的成员变量同名的情况:子类自己有,使用自己的,子类没有,使用父类
2. 方法中的局部变量与类中的成员变量同名的情况:
①在方法内部 用 this.
区分成员变量和局部变量
②在方法内部 用 super.
调用父类的成员变量
3. 重写与重载的区别:重载实现于一个类中、重写实现于子类中
①重写(Override)是父类与子类之间多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Override)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被“屏蔽”了。
②重载(Overload)是一个类中多态性的一种表现。如果在一个类中定义了多个同名的方法,它们参数列表不同,则称为方法的重载。
4. 方法重写的问题:
①权限问题:保证子类的权限要大于或者等于父类的方法权限(具体内容参阅【JavaSE 第九天】)
②如果父类的方法权限是 private,子类不知道该方法的存在,没有继承的说法。(不存在重写),这时四个写法都会正确,但并不是方法重写。
5. 继承后构造器的特点:
①构造方法特点 : 子类的构造方法(构造器)中,第一行存在隐式代码,代码是 super();
,作用是调用父类的无参数构造方法(构造器)。(并且 super();
与后续的代码不能换位置,必须在构造方法(构造器)的第一行。)
②父类中没有无参数构造方法的情况(自己显式定义了新的构造方法,默认的隐式构造方法(无参的构造方法)消失),子类的构造方法中要用 super(传递参数);
因为父类中没有无参构造方法,所以要传递相应的参数
③父类中存在多个构造方法,子类的构造方法只要调用到其中的一个即可(必须调用,至少一个)
十、第十天:
1. 对象多态性前提:
①必须有继承或者是接口实现
②必须有方法的重写
2. 多态的语法规则:
父类或者接口的引用指向自己的子类的对象。写法:父类 变量(对象名) = new 子类对象();
3. 多态中成员的特点:
简记:成员方法编译看左边(父类),运行看右边(子类)。成员变量都是左边(父类)。(Person p = new Student();
)
①多态当中成员变量的特点:
Ⅰ、编译:如果父类中没有成员变量,编译失败
Ⅱ、运行:如果父类和子类都有成员变量,运行父类中的成员变量
②多态中成员方法的特点:
Ⅰ、编译:如果父类中没有成员方法,编译失败
Ⅱ、运行:如果父类和子类都有成员方法,运行子类的方法重写
4. 多态的转型问题:
多态的程序中,不能调用子类的特有成员。 需要使用子类的特有成员,必须进行强制类型转换:转后类型 变量名 = (转后类型)要转换的数据
5. 多态转型下容易出现异常,解决异常的安全写法:
对象名 instanceof 类的名字
,比较这个对象,是不是由这个类产生的
6. 抽象类的使用时注意:
①创建子类对象(共两类:一种是使用多态性创建对象,一种是只利用子类创建对象)
②(建议)使用多态性创建对象,调用方法执行子类的重写
③抽象类中,可以不定义抽象方法,但是,如果有抽象方法存在,这个类必须是抽象类
7. 接口的相关问题:
①当一个抽象类中的所有方法全部都是抽象方法的时候,这个抽象类就叫做接口,接口是特殊的抽象类。
②接口中成员变量的修饰符是固定的: public static final
③成员方法的修饰符是固定的: public abstract
十一、第十一天:
1. 静态成员内存的特点:
①静态成员跟随自己的类进入元数据区(且是进入其中的静态区)
②静态成员属于自己的类,不属于对象
③静态成员进入内存后赋为默认值
④静态成员变量的初始化实际早于对象
2. 静态成员的调用方式:
①静态成员调用方式只有类名调用(当创建对象后进行对象调用静态成员时,会出现警告,但并不是错误,javac 编译时会自动改为类名的调用(.class 文件的反编译 javap ))
②非静态成员调用只有对象调用
3. 静态方法问题:
①静态方法直接类名调用,静态方法中不能直接使用(调用) 非静态成员(可以间接调用)而非静态可以直接调用静态
②由于静态在内存中优先于对象进入,所以在静态对象方法中不能使用 this(当前对象引用)
和 super(子类对象的空间标识)
来进行调用
4. 详解受保护权限 protected :
①权限的成员,为子类提供使用
②Object 类是所有类的父类,类中的方法权限有 public 和 protected
③protected 有一个关键的使用方式:受保护权限的方法只能是子类使用 super 调用,子类对象不能调用,不能出子类
5. final 修饰符:
① final 可以修饰:类、方法、成员变量、局部变量,(绝大多数东西都可以修饰)(接口不可以修饰,但是接口里面的东西可以修饰
final 修饰类
②被 final 修饰的类,称为最终类,不能被其他的类继承,无子类。
③被 final 修饰的类有:String、System、Scanner 等
final 修饰局部变量
④ final 修饰的基本数据类型,锁死值
⑤ final 修饰的引用数据类型,锁死内存地址 (引用类型中的成员不受影响)
⑥ final 修饰了方法的参数(参数列表),调用者传递值后,方法的参数值就锁死
final 修饰成员变量
⑦成员变量的定义位置很特别,是在类中,且在方法外面,成员变量在内存中有默认值。final 修饰成员变量的时候,锁住的不是内存默认值,而是程序人员手动的赋值。
⑧ final 修饰的成员变量,Ⅰ、可以直接赋值、Ⅱ、可以构造方法(构造器)赋值,Ⅲ、不能使用 set 方法赋值
6. 静态代码块:
①写在类中,却在方法外面:static {}
②静态代码块的执行时机:只要使用了这个类的成员(①new 对象、②调用静态方法、③调用静态变量 等),静态代码块就会执行,而且就执行一次
7. 构造代码块:
①写在类中,却在方法外面的 “ {} ”, 创建对象的时候运行,new 对象一次,运行一次
②构造代码块的运行优先级高于构造器
8. 局部代码块:
① 写在方法内部的 “ {} ” 就是局部代码块,基本极少用到,用处不大。
②可以用来限制变量的生存周期
③其实 if 判断语句和 for 循环语句中的 “ {} ” 就是局部代码块
9. 成员内部类问题:(具体内容参阅【JavaSE 第十一天】)
①成员内部类,是一个类定义在了另一个类的成员位置,这个内部类可以使用成员修饰符,public 、static 、final 、private 。(可以相当于成员变量来写)
②对于内部类:可以直接使用外部类的成员,如果外部类要使用内部类的成员,必须要创建对象。
③主要使用的:非静态调用方式:公式:外部类名.内部类名 = new 外部类对象().new 内部类对象
,相关知识:Ⅰ、内部类 Inner ,编译后有 class 文件:名字是:外部类$内部类Ⅱ、内部类也是类,可以继承 Object 类,可以实现接口
④内部类是静态的调用方式 : 外部类名.内部类名 变量名 = new 外部类.内部类()
10. 在内部类中的方法调用局部或成员变量打印时:(具体内容参阅【JavaSE 第十一天】)
①直接打印就会打印距离最近的赋值。
②当内部类中的成员变量与局部变量同名时用 this 标识成员变量
③调用外部类的成员变量时:外部类名.this.变量名
11. 局部内部类问题:
①局部内部类:要定义在方法里面。因为方法里面是局部位置,所以不能使用成员修饰符、权限、静态、抽象。 书写格式:class A { public void a(){ {class B{} } }
②局部内部类,访问局部变量,变量必须用 final 修饰
12. 匿名内部类(局部内部类的特殊写法):(具体内容参阅【JavaSE 第十一天】)
①可以简化的部分:实现类、实现接口、重写方法、创建对象,或者是子类继承父类中重写方法、创建对象。
②匿名内部类使用的前提 :Ⅰ、必须有接口实现,或者是类的继承Ⅱ、格式 : new 接口或者父类(){重写抽象方法};
(这种格式 相当于 实现类、实现接口、重写方法、创建对象一系列操作)
13. 非法修饰符组合:主要说的是:abstract(抽象)
① abstract 和 private 是非法组合,抽象方法需要重写,但 private 不能继承,冲突。
② abstract 和 final 是非法组合,抽象方法需要重写,但被 final 修饰不能重写,冲突。
③ abstract 和 static 是非法组合,抽象方法需要重写,但静态方法可以被类名直接调用,冲突(静态方法不能重写)。
十二、第十二天:
1. Object 类问题:
①Object 类定义在了 java.lang 包上, lang 包是核心包,此包中的任何类,在使用的时候不需要 import 导入
②Object 类的构造方法:Object();
但是第一行中不是 super();
③本地方法:Ⅰ、方法的定义使用关键字,修饰符 native
,这个方法就是本地方法。Ⅱ、方法运行的时候,是一个独立的内存 (本地方法栈)。Ⅲ、作用:凡是遇到本地方法,方法的作用是和本机的操作系统交互
2. Object 类的方法 toString()
:
①输出语句中 System.out.println(对象);
(默认)调用对象的 toString();
方法;
②System.out.println(对象);
就相当于: System.out.println( 对象.toString() );
3. Object 类的方法 equals()
:
①作用就是用来比较对象。方法结果是 boolean 值,对象相等就是 true
②源码中:return (this == obj)
就是比较对象的地址(引用数据类型)是不是相同,所以 Object 类的方法 equals()
默认比较对象的内存地址
③可以重写 equals()
方法,建立我们创建的对象的自己的比较方式
4. String 字符串类:
①字符串对象是常量,一旦创建不能修改
②字符串这个数据类型,在 Java 中是不存在的,字符串的实现原理是用 char[]
数组表示。例如:“abc”,这个字符串是使用数组 char[] ch = {'a','b','c'} ;
以这种形式来表示
5. 字节编码:
①字符编码:ASCII, 小写字母 a 的值97,大写字母 A 的值是65,数字是48到57;ASCII 是美国标准信息交换代码,一个字节编码代表一个字符
②中国(GB2312(大约4000个汉字)、GBK(大约20000个汉字,还有少数民族语言)、GB18030(尚未启用)),简体中文的编码表,汉字是用两个字节编码代表,并且两个字节编码都是负数的形式,防止与 ASCII 冲突
③ISO 国际标准化组织:全球的语言放在一个编码表中,万国语言标准:Unicode
④ UTF-8 :存储全球的文字(字节表示变长,但是能用一个字节表示的,绝不用两个字节表示,为了节省资源),在其中汉字用三个字节表示且都是负值
⑤ UTF-16 :定长表示,无论什么字符全部都是两个字节存储
6. 常用的 String 类的构造方法:
①字节数组转成字符串:
String(byte[] b)
字节数组转成字符串,使用平台的默认字符集String(byte[] b,int off,int len)
字节数组转成字符串,使用平台的默认字符集,参数 off 指的是:数组的开始索引,len 指的是:要转的个数String(byte[] b,int off,int,len,String,charsetName)
字节数组转成字符串,使用平台的默认字符集,参数 off 指的是:数组的开始索引,len 指的是:要转的个数,charsetName 参数是自己可以指定编码表
②字符数组转成字符串:
String(char[] b)
字符数组转成字符串String(char[] b,int off,int,len)
字符数组转成字符串,参数 off 数组的开始索引,len 要转的个数
7. String 类的常用方法:
① String 类的判断类型的方法,返回的都是布尔类型
boolean equals(Object obj)
字符串之间的比较,两个字符串相同,返回 true,严格区分大小写boolean equalsIgnoreCase(String str )
字符串之间的比较,两个字符串相同,返回 true,忽略大小写boolean startWith(String str)
判断字符串是否以另一个字符串开头,是开头就返回 true,严格区分大小写boolean endsWith(String str)
判断字符串是否以另一个字符串结尾,是结尾就返回 true,严格区分大小写boolean contains(String str)
判断字符串中是否包含另一个字符串,完全包含返回 true,严格区分大小写boolean isEmpty()
判断字符串的长度是不是0,如果是0返回 true
② String 类的获取方法,返回值不一定(有可能找得到,有可能找不到,有可能有多个,有可能没有)
int length()
返回字符串长度,字符串中字符的个数char charAt(int index)
返回指定索引上的单个字符int indexOf(String str)
返回指定的字符串,在当前字符串中第一次出现的索引int lastIndexOf(String str)
返回指定的字符串,在当前字符串中最后一次出现的索引String substring(int start,int end)
截取字符串,参数表示开始索引和结束索引,包含开头索引,不包含结束索引
③ String 类的转换方法
String toLowerCase()
字符串中的所有内容转成小写String toUpperCase()
字符串中的所有内容转成大写char[] toCharArray()
字符串转成字符数组byte[] getBytes()
字符串转成字节数组 (查询编码表),平台默认字符集byte[] getBytes(String charsetName)
字符串转成字节数组 (查询编码表),指定编码表static String valueOf(任意类型参数)
参数转成字符串对象
④ String 类的比较方法
int compareTo(String str)
字符串之间的比较,谁大谁小,按照字典顺序(自然顺序)(也就是 abcde… 的顺序)
⑤ String 类的方法:去空格、替换、切割
String trim()
去掉字符串两边空格,中间空格不去掉String replace(String oldString,String newString)
替换字符串String[] split("规则字符串")
对字符串进行切割
8. String 类正则表达式相关的功能:(具体内容参阅【JavaSE 第十二天】)
9. StringBuilder 字符串构建器:
①StringBuilder 是字符串对象的缓冲区对象,缓冲区(出现的目的,为了高效)提高 String 类的效率。
②实现原理:一个可变的字符序列,字符序列就是字符数组。char[] value;
③字符序列是数组,Java 数组是定长的,一旦创建,长度固定 。
④创建对象的时候,StringBuilder 中的数组的初始化长度为16个字符
⑤出现无法容纳问题的时候, StringBuilder 自动的进行数组的扩容,新创建一个数组,并且是开始数组的两倍,新数组实现,原来数组的中元素复制到新的数组,并且原数组被内存废弃销毁。StringBuilder 内部永远只有一个数组
⑥StringBuilder 类是线程不安全的类,运行速度快,推荐使用StringBuilder 。
⑦StringBuffer 是线程安全的类,运行速度慢,多线程的程序中使用。 这两个类的构造方法,和其他的方法都一模一样。
十三、第十三天
1. StringBuilder 类的常用方法:
StringBuilder append(任意类型)
参数追加形成字符串,无论参数写的是什么,变成字符串。相当于是字符串里面的“+” 运算StringBuilder append(任意类型)
可以使用链式编程:保证一个方法的返回值是一个对象,再使用这个对象调用的调用方法:对象.方法().方法().方法()......
StringBuilder insert(int 索引, 任意类型)
可以将任意类型的参数,插入到字符串缓冲区,需要指定索引。int length()
返回字符串缓冲区的长度StringBuilder delete(int start,int end)
删除缓冲区中的字符,包含开头索引,不包含结束索引(在 Java 中一般都是包含开头索引,不包含结束索引)void setCharAt(int 索引,char ch)
修改指定元素上的字符,没有返回值StringBuilder reverse()
翻转字符串
2. StringBuilder 对象 和 String 对象的互转:(具体内容参阅【JavaSE 第十三天】)
①String 对象转成 StringBuilder 对象:
- StringBuilder 类的构造方法
StringBuilder(String str)
- append 方法
append(String str)
②StringBuilder 对象转成 String 对象:
- StringBuilder 的方法
toString()
- String 类的构造方法
3. System 类:
System 是系统类:定义在 java.lang 包中,这个类定义了大量常用的字段(成员变量)和方法,该类不能实例化对象,不能使用 new 创建对象,因为类中的成员全部都是静态修饰,使用类名直接调用。 该类的构造方法(构造器)被 private 修饰,第一行 super 操作继承 Object 类
4. System 类的方法:
①static long currentTimeMillis()
返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值,1000毫秒=1秒
②static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length)
复制数组的元素
- src:要赋值的数据源,源数组
- srcPos:源数组的开始索引
- dest:要复制的目标数组
- destPos:目标数组的开始索引
- length:要复制的元素个数
③static Properties getProperties()
返回当前的操作系统属性
5. Math 类的方法:
static double PI
圆周率static double E
自然数的底数static int abs(int a)
返回参数的绝对值static double ceil(double d)
返回大于或者等于参数的最小整数static double floor(double d)
返回小于或者等于参数的最大整数static long round(double d)
对参数四舍五入static double pow(double a,double b )
a的b次幂static double random()
返回随机数 0.0-1.0之间static double sqrt(double d)
参数的平方根
6. Arrays 工具类:
static void sort(数组)
对数组进行升序排列 (目前为止效率最快)static int binarySearch(数组,查找的关键字)
对数组进行二分搜索法static void fill(数组,填充的元素)
填充覆盖原元素,拥有全新的数组元素static String toString(数组)
返回数组的字符串表现形式static List asList(T...t)
多个元素转成 List 集合
7. 数组的相关操作:(具体内容参阅【JavaSE 第十三天】)
①数组的翻转
②数组的二分(折半)搜索法
③数组的排序
8. 字符串的相关操作:(具体内容参阅【JavaSE 第十三天】具体内容参阅【JavaSE 第十四天】)
①字符串翻转
②自定义(模仿)方法 trim()
③字符出现的次数
④字符串出现的次数
⑤哪个字符出现的最多
十四、第十四天:
1. 大数运算:
java.math 包中具有:BigInteger 大整数 、BigDecimal 大浮点数(高精度,不损失精度)
-
BigInteger 类使用,计算超大整数:
- 创建大数据运算对象直接
new BigInteger(String str)
数字格式的字符串,长度任意,支持正负数 BigInteger add(BigInteger b)
计算两个 BigInteger 的数据求和BigInteger subtract(BigInteger b)
计算两个 BigInteger 的数据求差BigInteger multiply(BigInteger b)
计算两个 BigInteger 的数据求乘积BigInteger divide(BigInteger b)
计算两个 BigInteger 的数据求商,结果会截掉小数
- 创建大数据运算对象直接
-
BigDecimal 类使用,计算超大浮点数
- 构造方法,和 BigInteger 一样
- 方法 + (加法) - (加法) * (乘法) 和 BigInteger 一样
BigDecimal divide
除法运算divide(BigDecimal big,int scalar,int round)
方法有三个参数:- big 是被除数
- scalar 是保留几位
- round 是保留方式
- 保留方式:参看该类的静态成员变量(字段摘要):(静态类名成员,类名直接调用)
BigDecimal.ROUND_UP
不管四舍五入,直接向上进一位BigDecimal.ROUND_DOWN
直接舍去BigDecimal.ROUND_HALF_UP
四舍五入
2. Date 类:
表示当前的日期对象,精确到毫秒值,java.util.Date 类
①构造方法:
- 无参数构造方法:
new Date()
- 有 long 型参数的构造方法:
new Date(long 毫秒值)
②Date 类没有过时的方法:
long getTime()
返回当前日期对应的毫秒值void setTime(long 毫秒值)
日期设定到毫秒值上
3. 日期对象和毫秒值之间的相互转换:
①日期对象,转成毫秒值:
new Date().getTime()
System.currentTimeMillis()
②毫秒值转成日期对象:
new Date(毫秒值)
new Date().setTime(毫秒值)
4. 日历类 Calendar:
①Calendar 是抽象类,不能建立对象,所以需要子类继承:GregorianCalendar (格林威治日历)
②Calendar 类定义了静态方法:static Calendar getInstance()
返回的是 Calendar 的子类的对象 GregorianCalendar
(GregorianCalendar
是方法中自带原有的 new 创建的对象,直接调用即可)
5. 日历类的方法:
①int get(int field)
返回给定日历字段的值
- 日历中的任何数据,都是 int 类型
- 参数是具体的日历字段,传递年、月、日
- 日历字段的写法:参看 Calendar 类的静态成员变量(字段摘要中)
②void set()
修改日历的值
set(int field,int value)
field要修改的字段,value 具体的数据set(int,int,int)
传递年、月、日
③add()
设置日历字段的偏移量
add(int field,int value)
field 要修改的字段,value 具体的数据
6. DateFormat 日期格式化:
java.text.DateFormat 类:类的作用是格式化日期的,但是抽象类不能建立对象,需要创建子类的对象 SimpleDateFormat
7. SimpleDateFormat 子类使用:
①构造方法:带有 String 参数的构造方法
- 参数字符串:日期格式化后的样子
- 调用 SimpleDateFormat 类的父类方法 format
String format(Date date)
传递日期对象,返回字符串
②字符串转成日期对象:
- SimpleDateFormat 调用方法
Date parse(String str)
③时区:
- TimeZone 静态方法
.getDefault()
默认的时区
8. LocalDate 本地日期:(JDK8)
①获取该类的对象,属于静态方法
static LocalDate now()
获取 LocalDate 的对象,跟随操作系统static LocalDate of()
获取 LocalDate 的对象,可以自己设置日期- of 方法中传递年、月、日
of(int year,int month,int day)
- of 方法中传递年、月、日
②获取日期字段的方法:名字是 get 开头,非静态方法
int getYear()
获取年份int getDayOfMonth()
返回月中的天数int getMonthValue()
返回月份
③设置日期字段的方法:名字是 with 开头
LocalDate withYear(int year)
设置年份LocalDate withMonth(int month)
设置月份LocalDate withDayOfMonth(int day)
设置月中的天数- LocalDate 对象是不可变对象,设置方法 with 开头,返回新的 LocalDate 对象
④设置日期字段的偏移量:
- 设置日期字段的偏移量,方法名 plus 开头,向后偏移
- 设置日期字段的偏移量,方法名 minus 开头,向前偏移
9. Period 和 Duration 类:(JDK8)
①Period 计算日期之间的偏差:
static Period between(LocalDate d1,LocalDate d2)
计算两个日期之间的差值- 计算出两个日期相差的天数,月数,年数
②Duration 计算时间之间的偏差:
static Period between(Temporal d1,Temporal d2)
计算两个日期之间的差值(Temporal 是一个接口)
10. 时区:(JDK8)
①ZonedDateTime.now()
返回当前时区
②ZonedDateTime.now(ZoneId.of("America/New_York"))
设置时区
11. DateTimeFormatter :(JDK8)
①static DateTimeFormatter ofPattern(String str)
自定义的格式
②String format(TemporalAccessor t)
日期或者时间的格式化(其中的参数是一个接口)
③TemporalAccessor parse(String s)
字符串解析为日期对象
12. 基本数据类型对象包装类:
基本数据类型的包装类的最重要功能:实现类基本数据类型和 String 的互转
基本数据类型 | 对应的包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
①基本类型 int 变成 Integer 类的对象:
- Integer 类的构造方法:
Integer(int a)
int 类型转成 Integer 对象Integer(String s)
字符串转成 Integer 对象,前提:字符串必须纯数字格式static Integer valueOf(int a)
int 类型转成 Integer 对象static Integer valueOf(String s)
字符串转成 Integer 对象,前提:字符串必须纯数字格式
②String 对象转成基本数据类型 int :
static int parseInt(String str)
参数字符串转成基本类型,字符串要求是数字格式(静态方法)int intValue()
把 Integer 对象构造方法中的字符串,转成基本类型(非静态方法)
③自动装箱和拆箱:
- 自动装箱 : 基本数据类型 自动转成 引用类型 int → Integer
- 自动拆箱 : 引用类型 自动转成 基本数据类型 Integer → int
13. 异常的继承体系:
异常中的顶级父类:
java.lang.Throwable
:所有异常和错误的父类java.lang.Error
:所有错误的父类(java.lang.Throwable
的子类)java.lang.Exception
:所有异常的父类(java.lang.Throwable
的子类)java.lang.RuntimeExeption
:所有的运行异常父类(java.lang.Exception
的子类)
14. Throwable 的方法:
子类继承即可使用
String toString()
返回异常信息的简短描述 (控制台红色部分)String getMessage()
返回异常信息的详细描述void printStackTrace()
异常信息追踪到标准的错误流
十五、第十五天:
1. try…catch 异常处理使用:
try{
被检测的代码
可能发生异常的代码
}catch(异常类的类名 变量名){
异常的处理方式:写什么都可以
定义变量,创建对象,调用方法,循环,判断...
只要写了catch,异常就被处理掉了
}
多 catch 并行处理:异常处理的代码中:try 可以跟随多个 catch,多个catch处理异常的时候,写法特别注意:如果 catch 中的异常类没有继承关系,先写后写没有区别。 catch 中的异常类有继承关系时,父类写在最下面(如果父类写在上面,由于多态性,子类就无法捕获异常,成为多余的代码)
2. throw 和 throws 关键字的使用:
- throw 关键字:只能写在方法内部,关键字的后面跟随对象的创建
- throws 关键字:只能写在方法的定义上,关键字后面跟随异常类名
(内部有问题就用 throw,但是外界不知道该问题,对外声明暴露问题就需要 throws)
3. finally 代码块的使用:
①finally 代码块跟随 try … catch 使用,也可以跟随 try 使用
②finally 代码块里面的程序,无论是否出现异常,都会执行,必须执行(但是结束 JVM 后,finally 就不会执行)
③finally 代码块后期主要用于释放资源
4. RuntimeException 异常问题:
①异常的父类是 Exception,Exception 类的子类有 RuntimeException,凡是 RuntimeException 和他的所有子类,都称为运行异常,RuntimeException 和的它的子类之外的则都称为编译异常
②编译异常:方法出现编译异常,调用者必须处理,否则编译失败。处理方式可以是 try…catch 或者是 throws
③运行异常:方法出现运行异常,在方法的定义上,不需要 throws 声明,调用者也不需要处理这个异常,建议不要处理运行异常:程序一旦发生运行异常,请程序人员修改源码
5. 自定义异常类:(具体内容参阅【JavaSE 第十五天】)
①自定义异常,需要继承 Exception 或者 RuntimeException(只有 Exception 和他的子类,才具有可抛出性)
②在自定义的类中,构造方法,super 调用父类构造方法,传递异常信息
6. 集合框架的继承体系:(具体内容参阅【JavaSE 集合框架的继承体系】)
①第一个派系:
Collection (集合)
顶级接口 单列集合(一次只能存一个对象)List (列表)
接口ArrayList (数组列表)
实现类LinkedList (链表)
实现类Vector (数组列表)
实现类,已过时
Set (集合)
接口HashSet (哈希表)
实现类LinkedHashSet (链表哈希表)
实现类,继承自HashSet
TreeSet (红黑树)
实现类
②第二个派系:
Map (映射键值对)
顶级接口 双列集合(一次可以存两个对象)HashMap (哈希表)
实现类LinkedHashMap (链表哈希表)
实现类,继承自HashMap
TreeMap (红黑树)
实现类Hashtable (哈希表)
实现类,已过时Properties (哈希表)
实现类,继承自Hashtable
ConCurrentHashMap (哈希表)
线程相关
③存在一个独立的接口:Iterator
迭代器接口(用来做遍历)
④泛型的使用
⑤增强型循环: for(:)
循环
十六、第十六天:
归结于【JavaSE 集合框架的继承体系】
十七、第十七天:
归结于【JavaSE 集合框架的继承体系】
十八、第十八天:
关于线程的知识
十九、第十九天:
关于线程的知识及 File 类的知识
二十、第二十天:
关于 File 类的知识
二十一、第二十一天:
关于枚举、反射、注解的知识
二十二、第二十二天:
关于 Junit(单元测试)、Lambda 表达式、Stream 流、Optional 类的知识
二十三、网络编程:
归结于【JavaSE 网络编程】