java基础知识思维导图
2021-12-20 17:48:59 0 举报AI智能生成
1+x所考内容
作者其他创作
大纲/内容
io
多线程
概述
并发和并行
进程和线程
实现方式
继承Thread类的方式实现
实现Runnable接口的方式进行实现
利用Callable和Furture接口方式实现
java简介
语言背景
Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言
Java之父：詹姆斯·高斯林（James Gosling）
2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：[https://www.oracle.com](https://www.oracle.com/)
Java之父：詹姆斯·高斯林（James Gosling）
2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：[https://www.oracle.com](https://www.oracle.com/)
版本
JavaSE(Java Platform Standard Edition)：开发普通桌面和商务应用程序，是另外两类的基础
JavaEE(Java Platform Enterprise Edition)：是为开发企业环境下的应用程序提供的一套解决方案，包含Servlet、Jsp等，主要针对Web应用程序开发
JavaME(Java Platform Micro Edition)：是为开发电子消费产品和嵌入式设备提供的解决方案
特性
简单
面向对象
分布式
。。。
java跨平台原理
Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。
即 **先编译在解释**
即 **先编译在解释**
它本身是二进制文件,但是不可以被系统直接执行,而是需要虚拟机解释执行。
Java程序开发运行流程
编写代码
编译代码
.java属于源文件，无法被JVM所识别执行，这一步的目的 使用jdk中的翻译工具，将其翻译成jvm可以直接识别的
y运行代码
将生成的.class运行在JVM虚拟机中
JDK，JRE，JVM
* JVM（Java Virtual Machine），Java虚拟机
* JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）
* JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具
总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。
语言基础
注释
单行注释
//
多行注释
/* */
文档注释
/**
*
*/
*
*/
关键字
关键字是指被java语言赋予了特殊含义的单词。
关键字的特点：
关键字的字母全部小写。
常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。
关键字的字母全部小写。
常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。
常量
常量：在程序运行过程中，其值不可以发生改变的量。
分类
字符串常量 用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、"abc"、"中国"等
整数常量 整数，例如：-10、0、88等
小数常量 小数，例如：-5.5、1.0、88.88等
字符常量 用单引号括起来的一个字符，例如：'a'、'5'、'B'、'中'等
布尔常量 布尔值，表示真假，只有两个值true和false
空常量 一个特殊的值，空值，值为null
整数常量 整数，例如：-10、0、88等
小数常量 小数，例如：-5.5、1.0、88.88等
字符常量 用单引号括起来的一个字符，例如：'a'、'5'、'B'、'中'等
布尔常量 布尔值，表示真假，只有两个值true和false
空常量 一个特殊的值，空值，值为null
除空常量外，其他常量均可使用输出语句直接输出。
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎"); // 输出字符串
}
}
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎"); // 输出字符串
}
}
变量
定义
变量：在程序运行过程中，其值可以发生改变的量。
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
格式 数据类型 变量名 = 数据值；
**数据类型**：为空间中存储的数据加入类型限制。整数？小数？
**变量名**：自己要为空间起的名字，没有难度
**数据值**： 空间中要存储的数值，没有难度
**变量名**：自己要为空间起的名字，没有难度
**数据值**： 空间中要存储的数值，没有难度
数据类型 变量名 = 初始化值; // 声明变量并赋值
int age = 18;
System.out.println(age);
int age = 18;
System.out.println(age);
注意事项
1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
范围
成员变量
实例变量
int x= 1;
局部变量
静态变量
static int y = 2
特点
有效范围可以跨类，甚至可以在整个应用程序
直接以 类名.静态变量 访问
数据类型
基本数据类型
整数
表示形式
十进制
注意：不能以0开头，0除外
八进制
以0开头
八进制 0123 == 十进制 83
十六进制
以0X或0x开头
十六进制0x25 == 十进制 37
类型
byte
short
int
long
浮点
float
double
字符
char
布尔
boolean
引用数据类型
数组
对象
标识符
可以理解为名字，用来标记类名，变量名，数组名这些
方法体
即{ }
运算符
什么叫运算符或者表达式
赋值运算符
=
算数运算符
+ - * / %
比较运算符
>, >= ...
自增自减运算符
a++
a--
逻辑运算符
&&,&, || ,!
位运算符
三元运算符
？：
类型转换
隐式转换
强制转换
流程控制
顺序
条件语句
if
int num = 1;
if(num == 1){
}else if(num == 2){
}else{
}
switch
switch (choose){
case "1":
// 开启学生1管理系统
//StudentController studentController = new StudentController();
OtherStudentController studentController = new OtherStudentController();
studentController.start();
break;
case "2":
// 开启老师管理系统
TeacherController teacherController = new TeacherController();
teacherController.start();
break;
case "3":
System.out.println("3");
System.exit(0);
//break;
default:
System.out.println("输入有误，请重新输入");
}
case "1":
// 开启学生1管理系统
//StudentController studentController = new StudentController();
OtherStudentController studentController = new OtherStudentController();
studentController.start();
break;
case "2":
// 开启老师管理系统
TeacherController teacherController = new TeacherController();
teacherController.start();
break;
case "3":
System.out.println("3");
System.exit(0);
//break;
default:
System.out.println("输入有误，请重新输入");
}
循环语句
while
do。。。while
for
fori 增强for
循环控制
break
continue
进制
进制的介绍与书写格式
任意进制到十进制的转换
子主题
十进制到任意进制转换
数组
概念
同一种类型数据的集合。其实数组就是一个容器。
初始化
静态初始化
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
动态初始化
int[] arr = new int[3];
二维数组
常见异常
索引越界异常
ArrayIndexOutOfBoundsException
空指针异常
NullPointerException
数组遍历
for
for增强
Iterator（迭代器）
Collection<String> c = new ArrayList<>();
c.add("a");
c.add("b");
c.add("c");
// 创建迭代对象，一旦被创建出来，默认指向0索引出
Iterator<String> it = c.iterator();
//boolean hasNext(): 判断当前位置是否有元素可以被取出
//next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
while (it.hasNext()){
System.out.println(it.next());
}
面向对象
类和对象
思想
**面向过程 ：**是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的
**面向对象 ：**是一种以对象为中心的编程思想，通过指挥对象实现具体的功能
关系
对现实时间中某一种具体事物的抽象描述（特征和行为）
* 对象：是能够看得到摸的着的真实存在的实体
**类是对象的抽象（模板），而对象是类的具体实例**
类
组成
属性
方法
抽象类(abstract)
对现实世界中某一种类型的多种事物的抽象描述
- 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
- 抽象类不能实例化
- 抽象类可以有构造方法
- 抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
- 抽象类不能实例化
- 抽象类可以有构造方法
- 抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
权限修饰符
构造方法
格式
* 方法名与类名相同，大小写也要一致
* 没有返回值类型，连void都没有
* 没有具体的返回值（不能由retrun带回结果数据）
执行
* 创建对象的时候调用，每创建一次对象，就会执行一次构造方法
* 不能手动调用构造方法
* 不能手动调用构造方法
作用
用于给对象的数据（属性）进行初始化
注意事项
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
面向对象三大特征
封装
this
区分局部变量和成员变量的重名问题
调用重载构造方法
特指对象本身
用于完成特定的功能
继承
super
多态
什么是多态
同一个对象，在不同时刻表现出来的不同形态
多态的前提
- 要有继承或实现关系
- 要有方法的重写
- 要有父类引用指向子类对象
- 要有方法的重写
- 要有父类引用指向子类对象
访问特点
成员变量
编译看父类，运行看父类
成员方法
编译看父类，运行看子类
好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端
不能使用子类的特有成员
转型
向上转型
向下转型
instanceof
：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果
方法重写（又称方法覆盖）
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
- 方法的重写，不能发生在同类中，只能发生在子类中。
- 方法重写的权限：子类中的权限大于或等于父类的权限,（修饰符高低：private < 默认修饰符<protected < public）
- *特殊情况：子类不能重写父类被声明为private权限的方法*
- 静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
- 方法的重写，不能发生在同类中，只能发生在子类中。
- 方法重写的权限：子类中的权限大于或等于父类的权限,（修饰符高低：private < 默认修饰符<protected < public）
- *特殊情况：子类不能重写父类被声明为private权限的方法*
- 静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
重载
定义
方法重载：如果同一个类中包含了两个及两个以上方法名相同，方法参数的个数、顺序或者类型不同的方法，则称为方法的重载。
简单的说就是：方法重载就是方法名称重复，加载参数不同。
简单的说就是：方法重载就是方法名称重复，加载参数不同。
判断
1. 同一个类中，方法名称一致
2. 方法参数的个数、类型或者顺序不一致；
3. 与返回值、访问修饰符无关。
static关键字
特点
+ 被类的所有对象共享
是我们判断是否使用静态关键字的条件
+ 在类加载时被执行，只执行一次，优先于对象存在
对象需要类被加载后，才能创建
+ 可以通过类名调用
也可以通过对象名调用
注意事项
+ 静态方法只能访问静态的成员
+ 非静态方法可以访问静态的成员，也可以访问非静态的成员
+ 静态方法中是没有this关键字
+ 非静态方法可以访问静态的成员，也可以访问非静态的成员
+ 静态方法中是没有this关键字
final
作用
final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值
+ 变量是基本类型,不能改变的是值
+ 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的
代码块 {}
局部代码块
+ 位置: 方法中定义
+ 作用: 限定变量的生命周期，及早释放，提高内存利用率
构造代码块
+ 位置: 类中方法外定义
+ 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
+ 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
静态代码块
+ 位置: 类中方法外定义
+ 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
+ 作用: 在类加载的时候做一些数据初始化的操作
接口(interface)
两个意义
1. 用来定义规范
2. 用来做功能的拓展
特点
- 接口不能实例化
我们可以创建接口的实现类对象使用
- 接口的子类
要么重写接口中的所有抽象方法
要么子类也是抽象类
我们可以创建接口的实现类对象使用
- 接口的子类
要么重写接口中的所有抽象方法
要么子类也是抽象类
类实现接口用implements表示
public class 类名 implements 接口名 {}
接口的成员特点
成员变量
只能是常量
默认修饰符：public static final
默认修饰符：public static final
public static final int NUM = 10;
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
成员方法
只能是抽象方法
默认修饰符：public abstract
默认修饰符：public abstract
public abstract void show();
类和接口的关系
类与类的关系
继承关系，只能单继承，但是可以多层继承
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系
继承关系，可以单继承，也可以多继承
接口组成更新概述
常量
public static final
抽象方法
public abstract
- 默认方法(Java 8)
- 静态方法(Java 8)
- 私有方法(Java 9)
默认方法(default)
格式
public default 返回值类型 方法名(参数列表) { }
public default void show3() {
}
}
作用
解决接口升级的问题
注意事项
- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
- public可以省略，default不能省略
- 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写
- public可以省略，default不能省略
- 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写
静态方法(static)
格式
public static 返回值类型 方法名(参数列表) { }
public static void show() {
}
}
注意事项
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略
- public可以省略，static不能省略
内部类
内部类概念
在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
class Outer {
public class Inner {
}
}
public class Inner {
}
}
内部类的访问特点
- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类的成员，必须创建对象
- 外部类要访问内部类的成员，必须创建对象
成员内部类
class Outer {
private int num = 10;
private class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
Outer o = new Outer();
o.method();
}
}
private int num = 10;
private class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
Outer o = new Outer();
o.method();
}
}
局部内部类
class Outer {
private int num = 10;
public void method() {
int num2 = 20;
class Inner {
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
private int num = 10;
public void method() {
int num2 = 20;
class Inner {
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
public class OuterDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
匿名内部类
前提
存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式
new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
Inter i = new Inter(){
@Override
public void method(){
}
}
Inter i = new Inter(){
@Override
public void method(){
}
}
调用方式
interface Inter{
void method();
}
class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println("我是匿名内部类");
}
}.method(); // 直接调用方法
}
}
void method();
}
class Test{
public static void main(String[] args){
new Inter(){
@Override
public void method(){
System.out.println("我是匿名内部类");
}
}.method(); // 直接调用方法
}
}
静态内部类
class Outer {
static class Inner {
public void show(){
System.out.println("inner..show");
}
public static void method(){
System.out.println("inner..method");
}
}
}
public class Test3Innerclass {
/*
静态成员内部类演示
*/
public static void main(String[] args) {
// 外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
Outer.Inner.method();
}
}
static class Inner {
public void show(){
System.out.println("inner..show");
}
public static void method(){
System.out.println("inner..method");
}
}
}
public class Test3Innerclass {
/*
静态成员内部类演示
*/
public static void main(String[] args) {
// 外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
Outer.Inner.method();
}
}
Lambda表达式
前提
- 有一个接口
- 接口中有且仅有一个抽象方法
Lambda表达式和匿名内部类的区别
所需类型不同
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
常用api类
字符串
String
Stringbuilder
Math
System
exit
currentTimeMillis
Object
Object类的toString方法
返回地址值，建议所有子类重写
Object类的equals方法
比较对象是否相等，默认比较地址，重写比较内容
Objects
toString（对象）
toString（对象，默认字符串）
isNull
nonNull
BigDecimal
add
subtract
multiply
divide
常规
精确运算
Arrays
toString
sort
binarySearch
基本类型包装类
基本类型-》包装类 转换成对象，以便更好操作数据
注意
1，在使用包装类型的时候，如果做操作，最好先判断是否为null
2，推荐只要是对象，在使用前必须进行不为null的判断
Byte
Short
Integer
自动装箱和自动拆箱
类型装换 String 《=》 Int
parseInt
Long
Float
Double
Character
Boolean
时间日期类
Date类
构造方法
public Date()分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
成员方法
public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
=>
System.currentTimeMillis
public void setTime(long time)设置时间，给的是毫秒值
SimpleDateFormat
格式化 （从Date到String） 将日期格式化成日期/时间字符串
解析 （从String到Date） 从给定的字符串开始解析文本以生成对象 计算时间可用
常用格式
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); // 2021年07月19日 14:37:26
JDK8时间日期类
LocalDate 表示日期（年月日）
LocalTime 表示时间（时分秒）
LocalDateTime 表示时间+ 日期 （年月日时分秒）
获取时间对象
public static LocalDateTime of (年, 月 , 日, 时, 分, 秒)使用指定年月日和时分秒初始化一个LocalDateTime对象
public static LocalDateTime now()获取当前系统时间
获取时间中的每个值
public int getYear()获取年
public int getMonthValue()获取月份（1-12）
public int getDayOfMonth()获取月份中的第几天（1-31）
public int getDayOfYear()获取一年中的第几天（1-366）
public DayOfWeek getDayOfWeek()获取星期
public int getMinute()获取分钟
public int getHour()获取小时
转换方法
public LocalDate toLocalDate () 转换成为一个LocalDate对象
public LocalTime toLocalTime () 转换成为一个LocalTime对象
格式化与解析
public String format (指定格式)把一个LocalDateTime格式化成为一个字符串
public LocalDateTime parse (准备解析的字符串, 解析格式)把一个日期字符串解析成为一个LocalDateTime对象
public static DateTimeFormatter ofPattern(String pattern)使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象
增减时间
plus系列
public LocalDateTime plusYears (long years)添加或者减去年
public LocalDateTime plusMonths(long months)添加或者减去月
public LocalDateTime plusDays(long days)添加或者减去日
public LocalDateTime plusHours(long hours)添加或者减去时
public LocalDateTime plusMinutes(long minutes)添加或者减去分
public LocalDateTime plusSeconds(long seconds)添加或者减去秒
public LocalDateTime plusWeeks(long weeks)添加或者减去周
minus系列
前缀不一样，效果和plus相反
with系列
前缀不一样，写法同上
时间间隔对象
Period 获取年月日
public static Period between(开始时间,结束时间)计算两个“时间"的间隔
public int getYears()获得这段时间的年数
public int getMonths()获得此期间的总月数
public int getDays()获得此期间的天数
public long toTotalMonths()获取此期间的总月数
Duration 获取时分秒
public static Durationbetween(开始时间,结束时间)计算两个“时间"的间隔
public long toSeconds()获得此时间间隔的秒
public int toMillis()获得此时间间隔的毫秒
public int toNanos()获得此时间间隔的纳秒
异常
异常体系
Throwable成员方法
public String getMessage()返回此 throwable 的详细消息字符串
public String toString()返回此可抛出的简短描述
public void printStackTrace()把异常的错误信息输出在控制台
异常处理方式
抛出
throw throws
public static void main(String[] args) throws ParseException{
throw new NullPointerException(); //当参数为null的时候
捕获
try。。catch
try {
int[] arr = {1,2,3};
System.out.println(arr[10]);
} catch (Exception e) {
System.out.println( e.getMessage()); // Index 10 out of bounds for length 3
System.out.println( e.toString()); // java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 3
e.printStackTrace();
}
System.out.println("哈哈，我还在");
int[] arr = {1,2,3};
System.out.println(arr[10]);
} catch (Exception e) {
System.out.println( e.getMessage()); // Index 10 out of bounds for length 3
System.out.println( e.toString()); // java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 3
e.printStackTrace();
}
System.out.println("哈哈，我还在");
自定义异常
1. 定义异常类
2. 写继承关系
3. 提供空参构造
4. 提供带参构造
2. 写继承关系
3. 提供空参构造
4. 提供带参构造
public class AgeOutOfBoundsException extends RuntimeException {
public AgeOutOfBoundsException() {
}
public AgeOutOfBoundsException(String message) {
super(message);
}
}
public AgeOutOfBoundsException() {
}
public AgeOutOfBoundsException(String message) {
super(message);
}
}
使用
try {
int age = Integer.parseInt(ageStr);
s.setAge(age);
break;
} catch (NumberFormatException e) {
System.out.println("请输入一个整数");
continue;
} catch (AgeOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("请输入一个符合范围的年龄");
continue;
}
int age = Integer.parseInt(ageStr);
s.setAge(age);
break;
} catch (NumberFormatException e) {
System.out.println("请输入一个整数");
continue;
} catch (AgeOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("请输入一个符合范围的年龄");
continue;
}
集合
集合的概述和继承体系
集合与数组的对比
1，数组长度不可变，集合可变
2，数组可以存储基本数据类型和引用数据类型
集合只能存储引用数据类型，如果要存基本数据类型，则需要对象包装类
集合只能存储引用数据类型，如果要存基本数据类型，则需要对象包装类
集合体系结构
Collection
成员方法
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
boolean removeIf(Object o)根据条件进行移除void
clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空int
size()集合的长度，也就是集合中元素的个数
遍历 Iterator迭代器,集合的专用遍历方式
boolean hasNext(): 判断当前位置是否有元素可以被取出
E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
List
ArrayList
LinkedList
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素
set
TreeSet
HashSet
泛型
Map
Collections
数据结构
栈和队列
数组和链表
0 条评论
下一页
