按阶段
1. java基础语法
day01:
* 键盘的快捷键
* 常用的dos命令
D: 盘符切换(格式: 盘符号:) , 表示切换到D盘
dir 列出当前路径下所有的文件或者文件夹信息
cd 路径 表示切换到指定的路径
cd .. 表示回退到上一级目录
cls 清屏
exit 退出
cd /d 路径 进行跨盘的切换路径
* java语言的概述
java语言是1995年产生的
java语言的平台版本分类:
javaSe: 标准版,是其他两个技术的基础
javaMe: 小型版,用来开发一些移动端的小应用(已经被Android取代了)
javaEE: 企业版,开发一些企业级应用
* java语言的跨平台性:
跨平台: 就是一个java应用程序可以在多个平台之间进行运行.这个实现其实是靠JVM实现的.所以我们说jvm是不跨平台的
* JRE 和 JDK
* JRE: 是java的运行环境,一个java应用程序要运行起来,必须要有JRE. JRE = JVM + Java核心类库
* JDK: 是java的开发工具. JDK = JRE + Java的开发工具
* 由jdk开发的程序交由jre运行,由jvm实现跨平台
* 第一个java程序HelloWorld
* 环境变量:
* path 作用: 是为了让我们的java和javac命令可以在任意路径下进行执行
* classpath 作用: 是为了让字节码文件在任意路径下都可以执行(不用配置)
刚装的系统一定要配置环境变量
* 注释
* 概述: 就是用来解释说明程序的文字
* 分类:
单行注释 //
多行注释 /* 注释的内容 */
文档注释 /** 注释的内容 */
多行注释的注意事项: 不能嵌套使用
* 作用
* 用来解释说明程序
* 调试程序
* 标识符
* 概述: 就是给类,接口,方法,变量和常量起名字时使用的字符序列 ; 起名字要做到"见名知意"
* 组成规则:
** 英文大小写字母组成
** 数字字符
** $和_
* 注意事项:
** 不能以数字开头
** 不能是java语言中的关键字
** 区分大小写
* 关键字
* 概述: 就是被java语言赋予特殊含义的单词
* 特点:
** 组成都是小写字母
** goto 和 const 是java语言中的保留字
** 高级文本编辑器中会变色
* 命名规则
** 包 字母都是小写
** 类和接口
* 一个单词 首字母大写
* 多个单词 每一个单词的首字母大写,其余字母小写
** 方法和变量
* 一个单词 全部小写
* 多个单词 从第二个单词开始首字母大写
** 常量
* 一个单词 字母全部是大写
* 多个单词 字母全部是大写,每一个单词之间使用"_"链接
day02:-----------------------------------------------------------------------------------------------------------------------------------
* 常量
* 概述: 就是在程序的执行过程中其值不发生改变的量
* 分类:
** 自定义常量(面向对象部分讲解)
** 字面值常量
* 字符串常量 使用双引号引起来的内容 "HelloWorld"
* 整数常量 包含所有的整数 23 , 45
* 小数常量 包含所有的小数 1.34 , 5.67
* 字符常量 使用单引号引起来的内容 'a' , 'A' , '0' (注意事项:单引号中只能是单个数字单个字母和单个符号)
* 布尔常量 true 和 false
* 空常量 null
* 变量
* 概述: 就是在程序的执行过程中其值可以发生改变的量.定义一个变量其实就是在内存中开辟了一小块区域.
* 定义格式: 数据类型 变量名 = 变量值 ; 变量名: 就是合法的标识符 ; 变量值: 其实就是常量
* 数据类型分类:
** 引用数据类型: 类 , 数组 , 接口
** 基本数据类型:
* 数值型
** 整数型: byte(-128 ~ 127) , short , int , long
** 浮点数: float , double
* 字符型: char(0~65535)
* 布尔型: boolean
* 变量的注意事项:
** 变量必须赋值以后才能使用
** 一个变量定义在了哪一级大括号中,那么这个变量的作用域就是这对大括号,出了大括号就不能再使用
* 数据类型转换
** 隐式转换: 由小的数据范围到大的数据范围的转换
* boolean 不能转换成其他的数据类型
* byte , short , char ---- int ----- long ---- float ---- double
* byte , short ,char 之间不转换,它们在参与运算的时候会自动转换成 int 类型
** 强制转换: 由大的数据范围到小的数据范围的转换
* 格式: 目标数据类型 变量名 = (目标数据类型)(待转换的数据) ;
* 注意事项: 尽量不要使用强制类型转换,因为可能存在损失精度的问题
* 字符和字符串参与运算的情况
* 字符在参与运算的时候,会转换成int类型的值,需要去查ASCII码表找到对应的十进制数据
'a' --- 97 , 'A' --- 65 , '0' --- 48
* 字符串在参与运算的情况:
** 任何数和字符串进行相加得到的结果都是一个新的字符串
** +号在这个地方表示的是字符串链接符
* 运算符
* 分类:
** 算术运算符: + , - , * , / , % , ++ , --
/ : 两个整数相除得到的结果是一个整数,获取的是除法的商
% : 获取的是除法的余数.结果的正负号和参与运算的左边的数据的符号一致
++: 作用: 自增1
使用:
* 单独使用(开发中常用) ++在前和++在后对计算结果没有影响
* 参与运算的使用 ++在前先进行自增1然后在参与运算,++在后先参与运算,然后在自增1
** 赋值运算符: = , += , -= , *= , /= , %=
* 注意事项: 要求左边必须是一个变量
* +=: 把左边的数据和右边的数据进行加法运算,然后在赋值给左边
* 这几个扩展的赋值运算符隐含和强制类型转换
** 比较运算符: > , < , >= , <= , == , != , instanceof
* 特点: 运算完毕以后会返回一个boolean类型的值
* 注意事项: 不能将"=="写成一个"="
day03----------------------------------------------------------------------------------------------------------------------
* 运算符
** 逻辑运算符: & , | , ! , ^ , && , ||
* &&(短路与): 左边为false的时候右面就不执行; 有false则false
* ||(短路或): 左边为true的时候右面就不执行 ; 有true则true
* ! : 非false则true,非true则false
** 位运算符 : & , | , ^ , ~ , << , >> , >>>
* 注意事项: 都是对二进制数据的补码进行运算的
* <<的特点: 用左边的数据乘以2的移动次幂
* >>的特点: 用左边的数据除以2的移动次幂
* >>>的特点: 得到的结果都是一个正数
** 三元运算符: (比较表达式) ? 表达式1 : 表达式2 ;
* 执行流程: 首先计算比较表达式的值,看其返回结果是true还是false,如果是true就执行表达式1 , 如果是false就执行表达式2 ;
* 键盘录入数据
** 导包: 格式: import java.util.Scanner ; 位置: 在 class 上面
** 创建键盘录入对象: 格式: Scanner sc = new Scanner(System.in) ;
** 获取键盘录入数据: 格式: int x = sc.nextInt() ;
* 流程控制语句
** 顺序结构: 没有特定的语法规则,执行顺序: 从上到下依次执行
** 选择结构:
* if 语句
** if 语句的第一种格式
if(比较表达式或者 boolean 类型的值){
语句体 ;
}
执行流程: 计算比较表达式的值,看其返回结果是true还是false,如果是true就执行语句体; 如果是false就不执行语句体
** if 语句的第二种格式
if(比较表达式或者 boolean 类型的值){
语句体1 ;
}else {
语句体2 ;
}
执行流程: 计算比较表达式的值,看其返回结果是true还是false,如果是true就执行语句体1 , 如果是false就执行语句体2
** if 语句的第三种格式
if(比较表达式1或者 boolean 类型的值1){
语句体1 ;
}else if(比较表达式2或者 boolean 类型的值2){
语句体2 ;
}else if(比较表达式3或者 boolean 类型的值3){
语句体3 ;
}
... // 表示的意思是else if(....){} 这个语句可以有多个
else {
语句体n+1 ;
}
执行流程: 计算比较表达式1的值,看其返回结果是true还是false,如果是true就执行语句体1 ,
如果是false就计算比较表达式2的值,看其返回结果是true还是false,如果是true就执行语句体2,
如果是false就计算比较表达式3的值,看其返回结果是true还是false,如果是true就执行语句体3,
....
如果前面的表达式的值都是false那么,就执行else对应的语句体
注意事项: else 语句可以省略的
* switch 语句
格式:
switch(表达式){
case 值1 :
语句体1 ;
break ;
case 值2 :
语句体2 ;
break ;
...
default:
语句体n+1 ;
break ;
}
表达式的取值: byte , short , int , char
jdk1.5以后可以取枚举
jdk1.7以后可以去字符串
执行流程:
首先计算表达式的值,然后在和case后面的值进行匹配,如果匹配成功,那么就执行对应的语句体
如果没有找到对应的case的值,那么就执行default对应的语句体
day04----------------------------------------------------------------------------------------------------------------------
* 循环结构
** for 循环
* 格式
for(初始化表达式语句 ; 判断条件语句 ; 控制条件语句){
循环体语句;
}
* 执行流程:
a: 首先执行初始化表达式语句
b: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
c: 执行循环体语句
d: 执行控制条件语句
e: 回到b继续
* 注意事项: 初始化表达式语句只执行一次
** while 循环
* while 语句
* 格式:
初始化表达式语句 ;
while(判断条件语句){
循环体语句;
控制条件语句
}
* 执行流程
a: 首先执行初始化表达式语句
b: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
c: 执行循环体语句
d: 执行控制条件语句
e: 回到b继续
* do...while 语句
* 格式:
初始化表达式语句 ;
do {
循环体语句;
控制条件语句
}while(判断条件语句);
* 执行流程
a: 首先执行初始化表达式语句
b: 执行循环体语句
c: 执行控制条件语句
d: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
e: 回到b继续
* 三个循环语句的区别:
* do...while 循环是至少执行一次循环体的循环,而for和while,必须先判断条件是否成立,然后决定是否执行循环体语句
* 初始化循环变量的区别
* 两种特殊的死循环
* while(true){....}
* for(;;){......}
* 控制跳转语句
* break 中断
* 应用场景:
** 在switch语句中
** 在循环中
* 作用:
** 在switch语句中的作用,用来结束switch语句
** 在循环中
** 跳出单层循环 (默认)
** 跳出多层循环 (了解); 需要了解一个东西,就是带标签的语句: 格式: 标签名: 语句体
* continue 继续
* 应用场景: 在循环中
* 作用: 跳出本次循环执行下一步操作
* return 返回
* 作用: 就是用来结束一个方法的,把方法的返回值通过return带回给调用者
* 方法
* 方法作用: 就是对代码的一个封装 , 可以用来提高代码的复用性
* 定义格式:
修饰符 返回值类型 方法名(参数类型 参数名1 , 参数类型 参数名2 , ...){
方法体;
}
* 注意事项:
a: 方法不调用不执行
b: 方法的参数列表之间需要使用","隔开
c: 方法和方法是平级的关系,不能嵌套定义
d: 方法在调用的时候不用再传递数据类型
e: 如果一个方法有明确的返回值类型,那么就需要通过return带回一个具体的值
* 有明确返回值类型的方法调用
* 直接调用(了解)
* 赋值调用(推荐使用)
* 输出调用(可以使用)
* 没有明确返回值类型的方法调用
* 直接调用
* 方法重载: 就是在一个类中允许同时存在一个以上的同名方法,只要它们的参数列表不同,与返回值类型无关
* 参数列表不同:
参数的个数不同
参数的类型不同
day05-----------------------------------------------------------------------------------------------------------------------------------
* 一维数组
* 概述: 用来存储同一种数据类型的元素的容器
* 格式:
数据类型[] 数组名 ; // 推荐使用
数据类型 数组名[] ;
* 数组的初始化
* 动态初始化 就是由我们指定数组的长度,由系统分配默认的初始化值
* 静态初始化 就是由我们给出初始化值,由系统分配长度
* 注意事项 不能进行动静结合
* 动态初始化的格式:
数据类型[] 数组名 = new 数据类型[数组的长度] ;
数组的长度: 就是数组中存储元素的个数
* java语言的内存分配
* 栈: 存储的就是局部变量
局部变量: 就是方法定义中或者方法声明上的变量
* 堆: 存储的都是new出来的东西
* 特点:
** 系统会为每一个new出来的东西分配一个内存地址值
** 系统会为每一个元素赋一个默认的初始化值
byte , short , int , long --- 0
float , double --- 0.0
char --- '\u0000'
boolean --- false
引用数据类型 --- null
** 使用完毕以后就变成了垃圾,等待垃圾回收器对其进行回收
* 方法区(面向对象研究)
* 本地方法区(和系统相关)
* 寄存器(CPU)
* 数组的长度的获取: 需要使用 length 属性, 格式: 数组名.length
* 数组中每一个元素都存在一个整数索引,这个索引是从0开始,最大索引是: 数组的长度 - 1 ; 我们可以通过数组名配合索引获取数组中的元素的值
格式: 数组名[索引] ;
* 数组的常见操作
** 遍历
** 基本查找
** 获取最值
** 反转
代码:
public static void reverseArr(int[] arr){
for(int x = 0 , y = arr.length - 1 ; x <= y ; x++ , y--){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
** 查表法
思想: 使用数组模拟一张表,然后通过索引找出指定的值
代码:
public static String cha(int index){
// 模拟
String[] date = {"" , "星期一", "星期二" , "星期三" , "星期四" , "星期五" , "星期六" , "星期天"} ;
// 返回
return date[index] ;
}
* 静态初始化格式: 数据类型[] 数组名 = {元素1 , 元素2 , ....} ;
* 二维数组(了解)
* 格式: 数据类型[][] 数组名 = new 数据类型[m][n] ;
m: 表示的意思是这个二维数组中一维数组的个数
n: 表示的意思是每一个一维数组中的元素的个数
==========================================================================================================================================
2. 面向对象
day06-------------------------------------------------------------------------------------------------------------------------------------
* 面向对象的思想: 指挥对象做事情 , 体现到程序中: 就是创建对象调用方法
* 面向对象语言的三大特征: 封装 , 继承 , 多态
* 类和对象的关系
现实 java语言
事物 类
属性 成员变量
行为 成员方法
* 属性: 就是事物固有的特性
* 行为: 就是该事物可以做的事情
* 成员变量: 位置在类中方法外定义的变量
* 成员方法: 定义成员位置
* 类是一个抽象的东西,而对象是该类的具体的体现
* 创建对象的格式: 类名 对象名 = new 类名();
* 访问对象的属性: 对象名.属性名 ;
* 访问对象的方法: 对象名.方法名(...);
* 成员变量和局部变量的区别:(掌握)
* 在类中的位置不同
** 局部变量: 在方法定义中或者方法声明上
** 成员变量: 类中方法外
* 在内存中的位置不同
** 局部变量: 在栈内存中
** 成员变量: 在堆内存中
* 生命周期不同
** 局部变量: 随着方法的调用而产生,随着方法的消失而消失
** 成员变量: 随着对象的创建而产生,随着对象的消失而消失
* 初始化值的区别
** 局部变量: 没有默认的初始化值,必须赋值以后才能使用
** 成员变量: 有默认的初始化值
* 匿名对象: 就是没有名字的对象
作用:
a: 可以用来调用方法,仅仅调用一次
b: 作为参数传递
new Object() ;// 匿名对象
* private 修饰符: 可以用来修饰成员变量,也可以用来修饰成员方法. 被 private 修饰的成员只能在本类中访问
* this 关键字: 表示的是本类对象的一个引用,可以理解为就是本类的一个对象. 谁调用我方法中的 this 就代表谁
day07-------------------------------------------------------------------------------------------------------------------------------------
* 构造方法
** 特点:
* 方法名和类名相同
* 没有返回值类型,连void也没有
* 没有明确的返回值
** 作用: 创建对象使用的 new 关键字,但是创建对象的时候需要借助于构造方法. 构造方法的作用用来给的成员变量赋值,完成类的初始化工作
** 注意事项:
* 如果我们没有给出构造方法,那么系统会提供一个默认的无参的构造方法
* 如果我们给出了构造方法,那么系统将不会再提供默认无参的构造方法,那么这个时候如果我们还想借助于无参的构造方法创建对象,
那么我们就需要自己给出.建议始终给出
* 对象的创建步骤
Student s = new Student() ;
* 加载Student类对应的字节码文件到方法区
* 在栈内存中为s开辟空间
* 在堆内存中为new Student()开辟空间
* 对成员变量进行默认初始化
* 对成员变量进行显式初始化
* 调用构造方法对成员变量进行初始化
* 把堆内存中的地址值赋值给栈内存中的引用变量s
* static 关键字
** static 关键字是一个修饰符,可以用来修饰成员变量 , 也可以用来修饰成员方法
** 特点:
* 随着类的加载而加载
* 优先于对象存在
* 被类的所有的对象所共享
* 可以通过类名直接访问,本身也可以通过对象名访问,但是建议使用类名直接访问
** 注意事项:
* 在静态方法中不能存在 this 关键字
* 静态的成员方法只能访问静态的成员变量或者成员方法,非静态可以访问静态的也可以访问非静态的
* 帮助文档: 帮助文档的查看要求必须掌握
* Math 类的随机数功能
* 调用一个方法: public static double random(): 获取一个大于等于0小于1.0的一个随机数
* 生成一个1~100的随机数:
int result = (int)(Math.random() * 100) + 1 ;
int result = Math.floor(Math.random() * 100) + 1 ;
day08-------------------------------------------------------------------------------------------------------------------------------------
* 代码块
* 概述: 在java语言中使用大括号括起来的内容
* 分类: 局部代码块 , 构造代码块 , 静态代码块 , 同步代码块(在多线程中讲解的)
** 局部代码块: 在局部位置 , 作用: 用来限定变量的生命周期,提早释放内存,提供内存的利用率
** 构造代码块: 在成员位置 , 优先于构造方法的执行而执行,每创建一次对象,就会执行一次
** 静态代码块: 在成员位置,前面需要添加一个 static 关键字. 随着类的加载而加载,优先于构造代码块 , 只执行一次
可以完成类的初始化工作
* 继承
** 继承的格式: class 子类 extends 父类 {}
** 继承的好处和弊端
* 好处:
** 提高了代码的复用性
** 提高了代码维护性
** 让类和类产生了关系,是多态的前提
* 弊端:
增强了耦合性
开发的原则是高内聚,低耦合
** 继承特点: 在java语言中值支持单继承,不支持多继承. 但是支持多层继承
** 继承的注意事项:
* 子类只能继承父类非私有的成员
* 父类的构造方法子类不能继承,但是可以通过 super 关键字去访问
* 不要为了某一些功能去使用继承
什么时候去使用继承呢?
继承体现的是一种"is a"的关系
举例:
水果
苹果
香蕉
西瓜
** 继承中的成员访问问题
* 成员变量
** 变量的访问遵循"就近原则"
** 查找顺序
在子类的局部位置查找
在子类的成员位置查找
在父类的成员位置查找
就报错了
* this 和 super 的区别:
** this 表示的本类对象的一个引用,谁调用我 this 就代表谁
** super 表示的是父类存储空间的一个标识,可以理解为就是父类对应的一个引用
** this 和 super 访问成员的格式
* 成员变量
this.变量名 访问本类的成员变量
super.变量名 访问父类的成员变量
* 构造方法
this(...) 访问本类的构造方法
super(...) 访问父类的构造方法
* 成员方法
this.方法名(...) 访问本类的成员方法
super.方法名(...)访问父类的成员方法
* 构造方法: 在创建子类的对象的时候,都需要默认的调用父类无参的构造方法,完成父类数据的初始化
this(...)和 super(...) 只能是构造方法第一条语句,不能共存
任何类都默认的继承自 Object
构造方法的第一条语句默认都是 super()
* 成员方法
** 查找顺序
首先在本类中查找
上父类中查找
就报错
* 方法重写
** 概述: 子类中出现了与父类一模一样的方法(方法名,参数列表,返回值类型)
** 作用: 沿袭父类的功能的同时可以添加自己特有的功能
* final 关键字
** 意思: 最终的
** 可以用来修饰类,变量,方法
被修饰的类,不能被子类继承
被修饰的变量,其实是一个常量,只能赋值一次
被修饰的方法,不能被子类重写
day09-------------------------------------------------------------------------------------------------------------------------------------
* 多态
* 概述: 就是同一个事物在不同时刻表现出来的不同状态
* 前提:
** 继承关系
** 方法重写
** 父类的引用指向子类对象
* 多态的成员访问问题
** 成员变量: 编译看左边 , 运行看左边
** 构造方法: 子类在初始化的时候,都默认的要调用父类无参的构造方法,对父类数据进行初始化
** 成员方法:
* 静态成员方法 编译看左边 ,运行看左边
* 非静态成员方法 编译看左边 ,运行看右边
* 多态的好处:
** 提高的代码的维护性
** 提高了代码的扩展性
* 多态的弊端: 多态的形式不能访问子类特有的功能
* 如果我们想访问子类特有的功能,需要向下转型
向下转型: 就是把父类的引用强制转换成子类的引用格式: 子类 对象名 = (子类)父类的引用 ;
向上转型: 就是父类的引用指向子类对象
* 抽象类
** 特点:
* 抽象类格式: public abstract class 类名 {}
* 抽象方法: public abstract 返回值类型 方法名();
* 如果一个类中存在抽象方法,那么该类就需要定义为抽象类
* 抽象类中可以有非抽象方法
* 抽象类不能进行直接实例化
* 抽象类中可以存在构造方法,这个构造方法的作用是用于子类在访问父类数据的时候,对父类的数据进行初始化
* 抽象类的子类
** 可以是抽象类 (意义不大)
** 可以是非抽象类,这个类需要重写父类中所有的抽象方法
** 成员特点
* 成员变量 可以是变量,也可以是常量
* 构造方法 存在构造方法作用是用于子类在访问父类数据的时候,对父类的数据进行初始化
* 成员方法 可以是抽象方法,也可以是非抽象方法
* 接口
** 特点:
* 格式: public interface 接口名 {}
* 接口中没有构造方法
* 接口不能进行直接实例化
* 接口中只能存在抽象方法
* 接口的子类
** 可以是抽象类 (意义不大)
** 可以是非抽象类 ,这个类需要重写接口中所有的抽象方法
** 成员特点:
* 成员变量 只能是常量,存在默认的修饰符 public static final
* 构造方法 没有构造方法
* 成员方法 只能是抽象方法, 存在默认的修饰符 public abstract
* 抽象类和接口的区别
** 成员区别: 另请参见729行和748行
** 关系的区别
* 类与类 继承的关系,只能是单继承,可以是多层继承
* 类与接口 实现的关系 ,可以是单实现,也可以是多实现,并且一个类在继承一个类的同时去实现多个接口
* 接口和接口 继承的关系 ,可以是单继承,也可以是多继承
** 设计理念的区别
* 抽象类可以被继承 体现的是一种"is a"的关系 抽象类中定义的一般都是该继承体系中共性的内容
* 接口可以被实现 体现的是一种"like a"的关系 接口中定义的一般都是该继承体系中扩展性的内容. 可以用来解耦 , 定义规范
day10-------------------------------------------------------------------------------------------------------------------------------------
* 参数传递问题 : 要的都是对象
* 四种权限修饰符
private 默认 protected public (权限依次从小到大)
本类 同一个包不同包的子类不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y YY
* 内部类:
** 概述: 就是把一个类定义在另一个类中,那么这个类就被称之为内部类
** 特点:
* 内部类可以直接访问外部类的成员,包含私有的
* 外部类要访问内部类的成员,需要创建内部类的对象
** 分类:
* 成员内部类: 就是把一个类定义在另一个类的成员位置
其他类访问内部类创建对象的格式:外部类.内部类 对象名 = 外部类对象.内部类对象 ; Outer.Inter ou = new Outer().new Inter() ;
常见的修饰符: static , private
private: 保证了数据的安全性
static : 为了方便外部访问
被static修饰了以后其他类访问内部类创建对象的格式:
外部类.内部类 对象名 = new 外部类名.内部类名() ;
Outer.Inner oi = new Outer.Inner() ;
* 局部内部类 就是把该类定义在局部位置 (方法定义中的位置)
* 局部内部类在访问局部变量的时候,局部变量必须被 final 修饰
* 匿名内部类
* 概述: 其实是局部内部类的一种简化的写法
* 前提: 需要有一个类或者接口
* 格式:
new 类名或者接口名(){
重写方法 ;
} ;
* 本质: 是一个继承了某一个类或者实现了某一个接口的子类对象
* 内部接口: 把接口定义在类中
public class Computer {
public interface Mermory {
}
}
==========================================================================================================================================
3. API
day11-------------------------------------------------------------------------------------------------------------------------------------
* eclipse
* Object 类
** 概述: 该类是所有的类的顶层父类,所有的类都是直接的或者间接的继承自该类
** 构造方法: public Object() ;
** 成员方法:
* public int hashCode():获取对象的哈希码值. 不同的对象哈希码值不同,相同的对象哈希码值相同
* public Class getClass():获取一个对象对应的类的字节码文件对象
** Class 类中的方法 : public String getName():获取字节码文件对象对应的全类名
* public String toString():返回的是一个对象的字符串表现形式,默认是返回的是 地址值
* public boolean equals(Object obj)比较两个对象是否相等,默认比较的是地址值
** 面试题: == 和 equals 的区别 ?
day12-------------------------------------------------------------------------------------------------------------------------------------
* Scanner
** 作用: 接收键盘录入数据的
** 构造方法: public Scanner(InputStream in) ;
** 成员方法:
* public int nextInt():获取一个int类型的值
* public String nextLine():获取一个String类型的值
** 小问题: 先获取int类型的值,在获取字符串类型的值.会出现问题.
* 解决方案:
** 重新创建一个 Scanner 对象
** 全部使用String进行接收 , 然后在使用基本数据类型包装类将其转换成指定的类型
* String
** 是一个字符串,就是把多个字符链接起来的一串数据.类似于字符数组
** 特点:
* 字符串字面值就是字符串的一个对象; 比如: "abc"
* 字符串一旦被创建就不能被改变. 不能被改变指的是值不能被改变
** 构造方法
* public String(byte[] bytes):把一个字节数组转换成一个字符串
* public String(byte[] bytes , int off , int len)把一个字节数组中的一部分转换成一个字符串
* public String(char[] chs):把一个字符数组转换成一个字符串
* public String(char[] chs , int off , int len)把一个字符数组中的一部分转换成一个字符串
** 成员方法
* 获取功能
public int length():获取字符串的长度。
public char charAt(int index):获取指定索引位置的字符
public int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
public int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
public int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
public String substring(int start):从指定位置开始截取字符串,默认到末尾。
public String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
* 判断功能
public boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
public boolean contains(String str):判断字符串中是否包含传递进来的字符串
public boolean startsWith(String str):判断字符串是否以传递进来的字符串开头
public boolean endsWith(String str):判断字符串是否以传递进来的字符串结尾
public boolean isEmpty():判断字符串的内容是否为空。
* 转换功能
public byte[] getBytes():把字符串转换为字节数组。
public char[] toCharArray():把字符串转换为字符数组。
public static String valueOf(char[] chs):把字符数组转成字符串。
public static String valueOf(int i):把int类型的数据转成字符串。
public String toLowerCase():把字符串转成小写。
public String toUpperCase():把字符串转成大写。
public String concat(String str):把字符串拼接。
* 其他功能
public String replace(char old,char new)将指定字符进行互换
public String replace(String old,String new)将指定字符串进行互换
public String trim()去除两端空格
public int compareTo(String str)
public int compareToIgnoreCase(String str)
day13-------------------------------------------------------------------------------------------------------------------------------------
* StringBuffer
** StringBuffer 是线程安全的一个可变字符序列
** 构造方法:
public StringBuffer():无参构造方法
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
** 成员方法
* 添加功能
public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
* 删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
* 替换
public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
* 反转功能
public StringBuffer reverse():字符串反转
* 截取功能
public String substring(int start):从指定位置截取到末尾
public String substring(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
** 字符串和字符串缓冲区的转换问题
* 字符串 ---- 字符串缓冲区a: 构造方法完成 b: append方法
* 字符串缓冲区 ---- 字符串a: 调用toString方法
** String 作为参数传递问题:String 虽然是一个引用数据类型,但是它在传递的时候是按照基本数据类型进行传递的
* StringBuffer 和 StringBuilder 的区别:
** StringBuffer是线程安全的可变字符序列 , 效率低
** StringBuilder是线程不安全的可变字符序列 , 效率高. 如果单线程建议使用 StringBuilder
* 数组的高级操作
** 冒泡排序
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length - 1 ; x++){
for(int y = 0 ; y < arr.length - 1 - x ; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
** 选择排序
public static void selectSort(int[] arr){
for(int x = 0 ; x < arr.length - 1 ; x++){
for(int y = x + 1 ; y < arr.length ; y++){
if(arr[x] > arr[y]){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
}
}
** 二分查找
public static int binarySearch(int[] arr , int value){
int minIndex = 0 ;
int maxIndex = arr.length - 1 ;
while(minIndex <= maxIndex){
int midIndex = (minIndex + maxIndex) >>> 1 ;
if(arr[midIndex] == value){
return midIndex ;
}else if(arr[midIndex] > value){
maxIndex = midIndex - 1 ;
}else if(arr[midIndex] < value){
minIndex = midIndex + 1 ;
}
}
return -1 ;
}
* Arrays
** 数组工具类,属于java.util ;
** 成员方法:
public static void sort(int[] a):排序
public static int binarySearch(int[] a, int key):二分查找
public static String toString(int[] a):把一个数组转换成一个字符串
* 基本数据类型包装类
** java针对每一种基本数据类型都提供了对应的包装类类型
基本数据类型 包装类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
** 构造方法:
public Integer(int i):把一个int类型的值转换成包装类类型
public Integer(String num):把一个数字字符串转换成一个包装类类型
** 成员方法:
public static int parseInt(String s):把一个数字字符串转换成int类型的值
public int intValue():获取Integer这个对象中封装的数字
public static String toString(int i):把一个int类型的数据转换成字符串
** 字符串 ---- int 类型的转换
Integer 类中的方法: public static int parseInt(String s):把一个数字字符串转换成int类型的值
** int 类型 ---- 字符串
String 类中的方法: public static String valueOf(int i)
Integer 类中的方法: public static String toString(int i):把一个int类型的数据转换成字符串
** jdk1.5的新特性自动拆装箱
* 自动拆箱: 就是把包装类类型转换成基本数据类型
* 自动装箱: 就是把基本数据类型转换成包装类类型
Integer i = 23 ;// 自动装箱
i += 45 ; // 先进行自动拆箱,然后在进行自动装箱
** 字节常量池: 在方法区中存在一个字节常量池,范围是 -128 ~ 127
** 常见的面试题:
Integer i1 = new Integer(127) ;
Integer i2 = new Integer(127) ;
System.out.println(i1 == i2) ;// false
Integer i3 = 127 ;
Integer i4 = 127 ;
System.out.println(i3 == i4) ;// true
Integer i5 = 128 ;
Integer i6 = 128 ;
System.out.println(i5 == i6) ;// false
day14-------------------------------------------------------------------------------------------------------------------------------------
* 正则表达式
** 概述: 就是正确规则的表达式
** 规则:
* 字符
x 就是表示是x字符
\\ 反斜线字符
\r 回车
\n 换行
* 字符类
[abc] 表示的是a或者b或者c
[^abc] 表示除了abc以外,其他的都可以
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括
* 预定义字符
. 表示任意的意思. 如果想表示.本身,就需要对.进行转义,使用 \\.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
* 边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界不是英文字母的地方hello world?haha;xixi
* 计量词
? 表示0次或者1次
* 表示0次或者多次
+ 表示1次或者多次
{n} 恰好n次
{n,} 至少n次
{n,m} 大于等于n次小于等于m次
* 字符串中和正则表达式相关的方法:
public boolean matches(String regex):校验一个字符串是否匹配regex这个正则表达式
public String[] split(String regex):就是把一个字符串使用regex这个正则表达式进行切割
public String replaceAll(String regex,String replacement)把一个字符串中符合regex这正则表达式的字符串使用replacement这个字符串进行替换
* 和获取功能相关的两个类 Pattern(模式器) 和 Matcher(匹配器)
** 典型的应用:
// 把一个正则表达式封装成一个模式器对象
Pattern p = Pattern.compile("a*b");
// 通过模式器对象获取匹配器对象
Matcher m = p.matcher("aaaaab");
// 校验
boolean b = m.matches();
** 代码:
// 定义字符串
String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?"
// 定义正则表达式
String regex = "\\b[a-zA-Z]{3}\\b";
// 把一个正则表达式封装成一个模式器对象
Pattern p = Pattern.compile(regex);
// 通过模式器对象获取匹配器对象
Matcher m = p.matcher(s);
// 循环
while(m.find()){
System.out.println(m.group()) ;
}
* System
** 成员变量
public static final InputStream in ;标准输入流,对应的设备是键盘
public static final PrintStreamout ;标准输出流,对应的设备是显示器
** 成员方法
public void exit(int status):退出jvm.0表示正常退出
public void gc():运行垃圾回收器 , 本质上调用的是Object类中的finalize()
public static native long currentTimeMillis();获取当前系统时间对应的毫秒值
* Random
** 作用: 用来生成随机数
** 构造方法:
public Random():使用默认的种子创建一个Random对象
public Random(long seed):使用指定的种子创建一个Random对象
区别: 使用指定的种子创建对象以后,然后每一次获取的都是相同的随机数
** 成员方法:
public int nextInt():获取一个int范围内的随机数
public int nextInt(int n):获取一个大于等于0小于n的随机数
* Math
** 作用: 定义了一些和数学运算相关的方法
** 成员方法:
public static int abs(int a)取绝对值
public static double ceil(double a)向上取整(掌握)
public static double floor(double a)向下取整(掌握)
public static int max(int a,int b) 获取最大值
public static int min(int a, int b)获取最小值
public static double pow(double a,double b)获取a的b次幂
public static double random()获取随机数返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
public static int round(float a) 四舍五入 (掌握)
public static double sqrt(double a)获取正平方根
* BigDecimal
** 构造方法:
public BigDecimal(String val):把一个数字字符串转换成一个BigDecimal对象
** 成员方法:
public BigDecimal add(BigDecimal augend)加
public BigDecimal subtract(BigDecimal subtrahend)减
public BigDecimal multiply(BigDecimal multiplicand)乘
public BigDecimal divide(BigDecimal divisor)除
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)除 scale: 表示小数点后的位数. roundingMode: 取舍方式(BigDecimal.ROUND_HALF_UP;四舍五入)
* Date
** 构造方法:
public Date():创建一个日期对象
public Date(long time)把一个毫秒值转化成一个日期对象
** 成员方法:
public long getTime():获取当前日期对象对应的毫秒值
public void setTime(long time)给一个日期对应设置上具体的毫秒值
* SimpleDateFormat
** 作用: 把一个日期字符串解析成一个日期对象,获取把一个日期对象格式化成一个日期字符串
** 构造方法:
public SimpleDateFormat():使用默认的格式创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern): 使用指定的格式创建一个SimpleDateFormat对象
规则
y 年
M 月
d 天
H 时
m 分
s 秒
举例: yyyy-MM-dd HH:mm:ss
** 成员方法
public Date parse(String dateStr):把一个日期字符串解析成一个日期对象
public String format(Date date) :把一个日期对象格式化成一个日期字符串
* Calendar (日历类)
** 获取该类的对象: public static Calendar getInstance()
** 成员方法:
public int get(int field)获得给定日历字段对应的值
public void add(int field,int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year,int month,int date)设置日历时间
月份是从 0 开始的 一直到 11
==========================================================================================================================================
4. 集合
day15-------------------------------------------------------------------------------------------------------------------------------------
* 对象数组
** 概述: 就是用来存储对象的数组
** 举例: Student[] students = new Student[10] ;
* 集合的由来
** 集合和数组的区别:
* 长度区别
数组的长度是不可变的,集合的长度是可变的
* 存储数据类型的区别
数组可以存储基本数据类型的元素,也可以存储引用数据类型的元素
集合只能存储引用数据类型的元素
* 内容的区别
数组只能存储同一种数据类型的元素
集合可以存储多种数据类型的元素
* 集合的继承体系图
|-- Collection(接口)
|--- List(接口)
|----- ArrayList (类)
|----- Vector (类)
|----- LinkedList(类)
|--- Set (接口)
|----- HashSet (类)
|----- TreeSet (类)
* 成员方法
boolean add(E e)添加元素
boolean remove(Object o)删除元素
void clear() 删除所有的元素
boolean contains(Object o)判断是否包含o这个元素
boolean isEmpty()判断是否为空
int size() 获取集合的长度
boolean addAll(Collection c)添加一个集合的元素
boolean removeAll(Collection c)删除一个集合的元素,删除一个以上算是删除
boolean containsAll(Collection c)判断是否包含一个集合的元素,包含所有的才算是包含
boolean retainAll(Collection c)获取交集. A集合对B集合取交集,获取的交集元素存储到A中,返回的boolean类型的值表示的A集合是否发生改变
Object[] toArray() :把一个集合转换成数组
Iterator iterator():获取迭代器Iterator, 是集合的一种遍历方式
* 遍历
使用迭代器进行遍历集合
代码:
// 创建集合对象
Collection col = new ArrayList() ;
// 添加元素
col.add("刘亦菲");
col.add("范冰冰");
col.add("李冰冰");
// 获取迭代器
Iterator it = col.iterator() ;
// 循环
while(it.hasNext()){
// 获取
Object obj = it.next() ;// next方法的特点: 获取元素,并把指针向后移动一位
// 输出
System.out.println(obj) ;
}
* List 集合
** 特点: 元素有序,可以重复 , 每一个元素都具有一个整数索引
** 特有的功能:
void add(int index,E element):在index索引处添加element这个元素
E remove(int index):删除index索引处对应的元素
E get(int index):获取index索引处对应的元素
E set(int index,E element):给index索引设置element这个元素
** List 集合特有的遍历方式
* 使用for循环配合get和size方法
* 代码
for(int x = 0 ; x < list.size() ; x++){
System.out.println(list.get(x)) ;
}
* 数据结构
** 概述: 就是存储数据的方式
** 分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表
** 每一种数据结构的特点:
栈 : 先进后出
队列: 先进先出
数组: 查询快 , 增删慢
链表: 查询慢 , 增删快
* List 集合的三个子类的特点
** ArrayList 底层的数据结构是数组,查询快,增删慢.线程不安全,效率高
** Vector 底层的数据结构是数组,查询快,增删慢.线程安全,效率低
** LinkedList 底层的数据结构是链表,查询慢,增删快,线程不安全,效率高
day16-------------------------------------------------------------------------------------------------------------------------------------
* List 集合的三个子类
** ArrayList
** Vector
* 成员方法
public void addElement(E obj)添加元素
public E elementAt(int index)获取index索引处对应的元素
public Enumeration elements()遍历Vector集合,类似于 Iterator
** LinkedList
* 成员方法
public void addFirst(E e)在第一个位置添加元素
public void addLast(E e)在最后一个位置添加元素
public E getFirst()获取第一个位置对应的元素
public E getLast()获取最后一个位置对应的元素
public E removeFirst()删除第一个位置对应的元素
public E removeLast()删除最后一个位置对应的元素
** 使用 LinkedList 模拟栈的数据结构
代码:
public class MyLikedList {
private LinkedList list ;
public MyLikedList(){
list = new LinkedList() ;
}
public void add(Object obj){
list.addFirst(obj) ;
}
public Object get(){
return list.removeFirst() ;
}
public boolean isEmpty(){
return list.isEmpty() ;
}
}
* 泛型
** 概述: 是一种把类型的明确工作推迟到了创建对象或者调用方法的时候的一种特殊的类型
** 格式: <数据类型 , 数据类型 , ...> 这个数据类型只能是引用数据类型
** 好处:
* 把运行期的错误提前到了编译期
* 省去了向下转型
* 去除了黄色警告线
** 泛型的应用
* 泛型类 就是把泛型定义在一个类上
举例: public class Student<T> {}
* 泛型方法 就是把泛型定义在方法上
举例: public <T> void show(T t){}
* 泛型接口 就是把泛型定义在接口上
举例: public interface Inter<T> {}
** 泛型通配符:
? 表示的是任意的
? extends E 向下限定,表示的是E或者E的子类
? super E 向上限定,表示的是E或者E的父类
* 增强for循环 (掌握)
** 作用: 就是为了简化集合和数组的遍历
** 格式:
for(数据类型 变量名 : 数组或者Collection集合的名称){
直接使用变量名,这里的变量名其实就是数组或者Collection集合中的元素.
}
举例: int[] arr = {23, 45, 67} ;
for(int a : arr){
System.out.println(a);
}
* 静态导入: (了解)
** 格式: import static 包名.类名.方法名 ;
* 可变参数: (了解)
** 格式: public 返回值 方法名(数据类型... 变量名) {};
** 本质: 是一个数组
** 注意事项: 这个可变参数只能定义位该方法的最后一个参数
day17-------------------------------------------------------------------------------------------------------------------------------------
* 登录注册案例
* Set 集合
** 特点: 元素无序 , 可以保证元素的唯一性
** HashSet
* 数据结构: 是哈希表, 要使用该集合保证元素的唯一性,就需要重写hashCode方法和equals方法
* 遍历方式:
** 第一种使用迭代器
** 第二种使用增强for
** TreeSet
* 可以对元素进行排序.
排序方式有两种:
** 第一种自然排序
** 比较器排序
到底使用的是哪一种排序取决于构造方法:
public TreeSet():使用自然排序,对元素有要求,要求这个元素必须实现Comparable接口.
不明白为什么要实现这个接口,请看TreeMap中第557行代码
public TreeSet(Comparator comparator): 使用比较器排序
** LinkedHashSet : 底层的数据结构是链表和哈希表 , 元素有序(靠链表保证) , 并且唯一(靠哈希表保证)
day18-------------------------------------------------------------------------------------------------------------------------------------
* Map 集合
** Map 集合 和 Collection 集合的区别
* Map 集合是双列集合,而 Collection 集合是单列集合 ; Map 集合就像是夫妻对 , Collection 集合就像是 孤狼
* Map 集合的键唯一 , 而Collection集合中的Set集合可以保证元素的唯一性
* Map 集合的数据结构之和键有关系,而Collection集合的数据结构和元素是有关系的
* 成员方法
V put(K key,V value)添加元素
V remove(Object key)删除元素
void clear() 删除所有的元素
boolean containsKey(Object key)判断是否包含这个键
boolean containsValue(Object value)判断是否包含这个值
boolean isEmpty()判断是否为空
int size() 获取集合的长度
V get(Object key)根据键获取值
Set<K> keySet()获取所有的键对应的set集合
Collection<V> values()获取所有的值对应的Collection集合
Set<Map.Entry<K,V>> entrySet()获取所有的键值对对象对应的Set集合
* 遍历
Map<String , String> map = new HashMap<String , String>() ;
map.put("邓超" , "孙俪") ;
map.put("文章" , "马伊琍") ;
map.put("陈赫" , "张子萱") ;
** 键找值
* 思路:
** 获取所有的键对应的set集合
** 遍历Set集合获取每一个键,然后在根据键获取指定的值
* 代码:
Set<String> keys = map.keySet() ;
for(String key : keys) {
// 根据键找值
String value = map.get(key) ;
// 输出
System.out.println(key + "---" + value) ;
}
** 通过键值对对象获取键和值
* 思路
** 获取所有的键值对对象对应的Set集合
** 遍历Set集合获取每一个键值对对象,然后在获取键和值
* 代码
Set<Entry<String , String>> en = map.entrySet() ;
for(Entry<String , String> e : en){
String key = e.getKey() ;
String value = e.getValue() ;
System.out.println(key + "---" + value) ;
}
* HashMap 和 TreeMap
* LinkedHashMap : 底层的数据结构是链表和哈希表 , 元素有序(靠链表保证) , 并且唯一(靠哈希表保证)
* Hashtable 和 HashMap 的区别 :
** HashMap 是线程不安全,允许 null 值和 null 键
** Hashtable 是线程安全的,不允许有 null 值 和 null键
* Collections
** 概述: 集合工具类
** 成员方法:
public static <T> void sort(List<T> list):排序,默认按照自然顺序
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):获取最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换
==========================================================================================================================================
5. IO流
day19-------------------------------------------------------------------------------------------------------------------------------------
* 异常
** 概述: 就是在程序的运行过程中可能出现的问题
** 分类:
Throwable 问题
|- Error 严重性问题
|- Exception 非严重性问题
|-- 编译期异常 就是非 RuntimeException
|-- 运行期异常 就是 RuntimeException 或者 RuntimeException 的子类
** JVM对异常的默认处理方式:就是把异常的信息打印到控制台,并结束程序
** 对异常的处理方式:
* try .... catch 语句....
** 格式:
try {
可能出现问题的代码 ;
}catch (异常名 变量名){
对异常的具体处理方式;
}finally {
释放资源的代码 ;
}
简化版:
try {
可能出现问题的代码 ;
}catch (异常名 变量名){
对异常的具体处理方式;
}
注意事项:
* try 中的代码越少越好
* catch 中要做处理
变形版:
try {
可能出现问题的代码 ;
}catch (异常名1 变量名1){
对异常的具体处理方式;
}catch (异常名2 变量名2){
对异常的具体处理方式;
}
...
注意事项:
* 如果多个catch中存在子父类的继承关系,那么父类必须是最后一个catch
* 如果多个catch中不存在子父类的继承关系,那么顺序无所谓
* 如果我们可以明确异常信息,那么尽量不要使用大的异常
* 就是编译期异常和运行期异常的区别
** 编译期异常,我们必须对其进行处理
** 运行期异常可以处理,也可以不处理
* Throwable 中常见的方法:public void printStackTrace() : 打印出异常的堆栈信息
* throws 和 throw 的区别:
throws 用在方法定义上,用来给方法添加一个异常的声明(异常可以是多个);
throw 用在方法定义中,后面跟一个异常对象(可以是编译期异常,可以是运行期异常). 用来抛出一个异常
* finally : 特点:就是该代码始终被执行(JVM不能退出)
存放的代码作用: 用来释放资源
* 自定义异常: 定义一个类,然后让该类去继承 RuntimeException 或者 Exception
* File 类
** 概述: 是文件或者文件夹的抽象表示形式
** 构造方法:
public File(String filePath):使用文件路径创建一个File对象
public File(String parentPath , String filePath) ;使用父路径和子文件或者文件夹创建一个File对象
public File(File parentFile , String filePath) ;使用父文件和子文件或者文件夹创建一个File对象
** 成员方法:
public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
public boolean delete():删除文件或者文件夹
public boolean renameTo(File dest): 把文件重命名为指定的文件路径
public boolean isDirectory():判断是否是目录
public boolean isFile():判断是否是文件
public boolean exists():判断是否存在
public boolean canRead():判断是否可读
public boolean canWrite():判断是否可写
public boolean isHidden():判断是否隐藏
public String getAbsolutePath()：获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public long length():获取长度。字节数
public long lastModified():获取最后一次的修改时间，毫秒值
public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)
day20-------------------------------------------------------------------------------------------------------------------------------------
* 递归
** 概述: 方法定义中调用方法本身的现象
** 注意事项:
* 递归一定要有出口
* 递归的次数不宜过多
* 构造方法不能使用递归
** 递归的练习题:
* 5!
* 斐波那契数列
* 递归删除
* 递归打印
* IO流的概述和分类
** IO: Input Output
** 作用: 进行数据传输
** 什么是输入和输出:相对于内存而言
** 分类:
* 按照流向进行划分
** 输入流
** 输出流
* 按照操作数据类型进行划分
** 字节流
* 字节输入流 InputStream 读
* 字节输出流 OutputStream 写
** 字符流
* 字符输入流 Reader 读
* 字符输出流 Writer 写
* 字节流
** FileInputStream
* 构造方法
public FileInputStream(String filePath)
public FileInputStream(File file)
* 成员方法
public int read():一次读取一个字节
public int read(byte[] bytes)一次读取一个字节数组
** FileOutputStream
* 构造方法
public FileOutputStream(String filePath)
public FileOutputStream(File file)
* 成员方法
public void write(int by)一次写一个字节
public void write(byte[] bytes)一次写一个字节数组
public void write(byte[] bytes , int off , int len)一次写一个字节数组中的一部分
** BufferedInputStream
* 构造方法
public BufferedInputStream(InputStream in)
* 成员方法
public int read():一次读取一个字节
public int read(byte[] bytes)一次读取一个字节数组
** BufferedOutputStream
* 构造方法:
public BufferedOutputStream(OutputStream out)
* 成员方法
public void write(int by)一次写一个字节
public void write(byte[] bytes)一次写一个字节数组
public void write(byte[] bytes , int off , int len)一次写一个字节数组中的一部分
day21-------------------------------------------------------------------------------------------------------------------------------------
* 字符流的由来: 为了方便的操作中文,java就给我们提供了字符流
字符流 = 字节流 + 编码表
编码表:
ASCII '0' --- 48 , 'a' --- 97 , 'A' --- 65
GB2312
GBK (常用)
UNICODE
UTF-8 (常用)
* 字符串中的编解码问题
** 编码: 就是把字符串转换成字节数组
方法:
public byte[] getBytes()使用平台默认的字符集把一个字符串转换成字节数组
public byte[] gteBytes(String charsetName)使用平台指定的字符集把一个字符串转换成字节数组
** 解码: 就是把字节数组转换成字符串
方法:
public String(byte[] bytes)使用平台默认的字符集把一个字节数组转换成一个字符串
public String(byte[] bytes , String charSetName) 使用指定的字符集把一个字节数组转换成一个字符串
** 编解码问题: 使用什么进行编码,就是用什么进行解码
* 字符流: *****************************如果我们需要使用编码表,那么就只能使用转换流*****************************
** 转换流
* 转换输入流 InputStreamReader
** 构造方法: public InputStreamReader(InputStream in) ;
public InputStreamReader(InputStream in , String charsetName) ;
** 成员方法:
public int read():一次读取一个字符
public int read(char[] chs)一次读取一个字符数组
* 转换输出流 OutputStreamWriter
** 构造方法: public OutputStreamWriter(OutputStream out) ;
public OutputStreamWriter(OutputStream out , String charsetName) ;
** 成员方法:
public void write(int ch)一次写一个字符
public void write(char[] chs)一次写一个字符数组
public void write(char[] chs , int off , int len)一次写一个字符数组中的一部分
public void write(String str)一次写一个字符串
public void write(String str , int off , int len)一次写一个字符串中的一部分
** 便捷类
* 由来: 由于转换流的名称太长,并且在一般情况下也不需要制定编码表
* 便捷类和转换流的对应的关系
转换流 便捷类
InputStreamReaderFileReader
OutputStreamWriterFileWriter
* 没有特有的功能
** 高效的字符流
* 高效的字符输入流 BufferedReader
** 构造方法: public BufferedReader(Reader r)
** 特有的方法: public String readLine() 一次读取一行
* 高效的字符输出流 BufferedWriter
** 构造方法 public BufferedWriter(Writer w)
** 特有的方法: public void newLine() 写一个换行符
day22-------------------------------------------------------------------------------------------------------------------------------------
* 数据输入输出流 (了解)
** 数据输入流 DataInputStream
** 数据输出流 DataOutputStream
** 可以操作任意的数据类型
* 内存操作流
a:操作字节数组 (理解)
ByteArrayOutputStream
ByteArrayInputStream
b:操作字符数组
CharArrayWrite
CharArrayReader
c:操作字符串
StringWriter
StringReader
代码:
public static void main(String[] args){
// 创建对象
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 写数据
baos.write("张三".getBytes()) ;// 这个数据写入到了内存中
// 创建对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()) ;
// 读取数据
byte[] bytes = new byte[1024] ;
int len = 0 ;
while((len = bais.read(bytes)) != -1){
System.out.print(new String(bytes , 0 , len)) ;
}
}
* 打印流 (掌握)
** 字节打印流 PrintStream
** 字符打印流 PrintWriter
** 特点:
* 只能操作目的地不能操作数据源(只能写数据,不能读取数据)
* 可以操作任意数据类型的数据
* 如果我们启动了自动刷新,那么在调用printf , println , format方法的时候,会进行自动刷新
* 可以直接操作文件的流对象
** 构造方法:
* public PrintWriter(String filePath)
* public PrintWriter(File file)
* public PrintWriter(OutputStream out , boolean autoflush)启动自动刷新
* public PrintWriter(Writer out , boolean autoflush)启动自动刷新
** 成员方法:
* public void print(...)不带换行
* public void println(...)带换行
* 序列化流 (理解)
** 序列化: 就是把对象通过流的方式存储到文本文件中
** 反序列化: 就是把文本文件中的数据通过流的方式还原成一个对象
** 注意事项: 一个对象可以被序列化的前提,是这个对象对应的类必须实现Serializable
** 序列化流: ObjectOutputStream
* 构造方法: public ObjectOutputStream(OutputStream out)
* 成员方法: public void writeObject(Object obj)
** 反序列化: ObjectInputStream
* 构造方法: public ObjectInputStream(InputStream in)
* 成员方法: public Object readObject() ;
** transient: 如果我们不想让某一个字段被序列化,那么就使用该关键字修饰
* 随机访问流
** 特点:
* 可以操作任意的数据类型
* 父类为 Object
* 既可以读取数据也可以写数据
** 构造方法: public RandomAccessFile(File file, String mode): mode: 表示读写模式
** 成员方法:
* public native long getFilePointer() throws IOException;获取文件指针
* public native void seek(long pos) throws IOException;设置文件指针
* Properties
** 属于双列集合 , 父类是Hashtable
** 特点:
* 键和值都是字符串
* 可以和IO流进行配合使用
** 构造方法: public Properties()
** 成员方法:
public Object setProperty(String key,String value)添加元素
public String getProperty(String key)根据键获取值
public Set<String> stringPropertyNames()获取所有的键对应的Set集合
public void load(Reader reader)把一个文本文件中的数据加载到集合中
public void store(Writer writer,String comments)把集合中的数据存储到文本文件中
==========================================================================================================================================
6. 多线程,GUI,网络编程,反射
1. java基础语法
day01:
* 键盘的快捷键
* 常用的dos命令
D: 盘符切换(格式: 盘符号:) , 表示切换到D盘
dir 列出当前路径下所有的文件或者文件夹信息
cd 路径 表示切换到指定的路径
cd .. 表示回退到上一级目录
cls 清屏
exit 退出
cd /d 路径 进行跨盘的切换路径
* java语言的概述
java语言是1995年产生的
java语言的平台版本分类:
javaSe: 标准版,是其他两个技术的基础
javaMe: 小型版,用来开发一些移动端的小应用(已经被Android取代了)
javaEE: 企业版,开发一些企业级应用
* java语言的跨平台性:
跨平台: 就是一个java应用程序可以在多个平台之间进行运行.这个实现其实是靠JVM实现的.所以我们说jvm是不跨平台的
* JRE 和 JDK
* JRE: 是java的运行环境,一个java应用程序要运行起来,必须要有JRE. JRE = JVM + Java核心类库
* JDK: 是java的开发工具. JDK = JRE + Java的开发工具
* 由jdk开发的程序交由jre运行,由jvm实现跨平台
* 第一个java程序HelloWorld
* 环境变量:
* path 作用: 是为了让我们的java和javac命令可以在任意路径下进行执行
* classpath 作用: 是为了让字节码文件在任意路径下都可以执行(不用配置)
刚装的系统一定要配置环境变量
* 注释
* 概述: 就是用来解释说明程序的文字
* 分类:
单行注释 //
多行注释 /* 注释的内容 */
文档注释 /** 注释的内容 */
多行注释的注意事项: 不能嵌套使用
* 作用
* 用来解释说明程序
* 调试程序
* 标识符
* 概述: 就是给类,接口,方法,变量和常量起名字时使用的字符序列 ; 起名字要做到"见名知意"
* 组成规则:
** 英文大小写字母组成
** 数字字符
** $和_
* 注意事项:
** 不能以数字开头
** 不能是java语言中的关键字
** 区分大小写
* 关键字
* 概述: 就是被java语言赋予特殊含义的单词
* 特点:
** 组成都是小写字母
** goto 和 const 是java语言中的保留字
** 高级文本编辑器中会变色
* 命名规则
** 包 字母都是小写
** 类和接口
* 一个单词 首字母大写
* 多个单词 每一个单词的首字母大写,其余字母小写
** 方法和变量
* 一个单词 全部小写
* 多个单词 从第二个单词开始首字母大写
** 常量
* 一个单词 字母全部是大写
* 多个单词 字母全部是大写,每一个单词之间使用"_"链接
day02:-----------------------------------------------------------------------------------------------------------------------------------
* 常量
* 概述: 就是在程序的执行过程中其值不发生改变的量
* 分类:
** 自定义常量(面向对象部分讲解)
** 字面值常量
* 字符串常量 使用双引号引起来的内容 "HelloWorld"
* 整数常量 包含所有的整数 23 , 45
* 小数常量 包含所有的小数 1.34 , 5.67
* 字符常量 使用单引号引起来的内容 'a' , 'A' , '0' (注意事项:单引号中只能是单个数字单个字母和单个符号)
* 布尔常量 true 和 false
* 空常量 null
* 变量
* 概述: 就是在程序的执行过程中其值可以发生改变的量.定义一个变量其实就是在内存中开辟了一小块区域.
* 定义格式: 数据类型 变量名 = 变量值 ; 变量名: 就是合法的标识符 ; 变量值: 其实就是常量
* 数据类型分类:
** 引用数据类型: 类 , 数组 , 接口
** 基本数据类型:
* 数值型
** 整数型: byte(-128 ~ 127) , short , int , long
** 浮点数: float , double
* 字符型: char(0~65535)
* 布尔型: boolean
* 变量的注意事项:
** 变量必须赋值以后才能使用
** 一个变量定义在了哪一级大括号中,那么这个变量的作用域就是这对大括号,出了大括号就不能再使用
* 数据类型转换
** 隐式转换: 由小的数据范围到大的数据范围的转换
* boolean 不能转换成其他的数据类型
* byte , short , char ---- int ----- long ---- float ---- double
* byte , short ,char 之间不转换,它们在参与运算的时候会自动转换成 int 类型
** 强制转换: 由大的数据范围到小的数据范围的转换
* 格式: 目标数据类型 变量名 = (目标数据类型)(待转换的数据) ;
* 注意事项: 尽量不要使用强制类型转换,因为可能存在损失精度的问题
* 字符和字符串参与运算的情况
* 字符在参与运算的时候,会转换成int类型的值,需要去查ASCII码表找到对应的十进制数据
'a' --- 97 , 'A' --- 65 , '0' --- 48
* 字符串在参与运算的情况:
** 任何数和字符串进行相加得到的结果都是一个新的字符串
** +号在这个地方表示的是字符串链接符
* 运算符
* 分类:
** 算术运算符: + , - , * , / , % , ++ , --
/ : 两个整数相除得到的结果是一个整数,获取的是除法的商
% : 获取的是除法的余数.结果的正负号和参与运算的左边的数据的符号一致
++: 作用: 自增1
使用:
* 单独使用(开发中常用) ++在前和++在后对计算结果没有影响
* 参与运算的使用 ++在前先进行自增1然后在参与运算,++在后先参与运算,然后在自增1
** 赋值运算符: = , += , -= , *= , /= , %=
* 注意事项: 要求左边必须是一个变量
* +=: 把左边的数据和右边的数据进行加法运算,然后在赋值给左边
* 这几个扩展的赋值运算符隐含和强制类型转换
** 比较运算符: > , < , >= , <= , == , != , instanceof
* 特点: 运算完毕以后会返回一个boolean类型的值
* 注意事项: 不能将"=="写成一个"="
day03----------------------------------------------------------------------------------------------------------------------
* 运算符
** 逻辑运算符: & , | , ! , ^ , && , ||
* &&(短路与): 左边为false的时候右面就不执行; 有false则false
* ||(短路或): 左边为true的时候右面就不执行 ; 有true则true
* ! : 非false则true,非true则false
** 位运算符 : & , | , ^ , ~ , << , >> , >>>
* 注意事项: 都是对二进制数据的补码进行运算的
* <<的特点: 用左边的数据乘以2的移动次幂
* >>的特点: 用左边的数据除以2的移动次幂
* >>>的特点: 得到的结果都是一个正数
** 三元运算符: (比较表达式) ? 表达式1 : 表达式2 ;
* 执行流程: 首先计算比较表达式的值,看其返回结果是true还是false,如果是true就执行表达式1 , 如果是false就执行表达式2 ;
* 键盘录入数据
** 导包: 格式: import java.util.Scanner ; 位置: 在 class 上面
** 创建键盘录入对象: 格式: Scanner sc = new Scanner(System.in) ;
** 获取键盘录入数据: 格式: int x = sc.nextInt() ;
* 流程控制语句
** 顺序结构: 没有特定的语法规则,执行顺序: 从上到下依次执行
** 选择结构:
* if 语句
** if 语句的第一种格式
if(比较表达式或者 boolean 类型的值){
语句体 ;
}
执行流程: 计算比较表达式的值,看其返回结果是true还是false,如果是true就执行语句体; 如果是false就不执行语句体
** if 语句的第二种格式
if(比较表达式或者 boolean 类型的值){
语句体1 ;
}else {
语句体2 ;
}
执行流程: 计算比较表达式的值,看其返回结果是true还是false,如果是true就执行语句体1 , 如果是false就执行语句体2
** if 语句的第三种格式
if(比较表达式1或者 boolean 类型的值1){
语句体1 ;
}else if(比较表达式2或者 boolean 类型的值2){
语句体2 ;
}else if(比较表达式3或者 boolean 类型的值3){
语句体3 ;
}
... // 表示的意思是else if(....){} 这个语句可以有多个
else {
语句体n+1 ;
}
执行流程: 计算比较表达式1的值,看其返回结果是true还是false,如果是true就执行语句体1 ,
如果是false就计算比较表达式2的值,看其返回结果是true还是false,如果是true就执行语句体2,
如果是false就计算比较表达式3的值,看其返回结果是true还是false,如果是true就执行语句体3,
....
如果前面的表达式的值都是false那么,就执行else对应的语句体
注意事项: else 语句可以省略的
* switch 语句
格式:
switch(表达式){
case 值1 :
语句体1 ;
break ;
case 值2 :
语句体2 ;
break ;
...
default:
语句体n+1 ;
break ;
}
表达式的取值: byte , short , int , char
jdk1.5以后可以取枚举
jdk1.7以后可以去字符串
执行流程:
首先计算表达式的值,然后在和case后面的值进行匹配,如果匹配成功,那么就执行对应的语句体
如果没有找到对应的case的值,那么就执行default对应的语句体
day04----------------------------------------------------------------------------------------------------------------------
* 循环结构
** for 循环
* 格式
for(初始化表达式语句 ; 判断条件语句 ; 控制条件语句){
循环体语句;
}
* 执行流程:
a: 首先执行初始化表达式语句
b: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
c: 执行循环体语句
d: 执行控制条件语句
e: 回到b继续
* 注意事项: 初始化表达式语句只执行一次
** while 循环
* while 语句
* 格式:
初始化表达式语句 ;
while(判断条件语句){
循环体语句;
控制条件语句
}
* 执行流程
a: 首先执行初始化表达式语句
b: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
c: 执行循环体语句
d: 执行控制条件语句
e: 回到b继续
* do...while 语句
* 格式:
初始化表达式语句 ;
do {
循环体语句;
控制条件语句
}while(判断条件语句);
* 执行流程
a: 首先执行初始化表达式语句
b: 执行循环体语句
c: 执行控制条件语句
d: 执行判断条件语句, 如果是true就继续执行,如果是false就结束循环
e: 回到b继续
* 三个循环语句的区别:
* do...while 循环是至少执行一次循环体的循环,而for和while,必须先判断条件是否成立,然后决定是否执行循环体语句
* 初始化循环变量的区别
* 两种特殊的死循环
* while(true){....}
* for(;;){......}
* 控制跳转语句
* break 中断
* 应用场景:
** 在switch语句中
** 在循环中
* 作用:
** 在switch语句中的作用,用来结束switch语句
** 在循环中
** 跳出单层循环 (默认)
** 跳出多层循环 (了解); 需要了解一个东西,就是带标签的语句: 格式: 标签名: 语句体
* continue 继续
* 应用场景: 在循环中
* 作用: 跳出本次循环执行下一步操作
* return 返回
* 作用: 就是用来结束一个方法的,把方法的返回值通过return带回给调用者
* 方法
* 方法作用: 就是对代码的一个封装 , 可以用来提高代码的复用性
* 定义格式:
修饰符 返回值类型 方法名(参数类型 参数名1 , 参数类型 参数名2 , ...){
方法体;
}
* 注意事项:
a: 方法不调用不执行
b: 方法的参数列表之间需要使用","隔开
c: 方法和方法是平级的关系,不能嵌套定义
d: 方法在调用的时候不用再传递数据类型
e: 如果一个方法有明确的返回值类型,那么就需要通过return带回一个具体的值
* 有明确返回值类型的方法调用
* 直接调用(了解)
* 赋值调用(推荐使用)
* 输出调用(可以使用)
* 没有明确返回值类型的方法调用
* 直接调用
* 方法重载: 就是在一个类中允许同时存在一个以上的同名方法,只要它们的参数列表不同,与返回值类型无关
* 参数列表不同:
参数的个数不同
参数的类型不同
day05-----------------------------------------------------------------------------------------------------------------------------------
* 一维数组
* 概述: 用来存储同一种数据类型的元素的容器
* 格式:
数据类型[] 数组名 ; // 推荐使用
数据类型 数组名[] ;
* 数组的初始化
* 动态初始化 就是由我们指定数组的长度,由系统分配默认的初始化值
* 静态初始化 就是由我们给出初始化值,由系统分配长度
* 注意事项 不能进行动静结合
* 动态初始化的格式:
数据类型[] 数组名 = new 数据类型[数组的长度] ;
数组的长度: 就是数组中存储元素的个数
* java语言的内存分配
* 栈: 存储的就是局部变量
局部变量: 就是方法定义中或者方法声明上的变量
* 堆: 存储的都是new出来的东西
* 特点:
** 系统会为每一个new出来的东西分配一个内存地址值
** 系统会为每一个元素赋一个默认的初始化值
byte , short , int , long --- 0
float , double --- 0.0
char --- '\u0000'
boolean --- false
引用数据类型 --- null
** 使用完毕以后就变成了垃圾,等待垃圾回收器对其进行回收
* 方法区(面向对象研究)
* 本地方法区(和系统相关)
* 寄存器(CPU)
* 数组的长度的获取: 需要使用 length 属性, 格式: 数组名.length
* 数组中每一个元素都存在一个整数索引,这个索引是从0开始,最大索引是: 数组的长度 - 1 ; 我们可以通过数组名配合索引获取数组中的元素的值
格式: 数组名[索引] ;
* 数组的常见操作
** 遍历
** 基本查找
** 获取最值
** 反转
代码:
public static void reverseArr(int[] arr){
for(int x = 0 , y = arr.length - 1 ; x <= y ; x++ , y--){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
** 查表法
思想: 使用数组模拟一张表,然后通过索引找出指定的值
代码:
public static String cha(int index){
// 模拟
String[] date = {"" , "星期一", "星期二" , "星期三" , "星期四" , "星期五" , "星期六" , "星期天"} ;
// 返回
return date[index] ;
}
* 静态初始化格式: 数据类型[] 数组名 = {元素1 , 元素2 , ....} ;
* 二维数组(了解)
* 格式: 数据类型[][] 数组名 = new 数据类型[m][n] ;
m: 表示的意思是这个二维数组中一维数组的个数
n: 表示的意思是每一个一维数组中的元素的个数
==========================================================================================================================================
2. 面向对象
day06-------------------------------------------------------------------------------------------------------------------------------------
* 面向对象的思想: 指挥对象做事情 , 体现到程序中: 就是创建对象调用方法
* 面向对象语言的三大特征: 封装 , 继承 , 多态
* 类和对象的关系
现实 java语言
事物 类
属性 成员变量
行为 成员方法
* 属性: 就是事物固有的特性
* 行为: 就是该事物可以做的事情
* 成员变量: 位置在类中方法外定义的变量
* 成员方法: 定义成员位置
* 类是一个抽象的东西,而对象是该类的具体的体现
* 创建对象的格式: 类名 对象名 = new 类名();
* 访问对象的属性: 对象名.属性名 ;
* 访问对象的方法: 对象名.方法名(...);
* 成员变量和局部变量的区别:(掌握)
* 在类中的位置不同
** 局部变量: 在方法定义中或者方法声明上
** 成员变量: 类中方法外
* 在内存中的位置不同
** 局部变量: 在栈内存中
** 成员变量: 在堆内存中
* 生命周期不同
** 局部变量: 随着方法的调用而产生,随着方法的消失而消失
** 成员变量: 随着对象的创建而产生,随着对象的消失而消失
* 初始化值的区别
** 局部变量: 没有默认的初始化值,必须赋值以后才能使用
** 成员变量: 有默认的初始化值
* 匿名对象: 就是没有名字的对象
作用:
a: 可以用来调用方法,仅仅调用一次
b: 作为参数传递
new Object() ;// 匿名对象
* private 修饰符: 可以用来修饰成员变量,也可以用来修饰成员方法. 被 private 修饰的成员只能在本类中访问
* this 关键字: 表示的是本类对象的一个引用,可以理解为就是本类的一个对象. 谁调用我方法中的 this 就代表谁
day07-------------------------------------------------------------------------------------------------------------------------------------
* 构造方法
** 特点:
* 方法名和类名相同
* 没有返回值类型,连void也没有
* 没有明确的返回值
** 作用: 创建对象使用的 new 关键字,但是创建对象的时候需要借助于构造方法. 构造方法的作用用来给的成员变量赋值,完成类的初始化工作
** 注意事项:
* 如果我们没有给出构造方法,那么系统会提供一个默认的无参的构造方法
* 如果我们给出了构造方法,那么系统将不会再提供默认无参的构造方法,那么这个时候如果我们还想借助于无参的构造方法创建对象,
那么我们就需要自己给出.建议始终给出
* 对象的创建步骤
Student s = new Student() ;
* 加载Student类对应的字节码文件到方法区
* 在栈内存中为s开辟空间
* 在堆内存中为new Student()开辟空间
* 对成员变量进行默认初始化
* 对成员变量进行显式初始化
* 调用构造方法对成员变量进行初始化
* 把堆内存中的地址值赋值给栈内存中的引用变量s
* static 关键字
** static 关键字是一个修饰符,可以用来修饰成员变量 , 也可以用来修饰成员方法
** 特点:
* 随着类的加载而加载
* 优先于对象存在
* 被类的所有的对象所共享
* 可以通过类名直接访问,本身也可以通过对象名访问,但是建议使用类名直接访问
** 注意事项:
* 在静态方法中不能存在 this 关键字
* 静态的成员方法只能访问静态的成员变量或者成员方法,非静态可以访问静态的也可以访问非静态的
* 帮助文档: 帮助文档的查看要求必须掌握
* Math 类的随机数功能
* 调用一个方法: public static double random(): 获取一个大于等于0小于1.0的一个随机数
* 生成一个1~100的随机数:
int result = (int)(Math.random() * 100) + 1 ;
int result = Math.floor(Math.random() * 100) + 1 ;
day08-------------------------------------------------------------------------------------------------------------------------------------
* 代码块
* 概述: 在java语言中使用大括号括起来的内容
* 分类: 局部代码块 , 构造代码块 , 静态代码块 , 同步代码块(在多线程中讲解的)
** 局部代码块: 在局部位置 , 作用: 用来限定变量的生命周期,提早释放内存,提供内存的利用率
** 构造代码块: 在成员位置 , 优先于构造方法的执行而执行,每创建一次对象,就会执行一次
** 静态代码块: 在成员位置,前面需要添加一个 static 关键字. 随着类的加载而加载,优先于构造代码块 , 只执行一次
可以完成类的初始化工作
* 继承
** 继承的格式: class 子类 extends 父类 {}
** 继承的好处和弊端
* 好处:
** 提高了代码的复用性
** 提高了代码维护性
** 让类和类产生了关系,是多态的前提
* 弊端:
增强了耦合性
开发的原则是高内聚,低耦合
** 继承特点: 在java语言中值支持单继承,不支持多继承. 但是支持多层继承
** 继承的注意事项:
* 子类只能继承父类非私有的成员
* 父类的构造方法子类不能继承,但是可以通过 super 关键字去访问
* 不要为了某一些功能去使用继承
什么时候去使用继承呢?
继承体现的是一种"is a"的关系
举例:
水果
苹果
香蕉
西瓜
** 继承中的成员访问问题
* 成员变量
** 变量的访问遵循"就近原则"
** 查找顺序
在子类的局部位置查找
在子类的成员位置查找
在父类的成员位置查找
就报错了
* this 和 super 的区别:
** this 表示的本类对象的一个引用,谁调用我 this 就代表谁
** super 表示的是父类存储空间的一个标识,可以理解为就是父类对应的一个引用
** this 和 super 访问成员的格式
* 成员变量
this.变量名 访问本类的成员变量
super.变量名 访问父类的成员变量
* 构造方法
this(...) 访问本类的构造方法
super(...) 访问父类的构造方法
* 成员方法
this.方法名(...) 访问本类的成员方法
super.方法名(...)访问父类的成员方法
* 构造方法: 在创建子类的对象的时候,都需要默认的调用父类无参的构造方法,完成父类数据的初始化
this(...)和 super(...) 只能是构造方法第一条语句,不能共存
任何类都默认的继承自 Object
构造方法的第一条语句默认都是 super()
* 成员方法
** 查找顺序
首先在本类中查找
上父类中查找
就报错
* 方法重写
** 概述: 子类中出现了与父类一模一样的方法(方法名,参数列表,返回值类型)
** 作用: 沿袭父类的功能的同时可以添加自己特有的功能
* final 关键字
** 意思: 最终的
** 可以用来修饰类,变量,方法
被修饰的类,不能被子类继承
被修饰的变量,其实是一个常量,只能赋值一次
被修饰的方法,不能被子类重写
day09-------------------------------------------------------------------------------------------------------------------------------------
* 多态
* 概述: 就是同一个事物在不同时刻表现出来的不同状态
* 前提:
** 继承关系
** 方法重写
** 父类的引用指向子类对象
* 多态的成员访问问题
** 成员变量: 编译看左边 , 运行看左边
** 构造方法: 子类在初始化的时候,都默认的要调用父类无参的构造方法,对父类数据进行初始化
** 成员方法:
* 静态成员方法 编译看左边 ,运行看左边
* 非静态成员方法 编译看左边 ,运行看右边
* 多态的好处:
** 提高的代码的维护性
** 提高了代码的扩展性
* 多态的弊端: 多态的形式不能访问子类特有的功能
* 如果我们想访问子类特有的功能,需要向下转型
向下转型: 就是把父类的引用强制转换成子类的引用格式: 子类 对象名 = (子类)父类的引用 ;
向上转型: 就是父类的引用指向子类对象
* 抽象类
** 特点:
* 抽象类格式: public abstract class 类名 {}
* 抽象方法: public abstract 返回值类型 方法名();
* 如果一个类中存在抽象方法,那么该类就需要定义为抽象类
* 抽象类中可以有非抽象方法
* 抽象类不能进行直接实例化
* 抽象类中可以存在构造方法,这个构造方法的作用是用于子类在访问父类数据的时候,对父类的数据进行初始化
* 抽象类的子类
** 可以是抽象类 (意义不大)
** 可以是非抽象类,这个类需要重写父类中所有的抽象方法
** 成员特点
* 成员变量 可以是变量,也可以是常量
* 构造方法 存在构造方法作用是用于子类在访问父类数据的时候,对父类的数据进行初始化
* 成员方法 可以是抽象方法,也可以是非抽象方法
* 接口
** 特点:
* 格式: public interface 接口名 {}
* 接口中没有构造方法
* 接口不能进行直接实例化
* 接口中只能存在抽象方法
* 接口的子类
** 可以是抽象类 (意义不大)
** 可以是非抽象类 ,这个类需要重写接口中所有的抽象方法
** 成员特点:
* 成员变量 只能是常量,存在默认的修饰符 public static final
* 构造方法 没有构造方法
* 成员方法 只能是抽象方法, 存在默认的修饰符 public abstract
* 抽象类和接口的区别
** 成员区别: 另请参见729行和748行
** 关系的区别
* 类与类 继承的关系,只能是单继承,可以是多层继承
* 类与接口 实现的关系 ,可以是单实现,也可以是多实现,并且一个类在继承一个类的同时去实现多个接口
* 接口和接口 继承的关系 ,可以是单继承,也可以是多继承
** 设计理念的区别
* 抽象类可以被继承 体现的是一种"is a"的关系 抽象类中定义的一般都是该继承体系中共性的内容
* 接口可以被实现 体现的是一种"like a"的关系 接口中定义的一般都是该继承体系中扩展性的内容. 可以用来解耦 , 定义规范
day10-------------------------------------------------------------------------------------------------------------------------------------
* 参数传递问题 : 要的都是对象
* 四种权限修饰符
private 默认 protected public (权限依次从小到大)
本类 同一个包不同包的子类不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y YY
* 内部类:
** 概述: 就是把一个类定义在另一个类中,那么这个类就被称之为内部类
** 特点:
* 内部类可以直接访问外部类的成员,包含私有的
* 外部类要访问内部类的成员,需要创建内部类的对象
** 分类:
* 成员内部类: 就是把一个类定义在另一个类的成员位置
其他类访问内部类创建对象的格式:外部类.内部类 对象名 = 外部类对象.内部类对象 ; Outer.Inter ou = new Outer().new Inter() ;
常见的修饰符: static , private
private: 保证了数据的安全性
static : 为了方便外部访问
被static修饰了以后其他类访问内部类创建对象的格式:
外部类.内部类 对象名 = new 外部类名.内部类名() ;
Outer.Inner oi = new Outer.Inner() ;
* 局部内部类 就是把该类定义在局部位置 (方法定义中的位置)
* 局部内部类在访问局部变量的时候,局部变量必须被 final 修饰
* 匿名内部类
* 概述: 其实是局部内部类的一种简化的写法
* 前提: 需要有一个类或者接口
* 格式:
new 类名或者接口名(){
重写方法 ;
} ;
* 本质: 是一个继承了某一个类或者实现了某一个接口的子类对象
* 内部接口: 把接口定义在类中
public class Computer {
public interface Mermory {
}
}
==========================================================================================================================================
3. API
day11-------------------------------------------------------------------------------------------------------------------------------------
* eclipse
* Object 类
** 概述: 该类是所有的类的顶层父类,所有的类都是直接的或者间接的继承自该类
** 构造方法: public Object() ;
** 成员方法:
* public int hashCode():获取对象的哈希码值. 不同的对象哈希码值不同,相同的对象哈希码值相同
* public Class getClass():获取一个对象对应的类的字节码文件对象
** Class 类中的方法 : public String getName():获取字节码文件对象对应的全类名
* public String toString():返回的是一个对象的字符串表现形式,默认是返回的是 地址值
* public boolean equals(Object obj)比较两个对象是否相等,默认比较的是地址值
** 面试题: == 和 equals 的区别 ?
day12-------------------------------------------------------------------------------------------------------------------------------------
* Scanner
** 作用: 接收键盘录入数据的
** 构造方法: public Scanner(InputStream in) ;
** 成员方法:
* public int nextInt():获取一个int类型的值
* public String nextLine():获取一个String类型的值
** 小问题: 先获取int类型的值,在获取字符串类型的值.会出现问题.
* 解决方案:
** 重新创建一个 Scanner 对象
** 全部使用String进行接收 , 然后在使用基本数据类型包装类将其转换成指定的类型
* String
** 是一个字符串,就是把多个字符链接起来的一串数据.类似于字符数组
** 特点:
* 字符串字面值就是字符串的一个对象; 比如: "abc"
* 字符串一旦被创建就不能被改变. 不能被改变指的是值不能被改变
** 构造方法
* public String(byte[] bytes):把一个字节数组转换成一个字符串
* public String(byte[] bytes , int off , int len)把一个字节数组中的一部分转换成一个字符串
* public String(char[] chs):把一个字符数组转换成一个字符串
* public String(char[] chs , int off , int len)把一个字符数组中的一部分转换成一个字符串
** 成员方法
* 获取功能
public int length():获取字符串的长度。
public char charAt(int index):获取指定索引位置的字符
public int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
public int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
public int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
public int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
public String substring(int start):从指定位置开始截取字符串,默认到末尾。
public String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
* 判断功能
public boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
public boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
public boolean contains(String str):判断字符串中是否包含传递进来的字符串
public boolean startsWith(String str):判断字符串是否以传递进来的字符串开头
public boolean endsWith(String str):判断字符串是否以传递进来的字符串结尾
public boolean isEmpty():判断字符串的内容是否为空。
* 转换功能
public byte[] getBytes():把字符串转换为字节数组。
public char[] toCharArray():把字符串转换为字符数组。
public static String valueOf(char[] chs):把字符数组转成字符串。
public static String valueOf(int i):把int类型的数据转成字符串。
public String toLowerCase():把字符串转成小写。
public String toUpperCase():把字符串转成大写。
public String concat(String str):把字符串拼接。
* 其他功能
public String replace(char old,char new)将指定字符进行互换
public String replace(String old,String new)将指定字符串进行互换
public String trim()去除两端空格
public int compareTo(String str)
public int compareToIgnoreCase(String str)
day13-------------------------------------------------------------------------------------------------------------------------------------
* StringBuffer
** StringBuffer 是线程安全的一个可变字符序列
** 构造方法:
public StringBuffer():无参构造方法
public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
** 成员方法
* 添加功能
public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
* 删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
* 替换
public StringBuffer replace(int start,int end,String str):从start开始到end用str替换
* 反转功能
public StringBuffer reverse():字符串反转
* 截取功能
public String substring(int start):从指定位置截取到末尾
public String substring(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
** 字符串和字符串缓冲区的转换问题
* 字符串 ---- 字符串缓冲区a: 构造方法完成 b: append方法
* 字符串缓冲区 ---- 字符串a: 调用toString方法
** String 作为参数传递问题:String 虽然是一个引用数据类型,但是它在传递的时候是按照基本数据类型进行传递的
* StringBuffer 和 StringBuilder 的区别:
** StringBuffer是线程安全的可变字符序列 , 效率低
** StringBuilder是线程不安全的可变字符序列 , 效率高. 如果单线程建议使用 StringBuilder
* 数组的高级操作
** 冒泡排序
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length - 1 ; x++){
for(int y = 0 ; y < arr.length - 1 - x ; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
** 选择排序
public static void selectSort(int[] arr){
for(int x = 0 ; x < arr.length - 1 ; x++){
for(int y = x + 1 ; y < arr.length ; y++){
if(arr[x] > arr[y]){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
}
}
** 二分查找
public static int binarySearch(int[] arr , int value){
int minIndex = 0 ;
int maxIndex = arr.length - 1 ;
while(minIndex <= maxIndex){
int midIndex = (minIndex + maxIndex) >>> 1 ;
if(arr[midIndex] == value){
return midIndex ;
}else if(arr[midIndex] > value){
maxIndex = midIndex - 1 ;
}else if(arr[midIndex] < value){
minIndex = midIndex + 1 ;
}
}
return -1 ;
}
* Arrays
** 数组工具类,属于java.util ;
** 成员方法:
public static void sort(int[] a):排序
public static int binarySearch(int[] a, int key):二分查找
public static String toString(int[] a):把一个数组转换成一个字符串
* 基本数据类型包装类
** java针对每一种基本数据类型都提供了对应的包装类类型
基本数据类型 包装类类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
** 构造方法:
public Integer(int i):把一个int类型的值转换成包装类类型
public Integer(String num):把一个数字字符串转换成一个包装类类型
** 成员方法:
public static int parseInt(String s):把一个数字字符串转换成int类型的值
public int intValue():获取Integer这个对象中封装的数字
public static String toString(int i):把一个int类型的数据转换成字符串
** 字符串 ---- int 类型的转换
Integer 类中的方法: public static int parseInt(String s):把一个数字字符串转换成int类型的值
** int 类型 ---- 字符串
String 类中的方法: public static String valueOf(int i)
Integer 类中的方法: public static String toString(int i):把一个int类型的数据转换成字符串
** jdk1.5的新特性自动拆装箱
* 自动拆箱: 就是把包装类类型转换成基本数据类型
* 自动装箱: 就是把基本数据类型转换成包装类类型
Integer i = 23 ;// 自动装箱
i += 45 ; // 先进行自动拆箱,然后在进行自动装箱
** 字节常量池: 在方法区中存在一个字节常量池,范围是 -128 ~ 127
** 常见的面试题:
Integer i1 = new Integer(127) ;
Integer i2 = new Integer(127) ;
System.out.println(i1 == i2) ;// false
Integer i3 = 127 ;
Integer i4 = 127 ;
System.out.println(i3 == i4) ;// true
Integer i5 = 128 ;
Integer i6 = 128 ;
System.out.println(i5 == i6) ;// false
day14-------------------------------------------------------------------------------------------------------------------------------------
* 正则表达式
** 概述: 就是正确规则的表达式
** 规则:
* 字符
x 就是表示是x字符
\\ 反斜线字符
\r 回车
\n 换行
* 字符类
[abc] 表示的是a或者b或者c
[^abc] 表示除了abc以外,其他的都可以
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括
* 预定义字符
. 表示任意的意思. 如果想表示.本身,就需要对.进行转义,使用 \\.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
* 边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界不是英文字母的地方hello world?haha;xixi
* 计量词
? 表示0次或者1次
* 表示0次或者多次
+ 表示1次或者多次
{n} 恰好n次
{n,} 至少n次
{n,m} 大于等于n次小于等于m次
* 字符串中和正则表达式相关的方法:
public boolean matches(String regex):校验一个字符串是否匹配regex这个正则表达式
public String[] split(String regex):就是把一个字符串使用regex这个正则表达式进行切割
public String replaceAll(String regex,String replacement)把一个字符串中符合regex这正则表达式的字符串使用replacement这个字符串进行替换
* 和获取功能相关的两个类 Pattern(模式器) 和 Matcher(匹配器)
** 典型的应用:
// 把一个正则表达式封装成一个模式器对象
Pattern p = Pattern.compile("a*b");
// 通过模式器对象获取匹配器对象
Matcher m = p.matcher("aaaaab");
// 校验
boolean b = m.matches();
** 代码:
// 定义字符串
String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?"
// 定义正则表达式
String regex = "\\b[a-zA-Z]{3}\\b";
// 把一个正则表达式封装成一个模式器对象
Pattern p = Pattern.compile(regex);
// 通过模式器对象获取匹配器对象
Matcher m = p.matcher(s);
// 循环
while(m.find()){
System.out.println(m.group()) ;
}
* System
** 成员变量
public static final InputStream in ;标准输入流,对应的设备是键盘
public static final PrintStreamout ;标准输出流,对应的设备是显示器
** 成员方法
public void exit(int status):退出jvm.0表示正常退出
public void gc():运行垃圾回收器 , 本质上调用的是Object类中的finalize()
public static native long currentTimeMillis();获取当前系统时间对应的毫秒值
* Random
** 作用: 用来生成随机数
** 构造方法:
public Random():使用默认的种子创建一个Random对象
public Random(long seed):使用指定的种子创建一个Random对象
区别: 使用指定的种子创建对象以后,然后每一次获取的都是相同的随机数
** 成员方法:
public int nextInt():获取一个int范围内的随机数
public int nextInt(int n):获取一个大于等于0小于n的随机数
* Math
** 作用: 定义了一些和数学运算相关的方法
** 成员方法:
public static int abs(int a)取绝对值
public static double ceil(double a)向上取整(掌握)
public static double floor(double a)向下取整(掌握)
public static int max(int a,int b) 获取最大值
public static int min(int a, int b)获取最小值
public static double pow(double a,double b)获取a的b次幂
public static double random()获取随机数返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
public static int round(float a) 四舍五入 (掌握)
public static double sqrt(double a)获取正平方根
* BigDecimal
** 构造方法:
public BigDecimal(String val):把一个数字字符串转换成一个BigDecimal对象
** 成员方法:
public BigDecimal add(BigDecimal augend)加
public BigDecimal subtract(BigDecimal subtrahend)减
public BigDecimal multiply(BigDecimal multiplicand)乘
public BigDecimal divide(BigDecimal divisor)除
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)除 scale: 表示小数点后的位数. roundingMode: 取舍方式(BigDecimal.ROUND_HALF_UP;四舍五入)
* Date
** 构造方法:
public Date():创建一个日期对象
public Date(long time)把一个毫秒值转化成一个日期对象
** 成员方法:
public long getTime():获取当前日期对象对应的毫秒值
public void setTime(long time)给一个日期对应设置上具体的毫秒值
* SimpleDateFormat
** 作用: 把一个日期字符串解析成一个日期对象,获取把一个日期对象格式化成一个日期字符串
** 构造方法:
public SimpleDateFormat():使用默认的格式创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern): 使用指定的格式创建一个SimpleDateFormat对象
规则
y 年
M 月
d 天
H 时
m 分
s 秒
举例: yyyy-MM-dd HH:mm:ss
** 成员方法
public Date parse(String dateStr):把一个日期字符串解析成一个日期对象
public String format(Date date) :把一个日期对象格式化成一个日期字符串
* Calendar (日历类)
** 获取该类的对象: public static Calendar getInstance()
** 成员方法:
public int get(int field)获得给定日历字段对应的值
public void add(int field,int amount)根据日历的规则，为给定的日历字段添加或减去指定的时间量
public final void set(int year,int month,int date)设置日历时间
月份是从 0 开始的 一直到 11
==========================================================================================================================================
4. 集合
day15-------------------------------------------------------------------------------------------------------------------------------------
* 对象数组
** 概述: 就是用来存储对象的数组
** 举例: Student[] students = new Student[10] ;
* 集合的由来
** 集合和数组的区别:
* 长度区别
数组的长度是不可变的,集合的长度是可变的
* 存储数据类型的区别
数组可以存储基本数据类型的元素,也可以存储引用数据类型的元素
集合只能存储引用数据类型的元素
* 内容的区别
数组只能存储同一种数据类型的元素
集合可以存储多种数据类型的元素
* 集合的继承体系图
|-- Collection(接口)
|--- List(接口)
|----- ArrayList (类)
|----- Vector (类)
|----- LinkedList(类)
|--- Set (接口)
|----- HashSet (类)
|----- TreeSet (类)
* 成员方法
boolean add(E e)添加元素
boolean remove(Object o)删除元素
void clear() 删除所有的元素
boolean contains(Object o)判断是否包含o这个元素
boolean isEmpty()判断是否为空
int size() 获取集合的长度
boolean addAll(Collection c)添加一个集合的元素
boolean removeAll(Collection c)删除一个集合的元素,删除一个以上算是删除
boolean containsAll(Collection c)判断是否包含一个集合的元素,包含所有的才算是包含
boolean retainAll(Collection c)获取交集. A集合对B集合取交集,获取的交集元素存储到A中,返回的boolean类型的值表示的A集合是否发生改变
Object[] toArray() :把一个集合转换成数组
Iterator iterator():获取迭代器Iterator, 是集合的一种遍历方式
* 遍历
使用迭代器进行遍历集合
代码:
// 创建集合对象
Collection col = new ArrayList() ;
// 添加元素
col.add("刘亦菲");
col.add("范冰冰");
col.add("李冰冰");
// 获取迭代器
Iterator it = col.iterator() ;
// 循环
while(it.hasNext()){
// 获取
Object obj = it.next() ;// next方法的特点: 获取元素,并把指针向后移动一位
// 输出
System.out.println(obj) ;
}
* List 集合
** 特点: 元素有序,可以重复 , 每一个元素都具有一个整数索引
** 特有的功能:
void add(int index,E element):在index索引处添加element这个元素
E remove(int index):删除index索引处对应的元素
E get(int index):获取index索引处对应的元素
E set(int index,E element):给index索引设置element这个元素
** List 集合特有的遍历方式
* 使用for循环配合get和size方法
* 代码
for(int x = 0 ; x < list.size() ; x++){
System.out.println(list.get(x)) ;
}
* 数据结构
** 概述: 就是存储数据的方式
** 分类: 栈 , 队列 , 数组 , 链表 , 树 , 哈希表
** 每一种数据结构的特点:
栈 : 先进后出
队列: 先进先出
数组: 查询快 , 增删慢
链表: 查询慢 , 增删快
* List 集合的三个子类的特点
** ArrayList 底层的数据结构是数组,查询快,增删慢.线程不安全,效率高
** Vector 底层的数据结构是数组,查询快,增删慢.线程安全,效率低
** LinkedList 底层的数据结构是链表,查询慢,增删快,线程不安全,效率高
day16-------------------------------------------------------------------------------------------------------------------------------------
* List 集合的三个子类
** ArrayList
** Vector
* 成员方法
public void addElement(E obj)添加元素
public E elementAt(int index)获取index索引处对应的元素
public Enumeration elements()遍历Vector集合,类似于 Iterator
** LinkedList
* 成员方法
public void addFirst(E e)在第一个位置添加元素
public void addLast(E e)在最后一个位置添加元素
public E getFirst()获取第一个位置对应的元素
public E getLast()获取最后一个位置对应的元素
public E removeFirst()删除第一个位置对应的元素
public E removeLast()删除最后一个位置对应的元素
** 使用 LinkedList 模拟栈的数据结构
代码:
public class MyLikedList {
private LinkedList list ;
public MyLikedList(){
list = new LinkedList() ;
}
public void add(Object obj){
list.addFirst(obj) ;
}
public Object get(){
return list.removeFirst() ;
}
public boolean isEmpty(){
return list.isEmpty() ;
}
}
* 泛型
** 概述: 是一种把类型的明确工作推迟到了创建对象或者调用方法的时候的一种特殊的类型
** 格式: <数据类型 , 数据类型 , ...> 这个数据类型只能是引用数据类型
** 好处:
* 把运行期的错误提前到了编译期
* 省去了向下转型
* 去除了黄色警告线
** 泛型的应用
* 泛型类 就是把泛型定义在一个类上
举例: public class Student<T> {}
* 泛型方法 就是把泛型定义在方法上
举例: public <T> void show(T t){}
* 泛型接口 就是把泛型定义在接口上
举例: public interface Inter<T> {}
** 泛型通配符:
? 表示的是任意的
? extends E 向下限定,表示的是E或者E的子类
? super E 向上限定,表示的是E或者E的父类
* 增强for循环 (掌握)
** 作用: 就是为了简化集合和数组的遍历
** 格式:
for(数据类型 变量名 : 数组或者Collection集合的名称){
直接使用变量名,这里的变量名其实就是数组或者Collection集合中的元素.
}
举例: int[] arr = {23, 45, 67} ;
for(int a : arr){
System.out.println(a);
}
* 静态导入: (了解)
** 格式: import static 包名.类名.方法名 ;
* 可变参数: (了解)
** 格式: public 返回值 方法名(数据类型... 变量名) {};
** 本质: 是一个数组
** 注意事项: 这个可变参数只能定义位该方法的最后一个参数
day17-------------------------------------------------------------------------------------------------------------------------------------
* 登录注册案例
* Set 集合
** 特点: 元素无序 , 可以保证元素的唯一性
** HashSet
* 数据结构: 是哈希表, 要使用该集合保证元素的唯一性,就需要重写hashCode方法和equals方法
* 遍历方式:
** 第一种使用迭代器
** 第二种使用增强for
** TreeSet
* 可以对元素进行排序.
排序方式有两种:
** 第一种自然排序
** 比较器排序
到底使用的是哪一种排序取决于构造方法:
public TreeSet():使用自然排序,对元素有要求,要求这个元素必须实现Comparable接口.
不明白为什么要实现这个接口,请看TreeMap中第557行代码
public TreeSet(Comparator comparator): 使用比较器排序
** LinkedHashSet : 底层的数据结构是链表和哈希表 , 元素有序(靠链表保证) , 并且唯一(靠哈希表保证)
day18-------------------------------------------------------------------------------------------------------------------------------------
* Map 集合
** Map 集合 和 Collection 集合的区别
* Map 集合是双列集合,而 Collection 集合是单列集合 ; Map 集合就像是夫妻对 , Collection 集合就像是 孤狼
* Map 集合的键唯一 , 而Collection集合中的Set集合可以保证元素的唯一性
* Map 集合的数据结构之和键有关系,而Collection集合的数据结构和元素是有关系的
* 成员方法
V put(K key,V value)添加元素
V remove(Object key)删除元素
void clear() 删除所有的元素
boolean containsKey(Object key)判断是否包含这个键
boolean containsValue(Object value)判断是否包含这个值
boolean isEmpty()判断是否为空
int size() 获取集合的长度
V get(Object key)根据键获取值
Set<K> keySet()获取所有的键对应的set集合
Collection<V> values()获取所有的值对应的Collection集合
Set<Map.Entry<K,V>> entrySet()获取所有的键值对对象对应的Set集合
* 遍历
Map<String , String> map = new HashMap<String , String>() ;
map.put("邓超" , "孙俪") ;
map.put("文章" , "马伊琍") ;
map.put("陈赫" , "张子萱") ;
** 键找值
* 思路:
** 获取所有的键对应的set集合
** 遍历Set集合获取每一个键,然后在根据键获取指定的值
* 代码:
Set<String> keys = map.keySet() ;
for(String key : keys) {
// 根据键找值
String value = map.get(key) ;
// 输出
System.out.println(key + "---" + value) ;
}
** 通过键值对对象获取键和值
* 思路
** 获取所有的键值对对象对应的Set集合
** 遍历Set集合获取每一个键值对对象,然后在获取键和值
* 代码
Set<Entry<String , String>> en = map.entrySet() ;
for(Entry<String , String> e : en){
String key = e.getKey() ;
String value = e.getValue() ;
System.out.println(key + "---" + value) ;
}
* HashMap 和 TreeMap
* LinkedHashMap : 底层的数据结构是链表和哈希表 , 元素有序(靠链表保证) , 并且唯一(靠哈希表保证)
* Hashtable 和 HashMap 的区别 :
** HashMap 是线程不安全,允许 null 值和 null 键
** Hashtable 是线程安全的,不允许有 null 值 和 null键
* Collections
** 概述: 集合工具类
** 成员方法:
public static <T> void sort(List<T> list):排序,默认按照自然顺序
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):获取最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换
==========================================================================================================================================
5. IO流
day19-------------------------------------------------------------------------------------------------------------------------------------
* 异常
** 概述: 就是在程序的运行过程中可能出现的问题
** 分类:
Throwable 问题
|- Error 严重性问题
|- Exception 非严重性问题
|-- 编译期异常 就是非 RuntimeException
|-- 运行期异常 就是 RuntimeException 或者 RuntimeException 的子类
** JVM对异常的默认处理方式:就是把异常的信息打印到控制台,并结束程序
** 对异常的处理方式:
* try .... catch 语句....
** 格式:
try {
可能出现问题的代码 ;
}catch (异常名 变量名){
对异常的具体处理方式;
}finally {
释放资源的代码 ;
}
简化版:
try {
可能出现问题的代码 ;
}catch (异常名 变量名){
对异常的具体处理方式;
}
注意事项:
* try 中的代码越少越好
* catch 中要做处理
变形版:
try {
可能出现问题的代码 ;
}catch (异常名1 变量名1){
对异常的具体处理方式;
}catch (异常名2 变量名2){
对异常的具体处理方式;
}
...
注意事项:
* 如果多个catch中存在子父类的继承关系,那么父类必须是最后一个catch
* 如果多个catch中不存在子父类的继承关系,那么顺序无所谓
* 如果我们可以明确异常信息,那么尽量不要使用大的异常
* 就是编译期异常和运行期异常的区别
** 编译期异常,我们必须对其进行处理
** 运行期异常可以处理,也可以不处理
* Throwable 中常见的方法:public void printStackTrace() : 打印出异常的堆栈信息
* throws 和 throw 的区别:
throws 用在方法定义上,用来给方法添加一个异常的声明(异常可以是多个);
throw 用在方法定义中,后面跟一个异常对象(可以是编译期异常,可以是运行期异常). 用来抛出一个异常
* finally : 特点:就是该代码始终被执行(JVM不能退出)
存放的代码作用: 用来释放资源
* 自定义异常: 定义一个类,然后让该类去继承 RuntimeException 或者 Exception
* File 类
** 概述: 是文件或者文件夹的抽象表示形式
** 构造方法:
public File(String filePath):使用文件路径创建一个File对象
public File(String parentPath , String filePath) ;使用父路径和子文件或者文件夹创建一个File对象
public File(File parentFile , String filePath) ;使用父文件和子文件或者文件夹创建一个File对象
** 成员方法:
public boolean createNewFile():创建文件 如果存在这样的文件，就不创建了
public boolean mkdir():创建文件夹 如果存在这样的文件夹，就不创建了
public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来
public boolean delete():删除文件或者文件夹
public boolean renameTo(File dest): 把文件重命名为指定的文件路径
public boolean isDirectory():判断是否是目录
public boolean isFile():判断是否是文件
public boolean exists():判断是否存在
public boolean canRead():判断是否可读
public boolean canWrite():判断是否可写
public boolean isHidden():判断是否隐藏
public String getAbsolutePath()：获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public long length():获取长度。字节数
public long lastModified():获取最后一次的修改时间，毫秒值
public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)
day20-------------------------------------------------------------------------------------------------------------------------------------
* 递归
** 概述: 方法定义中调用方法本身的现象
** 注意事项:
* 递归一定要有出口
* 递归的次数不宜过多
* 构造方法不能使用递归
** 递归的练习题:
* 5!
* 斐波那契数列
* 递归删除
* 递归打印
* IO流的概述和分类
** IO: Input Output
** 作用: 进行数据传输
** 什么是输入和输出:相对于内存而言
** 分类:
* 按照流向进行划分
** 输入流
** 输出流
* 按照操作数据类型进行划分
** 字节流
* 字节输入流 InputStream 读
* 字节输出流 OutputStream 写
** 字符流
* 字符输入流 Reader 读
* 字符输出流 Writer 写
* 字节流
** FileInputStream
* 构造方法
public FileInputStream(String filePath)
public FileInputStream(File file)
* 成员方法
public int read():一次读取一个字节
public int read(byte[] bytes)一次读取一个字节数组
** FileOutputStream
* 构造方法
public FileOutputStream(String filePath)
public FileOutputStream(File file)
* 成员方法
public void write(int by)一次写一个字节
public void write(byte[] bytes)一次写一个字节数组
public void write(byte[] bytes , int off , int len)一次写一个字节数组中的一部分
** BufferedInputStream
* 构造方法
public BufferedInputStream(InputStream in)
* 成员方法
public int read():一次读取一个字节
public int read(byte[] bytes)一次读取一个字节数组
** BufferedOutputStream
* 构造方法:
public BufferedOutputStream(OutputStream out)
* 成员方法
public void write(int by)一次写一个字节
public void write(byte[] bytes)一次写一个字节数组
public void write(byte[] bytes , int off , int len)一次写一个字节数组中的一部分
day21-------------------------------------------------------------------------------------------------------------------------------------
* 字符流的由来: 为了方便的操作中文,java就给我们提供了字符流
字符流 = 字节流 + 编码表
编码表:
ASCII '0' --- 48 , 'a' --- 97 , 'A' --- 65
GB2312
GBK (常用)
UNICODE
UTF-8 (常用)
* 字符串中的编解码问题
** 编码: 就是把字符串转换成字节数组
方法:
public byte[] getBytes()使用平台默认的字符集把一个字符串转换成字节数组
public byte[] gteBytes(String charsetName)使用平台指定的字符集把一个字符串转换成字节数组
** 解码: 就是把字节数组转换成字符串
方法:
public String(byte[] bytes)使用平台默认的字符集把一个字节数组转换成一个字符串
public String(byte[] bytes , String charSetName) 使用指定的字符集把一个字节数组转换成一个字符串
** 编解码问题: 使用什么进行编码,就是用什么进行解码
* 字符流: *****************************如果我们需要使用编码表,那么就只能使用转换流*****************************
** 转换流
* 转换输入流 InputStreamReader
** 构造方法: public InputStreamReader(InputStream in) ;
public InputStreamReader(InputStream in , String charsetName) ;
** 成员方法:
public int read():一次读取一个字符
public int read(char[] chs)一次读取一个字符数组
* 转换输出流 OutputStreamWriter
** 构造方法: public OutputStreamWriter(OutputStream out) ;
public OutputStreamWriter(OutputStream out , String charsetName) ;
** 成员方法:
public void write(int ch)一次写一个字符
public void write(char[] chs)一次写一个字符数组
public void write(char[] chs , int off , int len)一次写一个字符数组中的一部分
public void write(String str)一次写一个字符串
public void write(String str , int off , int len)一次写一个字符串中的一部分
** 便捷类
* 由来: 由于转换流的名称太长,并且在一般情况下也不需要制定编码表
* 便捷类和转换流的对应的关系
转换流 便捷类
InputStreamReaderFileReader
OutputStreamWriterFileWriter
* 没有特有的功能
** 高效的字符流
* 高效的字符输入流 BufferedReader
** 构造方法: public BufferedReader(Reader r)
** 特有的方法: public String readLine() 一次读取一行
* 高效的字符输出流 BufferedWriter
** 构造方法 public BufferedWriter(Writer w)
** 特有的方法: public void newLine() 写一个换行符
day22-------------------------------------------------------------------------------------------------------------------------------------
* 数据输入输出流 (了解)
** 数据输入流 DataInputStream
** 数据输出流 DataOutputStream
** 可以操作任意的数据类型
* 内存操作流
a:操作字节数组 (理解)
ByteArrayOutputStream
ByteArrayInputStream
b:操作字符数组
CharArrayWrite
CharArrayReader
c:操作字符串
StringWriter
StringReader
代码:
public static void main(String[] args){
// 创建对象
ByteArrayOutputStream baos = new ByteArrayOutputStream();
// 写数据
baos.write("张三".getBytes()) ;// 这个数据写入到了内存中
// 创建对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()) ;
// 读取数据
byte[] bytes = new byte[1024] ;
int len = 0 ;
while((len = bais.read(bytes)) != -1){
System.out.print(new String(bytes , 0 , len)) ;
}
}
* 打印流 (掌握)
** 字节打印流 PrintStream
** 字符打印流 PrintWriter
** 特点:
* 只能操作目的地不能操作数据源(只能写数据,不能读取数据)
* 可以操作任意数据类型的数据
* 如果我们启动了自动刷新,那么在调用printf , println , format方法的时候,会进行自动刷新
* 可以直接操作文件的流对象
** 构造方法:
* public PrintWriter(String filePath)
* public PrintWriter(File file)
* public PrintWriter(OutputStream out , boolean autoflush)启动自动刷新
* public PrintWriter(Writer out , boolean autoflush)启动自动刷新
** 成员方法:
* public void print(...)不带换行
* public void println(...)带换行
* 序列化流 (理解)
** 序列化: 就是把对象通过流的方式存储到文本文件中
** 反序列化: 就是把文本文件中的数据通过流的方式还原成一个对象
** 注意事项: 一个对象可以被序列化的前提,是这个对象对应的类必须实现Serializable
** 序列化流: ObjectOutputStream
* 构造方法: public ObjectOutputStream(OutputStream out)
* 成员方法: public void writeObject(Object obj)
** 反序列化: ObjectInputStream
* 构造方法: public ObjectInputStream(InputStream in)
* 成员方法: public Object readObject() ;
** transient: 如果我们不想让某一个字段被序列化,那么就使用该关键字修饰
* 随机访问流
** 特点:
* 可以操作任意的数据类型
* 父类为 Object
* 既可以读取数据也可以写数据
** 构造方法: public RandomAccessFile(File file, String mode): mode: 表示读写模式
** 成员方法:
* public native long getFilePointer() throws IOException;获取文件指针
* public native void seek(long pos) throws IOException;设置文件指针
* Properties
** 属于双列集合 , 父类是Hashtable
** 特点:
* 键和值都是字符串
* 可以和IO流进行配合使用
** 构造方法: public Properties()
** 成员方法:
public Object setProperty(String key,String value)添加元素
public String getProperty(String key)根据键获取值
public Set<String> stringPropertyNames()获取所有的键对应的Set集合
public void load(Reader reader)把一个文本文件中的数据加载到集合中
public void store(Writer writer,String comments)把集合中的数据存储到文本文件中
==========================================================================================================================================
6. 多线程,GUI,网络编程,反射
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
