二 java基础中
对象
对象是一类事物的具体体现
类里面有四个成员
1 属性：静态描述类的特征
2 方法：动态描述类的行为
3 构造方法：为了创造对象
4 代码块：创建对象前初始化参数
1 属性
类的第一个成员
属性的格式：静态描述类的特征
权限修饰符 [特征修饰符] 属性类型 属性名字 [=赋值]
2 方法
类的第二个成员
1 方法的格式：动态描述类的行为
类中的方法---->做一件事情
权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
方法体
}]
2 形参和实参
方法调用时会将实参的内容传递给形参
如果内容是基本类型 传递的 是值 形参改变 实参不变
如果内容是引用类型 传递的 是引用 形参改变 实参跟着改变
根本是判断堆中的值是否发生改变或者原变量对堆的引用是否发生改变
3方法的重载
方法重载
1.概念：一个类中的一组方法 相同的方法名字 不同的参数列表 这样的一组方法构成了方法重载
参数列表的不同体现在哪里?
参数的个数 参数的类型 参数的顺序 与返回值无关
2.作用：为了让使用者便于记忆与调用 只需要记录一个名字 执行不同的操作
3.自己也可以设计方法重载
调用方法的时候 首先通过方法名字定位方法
如果方法名字有一致 可以通过参数的数据类型定位方法
如果没有与传递参数类型一致的方法 可以找一个参数类型可以进行转化(自动)
4.JDK1.5版本之后 出现了一个新的写法
int... x 动态参数列表 类型固定 个数可以动态 0--n都可以
x本质上就是一个数组 有length属性 有[index]
动态参数列表的方法 不能 与相同意义的数组类型的方法构成方法重载 本质是一样的
动态参数列表的方法 可以不传参数 相当于0个 而数组的方法 必须传递参数
动态参数列表在方法的参数中只能存在一份儿 且必须放置在方法参数的末尾
4 构造方法
类中的第三个成员
构造方法---做事情
1.作用: 只有一个 构建(构造)当前类的对象
2.写法: 权限修饰符 与类名一致的方法名 (参数列表) [抛出异常]{
一件事情 创建一个对象(当前类Person)
返回对象;
}
3.用法: 通过new关键字调用
4.特点:
1.每一个类都有构造方法，若自己在类中没有定义，系统会默认提供一个无参数的构造方法
若在类中自己定义了构造方法，则默认无参数的构造方法即被覆盖
2.构造方法是否存在方法重载?----存在构造方法重载
5.每一个类都有构造方法
若不定义 系统会默认提供构造方法
为什么要定义构造方法? 什么时候需要设计构造方法?
在创建对象的同时 想要一并做一些事情 默认提供的构造方法是不会做的
这个时候我们可以自己定义构造方法(无参数的构造方法内做事 也可以定义带参数的)
5 this关键字
构造方法中 属性与变量重名 必须需要一个代替词 代替对象
this关键字的使用
1.是一个关键字(指代词) 代替的是某一个对象 (当前调用属性或方法时的那个对象)
2.this既然代替的是一个对象
this可以调用什么? 属性 方法 可以
this可以调用构造方法么? 可以 在一个构造方法内可以调用另一个构造方法
通过this(); 省略了构造方法的名字(必须与类名一致)
必须在另一个构造方法内调用 必须在程序的第一行
构造方法 一般方法 有顺序 认为构造方法早于一般方法
在一般方法内调用构造方法呢？ 不行
构造方法可以重载 构造方法 调用另一个构造方法呢?
3.this调用的过程可以放置在哪个位置写?
调用属性或方法 这一行代码 可以放置在类中的任何成员位置 上下顺序随意
6 代码块
类的第四个成员---程序块(代码块)
1.作用: 跟普通方法一样 做事情的
2.写法: 可以认为程序块是一个 没有修饰符 没有参数 没有返回值 没有名字的特殊方法
{
}
3.用法: 块也需要调用才能执行 我们自己调用不到(没有名字)
每一次我们调用构造方法之前 系统会帮我们自动的调用一次程序块 让他执行一遍
4.特点: 没有什么重载的概念(压根连名字都没有 连参数都没有)
但是可以在类中定义 多个程序块
5.块可以在里面写一些程序 我想要在创建对象之前执行
7 普通类的成员的执行顺序
1 代码块<--构造方法<--普通方法
8 nextLine、nextInt、next的区别
1 nextLine 会读取回车符之前的内容，连同回车符一块读取，然会将回车符丢掉
2 NextInt 会读取回车符之前的内容，回车符不读取，仍然保存在队列中。
next方法看到回车或空格都认为结束 nextLine只认为回车符结束
9 继承
继承 is-a
1.子类继承父类，通过一个关键字 extends
2.子类的对象可以调用父类中的(public protected)属性和方法 当做自己的来使用
3.子类可以添加自己独有的属性和方法的
4.子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写(覆盖)父类的方法 更多指的是内容
5.每一个类都有继承类，如果不写extends关键字，默认继承Object，如果写了extends则继承后面那个父类
可以理解为Object类非常重要 是任何一个引用类型的父类(直接或间接的继承Object) Object类没有父类
6.Java中继承是单个存在的(单继承) 每一个类只能有一个继承类 (在extends关键字后面只能写一个类)
可以通过传递的方式实现多继承的效果 后续还会有多实现
*7.继承在内存中的存储形式
*8.关于this和super的使用
this和super都是指代词 代替的是对象
this代替的是当前执行方法时的那个对象 不一定是当前类的
super代替的是当前执行方法时的对象的父类对象 空间内部的那个
都能调用一般属性 和 一般方法
可以放置在类成员的任意位置(属性 方法 构造 块)
注意调用一般方法的时候可以来回互相调用(写法 编译好用) 执行可能产生问题(StackOverflowError)
可以调用构造方法(放在构造方法的第一行)
this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行
构造方法之间不能来回互相调用(编译就不好用)
10 Object 超类的方法
小细节知识点补充
三目运算符
(a>b) ? x : y ;
Object类中的方法
hashCode() 将对象在内存中的地址经过计算得到一个int整数
public native int hashCode();
equals() 用来比较两个对象的内容 Object默认效果是==
==可以比较基本类型(比较值) 可以比较引用类型(比较地址)
equals方法时Object类中继承过来的方法 默认效果比较地址
如果想要改变其规则 可以进行方法重写
public boolean equals(Object obj){
return (this == obj);
}
toString() 打印输出时将对象变成String字符串
public String toString(){
return this.getClass().getName()+"@"+Integer.toHexString(this.hashCode());
}
getClass() 获取对象对应类的类映射(反射)
wait() 线程进入挂起等待状态 存在方法重载
notify() 线程唤醒
notifyAll() 唤醒所有
finalize() 权限修饰符是protected 在对象被GC回收的时候 默认调用执行的方法
final finally finalize区别
protected void finalize(){
}
clone() 权限修饰符是protected 为了克隆对象
11 重载和重写的区别
方法重写override 方法重载overload
1.类 产生两个继承关系的类 一个类中的一组方法
子类重写父类的方法
2.权限 子类可以大于等于父类 没有要求
3.特征 final static abstract 没有要求
父类方法是final 子类不能重写
父类方法是static 子类不存在
父类方法是abstract 子类必须重写
(子类是具体必须重写 否则子类是抽象类 可以不重写)
4.返回值 子类可以小于等于父类 没有要求
5.名字 子类与父类一致 一个类中的好多方法名必须一致
6.参数 子类与父类一致 每一个方法的参数必须不一致(个数 类型 顺序)
*7.异常 运行时 编译时 没有要求
如果父类方法抛出运行时异常
子类可以不予理会
如果父类方法抛出编译时异常
子类抛出异常的个数少于等于父类
子类抛出异常的类型小于等于父类
8.方法体 子类的方法内容与父类不一致 每一个重载的方法 执行过程不一致
12java调试原则
1 不用使用System.out.println()作为调试工具：破坏代码的整体结构
2 启用所有组件的详细日志记录级别
3 使用一个日志分析器来阅读日志
断点技巧：
1 条件断点
2 异常断点
3 设置行号观察点
4 查看变量
5 动态的改变某个变量的值
6 在main方法中停止
7 设置环境变量
8 在main方法中停止 Drop to frame
9 step 过滤
10 进入、跳过、返回
13 类与类之间的关系
1 is-a 继承和实现的关系
2 have-a 包含关系
从Java程序来描述这样的关系 通过一个类的对象当做另一个类的属性来存储
3 use-a 依赖的关系
Java程序体现的形式为:
一个类的方法中使用到了另一个类的对象
第一个可以在方法中传递参数
第二个可以在方法中自己创建
设计类的关系遵循的原则:高内聚低耦合
耦合度: 紧密 继承(实现) > 包含 > 依赖
14 修饰符和特征修饰符final
1 描述一个类
修饰符 特征 class 类名{
属性 权限 特征 类型 名字
方法 权限 特征 返回值 名字 参数 异常 执行体
构造方法 权限 名字 参数 异常 执行体
程序块 执行体
}
2 修饰符
权限修饰符
public 公共的
protected 受保护的
默认不写 默认的
private 私有的
特征修饰符
final 最终的 不可更改的
static 静态的
abstract 抽象的
native 本地的
*transient 瞬时的 短暂的------>序列化
*synchronized 同步的 线程问题
*volatile 不稳定的
3 权限修饰符
public 公共的 本类 同包 子类 当前项目中任意类的位置只要有对象都可以访问
protected 保护的 本类 同包 子类(通过子类对象在子类范围内部访问)
默认不写 默认的 本类 同包 不同包的子类不可以（子类和修饰的类在一个类中也可以访问）
private 私有的 本类
1.能修饰什么 2.范围如何
权限修饰符可以用来修饰 类本身 和类中的成员(除程序块)
权限修饰符用来修饰类的时候只有两个可以用(public 默认不写)
权限修饰符都可以用来修饰类中其他成员
4 特征修饰符
1.可以修饰什么
2.修饰以后有什么特点
final 最终的 不可更改的
修饰变量
如果在定义变量时没有赋初始值
给变量一次存值的机会(因为变量在栈内存空间内 没有默认值 如果不给机会 就没法用啦)
一旦变量被存储了一个值 若用final修饰后 则不让再次改变 ----> 相当于常量啦(值没法动)
注意变量类型是基本类型还是引用类型
如果修饰的变量是基本数据类型 则变量内的值不让更改---常量
如果修饰的变量是引用数据类型 则变量内的地址引用不让更改---对象唯一
修饰属性
全局变量 存储在堆内存的对象空间内一个空间
属性如果没有赋值 有默认值存在的
属性用final修饰后 必须给属性赋初值 否则编译报错
特点与修饰变量一致
注意变量类型是基本类型还是引用类型
如果修饰的变量是基本数据类型 则变量内的值不让更改---常量
如果修饰的变量是引用数据类型 则变量内的地址引用不让更改---对象唯一
修饰方法
方法是最终的方法 不可更改
子类继承父类的方法 将父类的方法重写(覆盖)
final修饰的方法 要求不可以被子类重写(覆盖)
修饰类本身
类是最终的 不可以更改
(太监类 无后) 此类不可以被其他子类继承
通常都是一些定义好的工具类
Math Scanner Integer String
15 java的特征
Java面向对象的四个特征
继承 封装 多态 (抽象)
封装 : 将一些数据或执行过程 进行一个包装
目的 : 保护这些数据 或 执行过程的安全
写登录流程--->main 一段代码
写登录方法--->login(name,pass)
方法本身就算是封装 封装了执行的过程 保护过程的安全 隐藏了执行细节 增强复用性
好多的方法和属性---->类 类也算是一个封装
ArrayBox
私有属性elementData size
--->add get remove size
ensureCapacityInternal grow copyOf rangeCheck
对属性本身的封装:
属性私有(封装在类中)
提供操作属性相应的方式(公有的方法)
以后强烈建议大家属性不要公有的---->非常不安全
既然以后大家都这样操作属性 属性及其操作属性的方法都有其命名的规约
age------> setAge getAge
myAge--> setMyAge getMyAge
16 特征修饰符 Static
1 static静态的
1.可以修饰 ： 修饰属性 修饰方法 *修饰块 修饰类(内部类)
2.特点：
1.静态元素在类加载时就初始化啦，创建的非常早，此时没有创建对象
2.静态元素存储在静态元素区中，每一个类有一个自己的静态区域，与别的类不冲突
3.静态元素只加载一次(只有一份)，全部类对象及类本身共享
4.由于静态元素区加载的时候，有可能没有创建对象，可以通过类名字直接访问
5.可以理解为静态元素不属于任何一个对象，属于类的
6.静态元素区Garbage Collection无法管理，可以粗暴的认为常驻内存
7.非静态成员(堆内存对象里)中可以访问静态成员(静态区)
8.静态成员中可以访问静态成员(都存在静态区)
9.静态成员中不可以访问非静态成员(个数 一个出发访问一堆相同名字的东西 说不清)(静态元素属于类 非静态成员属于对象自己)
10.静态元素中不可以出现this或super关键字(静态元素属于类)
设计模式23种 单例模式Singleton
17 设计模式
设计模式 23种 (内功心法)
1.设计模式不是知识点
2.设计模式是一种设计经验的总结
3.设计模式用来解决某些场景下的某一类问题的---->通用的解决方案
4.有了设计模式之后 可以让代码更容易被理解 确保了复用性 可靠性 可扩展性
设计模式分为三类
1.创建型模式(5种)----->用于解决对象创建的过程
单例模式 工厂方法模式 抽象工厂模式 建造者模式 原型模式
2.结构型模式(7种)----->把类或对象通过某种形式结合在一起 构成某种复杂或合理的结构
适配器模式 装饰者模式 代理模式 外观模式 桥接模式 组合模式 享元模式
3.行为型模式(11种)---->用来解决类或对象之间的交互 更合理的优化类或对象之间的关系
观察者模式 策略模式 模板模式 责任链模式 解析器模式 迭代子模式
命令模式 状态模式 备忘录模式 访问者模式 中介者模式
18 单例模式
单例模式(Singleton)
设计-->一个类只能创建一个对象 有效减少内存占用空间
设计一个系统--->百度 搜索引擎
public class Baidu{
public void 搜索(String keyword){
}
}
创建一个Baidu对象 new
调用搜索的方法 做事情 方法执行一遍
同一时间有很多很多很多很多人在使用这个系统
对象--->只创建一个 堆内存中就只开辟一个空间
调用一次方法--->临时执行一次 方法执行空间就回收啦
单例模式的实现
1.私有的构造方法
2.私有的静态的当前类对象作为属性
3.公有的静态的方法返回当前类对象
指的是对象的加载
饿汉式(立即加载) 对象启动时就加载啦
不会产生对象没有就拿来使用的问题 空指针异常
启动项目加载的对象过多 有些还没有使用 产生服务器承载压力的问题
懒汉式(延迟加载) 对象什么时候用到了 才会加载
可能会由于没有操作好 导致异常(很严谨)
启动项目时候只有需要的加载 不需要的还没有创建 不会浪费空间
*生命周期托管(单例对象别人帮我们处理) 对象加载过程交给别人
19 存在继承关系的类的加载顺序
存在继承关系的类 加载机制 及执行过程
加载类的过程---静态元素已经加载
new Person();
1.加载父类
2.父类会产生自己的静态空间 属性 方法 块
执行静态块
3.加载子类
4.子类会产生自己的静态空间 属性 方法 块
执行静态块
5.开辟对象空间
6.加载父类的非静态成员 属性 方法 块 构造方法
7. 执行块 执行父类构造方法
8.加载子类的非静态成员 属性 方法 块 构造方法
9. 执行块 执行子类构造方法
10.将对象空间的地址引用交给 变量来存储
自己实现顺序：
Animal类的静态代码块
Person类的静态代码块
Animal类的非静态代码块
Animal类的无参构造方法
Person类的非静态代码块
person类的无参构造方法
20 抽象类和接口
native本地的
Java源代码中看到native就已经再也看不见后续代码
后续会调用其他的编程语言C++ C执行内存的操作 帮我们操作内存
Object类中一个方法 hashCode
abstract抽象的---(很不具体 没有具体的执行 只是个概念)
1.可以修饰什么
修饰方法
用abstract修饰符修饰的方法 只有方法的结构 没有方法执行体叫做抽象方法
当然注意native修饰的方法虽然也没有方法体 但是不是抽象方法 只是执行的过程是其他语言写的 看不见
修饰类
用abstract修饰符修饰的类 叫做抽象类
2.修饰后有什么特点
抽象类中必须有抽象方法么? 不是必须含有抽象方法 可以含有非抽象方法
抽象方法必须放在抽象类中么? 目前来看必须放在抽象类中(或接口中) 普通类是不允许含有抽象方法
3.研究一下什么叫抽象类 抽象类有什么特点？(通常用来描述事物 还不是很具体)
1.类里面有什么 成员
属性 可以含有一般的属性 也可以含有 private static final等等
方法 可以含有一般的方法 也可以含有 private static final等等
注意:抽象类中是允许含有抽象方法(只有方法结构 没有方法执行体)
块 可以含有一般的程序块 也可以含有static程序块
构造方法 可以含有构造方法 包括重载
2.类如何使用 创建对象
抽象类含有构造方法 但是我们不能通过调用构造方法直接创建对象
抽象类只能通过子类单继承来做事
为什么不让我们调用构造方法创建对象？为什么还有呢？
3.类和类的关系
抽象类----直接单继承----抽象类 可以
抽象类----直接单继承----具体类 可以 (用法通常不会出现)
具体类----直接单继承----抽象类 不可以 (将父类的抽象方法具体化 或子类也变成抽象类)
4.小问题
抽象类中能不能没有抽象方法 全部都是具体成员 可以
抽象类中能不能没有具体成员 全部都是抽象方法 可以 ---> 抽象类抽象到极致 质的变化 ---> 接口
接口可以理解为是抽象类抽象到极致--->还是一个类的结构 不能用class修饰 改用interface修饰
5.什么是接口(通常是为了定义规则)
接口也是一个类的结构 只不过 用interface修饰 替换原有的class
1.有什么 成员
属性 不能含有一般属性 只能含有公有的静态的常量 public static final
方法 不能含有一般方法 只能含有公有的抽象的方法(1.8 defualt修饰具体方法)
块 不能含有一般程序块 也不能含有static块(块本身就是具体的 接口中不让有具体的)
构造方法 不能含有构造方法
2.如何使用 创建对象
不能创建对象
只能通过子类多实现(implements)来做事
public class A implements B,C,D{
}
3.与别的类结构关系
接口不能继承别的类 最抽象
抽象类----直接多实现----接口 可以
具体类----直接多实现----接口 不可以(必须将接口中的抽象方法具体化 自己变成抽象类)
*接口---多继承---接口 可以直接多实现
21 缺省适配器模式
有了box接口可以做统一的规则约束
每一个子类都实现同一个规则 用户使用起来很容易
如果按照上述的方式来实现 规则添加了新的方法 所有的子类都跟着添加新的方法
适配器模式是接口和具体类之间的中间体（抽象类），抽象类会实现接口的一些方法，使具体类不必实现接口的所有方法，抽象类中可以将实现的方法抛出异常，只要具体类想要调用就必须重写
设计模式
适配器模式 Adapter
定义一个规则--->和尚 吃斋 念经 打坐 撞钟 习武
缺省适配器模式
鲁智深 鲁达 形态丑陋 面貌凶顽
此人上应天星 心地刚直 虽时下凶顽 命中驳杂 久后却得清净 证果非凡 汝等皆不及他
public abstract class AbstractBox implements Box{
public boolean add(element);
public void add(int index,int element){//具体化
//抛出自定义异常
}
public void addAll(){//具体化
//抛出自定义异常
}
public int get(index);
public int remove(index);
public int size();
public void rangeCheck(int index){
if(index<0 || index>=size){
自定义的异常
}
}
}
22 多态
Java面向对象的四大特性
继承 封装 多态 (抽象)
多态
同一个对象 体现出来的多种不同形态(身份) 将一种行为表现出不同的效果
要想实现多态的效果 需要现有继承关系
体现:
1.父类类型的引用 指向 子类的对象
Person p = new Teacher();
2.该引用只能调用父类中定义的属性或方法
3.如果子类中将父类的方法重写，那么调取方法后执行的结果是子类重写之后的那个结果
如果父类与子类有同名的属性 执行父类的属性
如果父类与子类有同名的方法(重载) 执行子类重写之后的方法
4.若想要调用子类中独有的成员
(强制类型转化) 造型 铸型 (向上/向下转型)
5.造型时(强制向下转型时) 可能会出现一个运行时异常
ClassCastException 造型 铸型 异常
如果想要避免造型的异常 可以用instanceof关键字来进行判断
对象 instanceof 类
银行Bank
设计一个方法 等待用户来办理业务
profession(需要一个人)
叫一个号码-->排队
去窗口办理-->办理
办理完毕离开->离开
老人 年轻 土豪
//按照刚才的设计 可能有问题
//1.三个不同的人类方法名不一致(可以)
//2.银行办理业务的方法写了三个
//解决如上所述的问题 可以在三个人类之上创建一个父类
//1.解决三个人类中的相同代码 比如name属性 比如get方法之类的
//2.父类定义的三个方法可以是抽象 解决了子类命名不一致的问题 子类执行也不一致
//3.父类可以作为参数传入银行
调用一个方法 名字一样 传递参数却不同
1.利用方法重载---静态加载
2.利用多态效果---动态加载
23 策略模式
体现出另一种设计模式
策略模式Strategy-----行为型模式
用来解决 执行流程固定 执行的结果由于提供了不同的策略而不同
银行类
方法办理业务(人){ 人---抽象类 接口(不能产生对象) 传递一个子类对象
欢迎用户进来啦
叫号
办理
离开
欢迎您下次再来
}
人类
提供策略--抽象
具体类
实现策略
24 内部类
内部类
指的是在Java中可以将一个类定义在另一个类的内部
内部类可以定义在 类的内部 (与类成员层次一致)
内部类可以定义在 方法/块内部 (与类成员相差一个层次 方法的局部变量一个层次)
LinkedBox Node内部类
*1.成员内部类
将一个类直接定义在类的里面，作为成员，与属性或方法层次一致
成员内部类可以与正常类一样 使用不同的修饰符来修饰
好处1.省略了一个.java文件 好处2.成员内部类中可以访问外部类的所有成员 包括私有的
若想要在内部类中通过对象.调用外部类成员 外部类.this.外部类成员;
内部类存在后 源代码进行编译 产生一个字节码 Demo$InnerDemo.class
2.局部内部类
将一个类定义在方法/块里面，作为成员的内部结构，与临时的局部变量一个层次
局部内部类像是一个局部的变量一样，不能用public protected private及static
只能用abstract或final
局部内部类命名规则Demo$1InnerTestMethod Demo$2InnerTestMethod
局部内部类使用的变量只能是final修饰
*3.匿名内部类
成员匿名内部类
局部匿名内部类
public interfase Test{
public void test();
}
Test t = new Test(){
public void test(){
}
};
通常接口或抽象类的具体子类这样写
开发中为了省略一个类文件 上述写法比较常见
匿名内部类很特殊 只有类体 没有类的所有结构( 修饰符 名字 继承 实现)
不能用任何修饰符来修饰 匿名内部类也没有构造方法
Swing 做一个按钮 绑定一个事件监听器
4.静态内部类
成员静态内部类
不需要外部类对象，通过正常的方式直接创建内部类
静态元素不能访问非静态成员(自己类和外部类)
25 枚举类
枚举类
一个类中的对象 认为个数是有限且固定的 可以将每一个对象一一列举出来
1.试一试若没有枚举类型的时候 如何手动设计 (静态常量 单例模式) Day(类 当做描述星期 7个对象)
private构造方法
public static final属性 = new
2.JDK1.5版本之后可以直接定义enum类型
我们自己定义的enum类型直接默认继承Enum(java.lang包)
我们自己定义的enum类型不能再写extends 但是可以实现
Enum类型
有两个属性
name----->枚举对象的名字 name()获取name属性
ordinal--->枚举对象在类中罗列的顺序 类似index 也从0开始 ordinal()获取序号
一些常用的方法
valueOf() 通过给定的name获取对应的枚举对象
values() 获取全部的枚举对象 ---> 返回一个数组 Day[]
compareTo() 可以比较两个枚举对象 int
toString() 由于这个方法没有final修饰 可以覆盖(重写)
3.switch内部判断枚举的应用
4.我们也可以在enum中描述自己的一些属性或方法
必须在enum类中第一行 描述一下枚举的样子 最后需要分号结束;
可以定义自己的属性
类创建的过程中 帮我们创建枚举类型的对象
需要给枚举类型提供对应样子的构造方法 构造方法只能private修饰 可以重载
26 重写finalize方法、Runtime堆的内存查看
1 Person person = new Person();
try{
Thread.sleep(2000);
}catch (Exception e) {
e.printStackTrace();}
person=null;
System.gc();
@Override
public void finalize(){
System.out.println("person类的finalize方法");
}
person类的无参构造方法
person类的finalize方法
2 Runtime runtime = Runtime.getRuntime();
long max = runtime.maxMemory();
long total = runtime.totalMemory();
long free= runtime.freeMemory();
27 包装类
1.类所在的包
2.类的关系 自己默认继承 实现
3.是否可以创建对象 调用 方法本身静态的
4.类中提供的常用方法
包装类(封装类) 1.5版本之后 自动拆装包
byte---Byte short---Short int---Integer long---Long
float---Float double---Double char---Character boolean---Boolean
1.八个包装类都在同一个包下 java.lang包 不需要import导包直接使用
2.八个包装类中有六个是与数字相关 都默认继承父类Number
3.八个包装类都实现了Serializable, Comparable
4.八个包装类都有带自己对应类型参数的构造方法
八个包装类中有七个(除了Character)还有构造方法重载 带String类型
5.创建对象 对象调用方法
有六个与数字相关的类都继承Number xxxValue(); 将一个包装类类型转化为对应的基本类型(拆包)
Integer i1 = new Integer(10);//引用数据类型 包装类
int value = i1.intValue();
Integer i2 = 10;
int value = new Integer(10);
int value = Integer.parseInt("123"); Float.parseFloat("123.45")
int value = new Integer("123");
6.经常在笔试中出现的问题
Integer i1 = 10;
Integer i2 = 10;
Integer i3 = new Integer(10);
Integer i4 = new Integer(10);
System.out.println(i1==i2);// true--->如果数字范围超过127false
System.out.println(i1==i3);// false
System.out.println(i3==i4);// false
System.out.println(i1.equals(i2));//true
System.out.println(i1.equals(i3));//true
System.out.println(i3.equals(i4));//true
1.==与equals()区别
==可以比较基本数据类型 也可以比较引用数据类型 (变量中存储的内容)
如果比较基本类型比较是变量中存储的值
如果比较引用类型比较是变量中存储的地址引用
equals()是Object类中继承过来的方法 每一个引用类型都可以调用
默认继承的equals()方法比较与==一致 如果想要改变比较规则 可以重写equals方法
由于Integer类就重写了equals() 所以Integer比较的是数值
2.考察Integer类加载的时候 自己有一个静态的空间
空间内立即加载 Integer类型的数组 内存储256个Integer对象 -128 ~ 127
如果我们用的对象范围在这之内Integer i1 = 10; 直接取静态区中找对应的对象
如果我们用的对象范围超出了这个Integer i1 = 1000; 会帮我们创建一个新的Integer对象
28 数学math类
Math
1.所属的包java.lang
2.Math构造方法是私有的 我们不能直接调用创建对象
3.由于Math中提供的属性及方法都是static 不需要创建对象
4.常用的方法
abs()返回给定数字的绝对值 (参数 int long float double)
double = ceil()向上取整
double = floor()向下取整
double = rint()临近的整数 如果两边距离一样 则返回偶数
int = round() 四舍五入的整数
max(a,b) min(a,b) (参数int long float double)
pow(a,b) a的b次方 (参数double 返回值double)
sqrt(double a) 获取给定参数的平方根
double = random(); 随机产生一个 [0.0--1.0)
5.Math.random()计算小数的时候精确程度可能有些损失
0-9之间的随机整数
int value = (int)(Math.random()*10);
5.0---10.9之间的小数
(Math.random()*6)+5
0.0---0.99999 * 6
(0.0---5.49999)+5
Random类
1.在java.util包中的类 需要import导入
2.没有任何继承关系 默认继承Object类
3.查找构造方法--->如何创建对象
Random r = new Random();
4.类中提供的常用方法
r.nextInt(); 随机产生 int取值范围的整数 有正有负
r.nextInt(int bound); 随机产生一个 [0--bound) 整数
注意bound必须为正数 否则会出现如下的运行时异常
IllegalArgumentException
r.nextFloat() 随机产生一个 [0.0---1.0)
r.nextBoolean() 随机产生一个boolean值 true false
UUID类
1.所属的包 java.util 需要import导入
2.没有任何继承关系 默认继承Object类
3.构造方法有 没有无参数的 我们通常不会创建对象
UUID uuid = UUID.randomUUID();
System.out.println(uuid.toString());//数据库表格主键 primary key
产生一个32位的随机元素 每一个位置是一个16进制的数字
BigInteger类 大整数 long -2的63次方 ~ 2的63次方-1
1.所属的包java.math 需要import导入
2.继承自Number
3.如何创建对象 提供的构造方法全部都是带参数的
通常利用带String参数的构造方法创建这个类的对象
BigInteger bi = new BigInteger("123");
4.类中的常用方法
做四则运算
add() subtract() multiply() divide()
5.小例子 设计一个方法 用来计算给定数字的阶乘 5 1*2*3*4*5==120
//设计一个方法 用来计算给定数字的阶乘
//参数 返回值
public BigInteger factorial(int num){
BigInteger result = new BigInteger("1");
for(int i=1;i<=num;i++){
result = result.multiply(new BigInteger(i+""));
}
return result;
}
BigDecima类 超过了double取值范围//处理小数点之后的
1.所属的包 java.math包
2.继承Number类
3.通常也是可以通过 带String参数 构建对象
4.类中的常用方法
做四则运算
add() subtract() multiply() divide()
两个参数前面是保留小数点之后的位数 后面参数是设置的模式
对象.setScale(2,BigDecimal.ROUND_DOWN);
将小数点之前和之后的位数都能处理的类---->格式化
DecimalFormat
1.所属的包 java.text
2.import导入才能使用
3.通过带String参数的构造方法创建一个格式化对象 0 #
4.调用format方法将一个小数格式化成一个字符串
DecimalFormat df = new DecimalFormat("000.###");// 0 #
String value = df.format(12.45);
System.out.println(value);
29 包装类、时间类、
包装类 数学相关
Scanner类
1.所属的包java.util包 需要import导包
2.通过一个带输入流的构造方法创建对象
3.常用方法 nextInt() nextFloat() next() nextLine()
System类
1.所属的包java.lang包 不需要导入
2.不需要创建对象 通过类名就可以访问
3.有三个属性及若干的方法
三个属性out in err
方法gc() exit(0); currentTimeMillis();
日期相关
Date类
1.通常使用的是java.util包
2.导包 拿来使用 构建对象
3.通常使用无参数的构造方法 或者带long构造方法
4.Date类中常用的方法
before(); after();
setTime() getTime();----->long
compareTo(); -1 1 0
5.可以处理一个Date日期的格式
DateFormat类
1.包java.text 需要导包使用
2.此类是一个抽象类 不能创建对象 子类来使用
3.SimpleDateFormat类 是DateFormat的子类
4.调用带String参数的构造方法创建format对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String v = sdf.format(date1);//通过sdf对象将date1格式化成你描述的样子
Calendar类 1.1版本
1.所属的包java.util 需要导包
2.有构造方法 用protected修饰的 通常访问不到 通常会调用默认的getInstance();
3.常用方法
after() before()
setTime() getTime()---->Date
getTimeInMillis()----time
getTimeZone()---TimeZone
Calendar里面包含一个date属性 可以操作date的某一个局部信息
set get
calendar.set(Calendar.YEAR,2015);
int year = calendar.get(Calendar.YEAR);
TimeZone
1.java.util包
2.可以通过calendar对象.getTimeZone()获取 或 TimeZone.getDefault();
3.常用方法
tz.getID() ----> Asia/Shanghai
tz.getDisplayName() 中国标准时间
30 String类
1.存在哪儿 java.lang包
没有任何继承关系 实现三个接口Serializable, CharSequence, Comparable<String>
2.如何构建对象
String str = "abc"; //直接将字符串常量赋值给str (字符串常量池)
String str = new String();//无参数构造方法创建空的对象
String str = new String("abc");//带string参数的构造方法创建对象
String str = new String(byte[] )//将数组中的每一个元素转化成对应的char 组合成String
String str = new String(char[] )//将数组中的每一个char元素拼接成最终的String
3.String的不可变特性
String类中包含一个private final char[] value;
体现在两个地方 长度及内容
长度--->final修饰的数组 数组长度本身不变 final修饰数组的地址也不变
内容--->private修饰的属性 不能在类的外部访问
4.String类中的常用方法
1.boolean = equals(Object obj);
继承自Object类中的方法 重写啦 改变了规则 比较字符串中的字面值
== equals()区别
equalsIgnoreCase();
2.int = hashCode();
继承自Object类中的方法 重写啦 31*h+和
3.int = compareTo();
实现自Comparable接口 实现方法 结果按照字典排布(unicode编码)顺序
按照两个字符串的长度较小的那个(次数)来进行循环
若每次的字符不一致 则直接返回code之差
若比较之后都一致 则直接返回长度之差
compareToIgnoreCase();
4.String = toString()
没有重写过的toString从Object类中继承过来的
类名@hashCode(16进制形式)
String类重写啦 返回的是String对象的字面值
-----------------------------------------------------------------------------------
5.char = charAt(int index);
返回给定index位置对应的字符
int = codePointAt(int index);
返回给定index位置对应字符的code码
6.int = length();
返回字符串的长度 (其实就是底层char[] value属性的长度)
注意: 区别数组length是属性 String的length()方法 集合size()方法
7.String = concat(String str);
将给定的str拼接在当前String对象的后面
注意: 方法执行完毕需要接受返回值 String的不可变特性
concat方法与 +拼接的性能问题
开发中若遇到频繁的拼接字符串--->通常使用StringBuilder/StringBuffer
8.boolean = contains(CharSequence s);
判断给定的s是否在字符串中存在
9. startsWith(String prefix);
endsWith(String suffix);
判断此字符串是否已xx开头/结尾
10.byte[] = getBytes(); ---> getBytes(String charsetName);
char[] = toCharArray();
将当前的字符串转化成数组 "我爱你中国" char[] '我' '爱' '你' '中' '国'
11. int index = indexOf(int/String str [,int fromIndex] ); 四个方法重载
找寻给定的元素在字符串中第一次出现的索引位置 若字符串不存在则返回-1
lastIndexOf(int/String str , [int fromIndex]);
找寻给定的元素在字符串中最后一次出现的索引位置 若不存在则返回-1
12.boolean = isEmpty();
判断当前字符串是否为空字符串 (length是否为0)
注意： 与null之间的区别
13.replace();
replaceAll();
replaceFirst(); 换第一次出现的那个字串
将给定的字符串替换成另外的字符串
14.String[] = split(String regex [,int limit限度界限]);
按照给定的表达式将原来的字符串拆分开的
15.String = substring(int beginIndex [,int endIndex]);
将当前的字符串截取一部分
从beginIndex开始至endIndex结束 [beginIndex,endIndex)
若endIndex不写 则默认到字符串最后
16.String = toUpperCase();
String = toLowerCase();
将全部字符串转换成大写/小写
17.String = trim();
去掉字符串前后多余的空格
18.boolean = matches(String regex)
regular有规律的 expression表达式
正则表达式
last.常见的String笔试题
== equals方法的区别
==可以比较基本类型 可以比较引用类型
比较基本类型比较值 比较引用类型比较地址
equals只能比较引用类型(方法)
默认比较地址this==obj
如果想要修改其比较规则 可以重写equals方法
通常重写equals方法时会伴随着重写hashCode方法
比如String类 比如Integer
*String的不可变特性
长度及内容
String与StringBuffer区别
StringBuffer与StringBuilder区别
String对象的存储
"abc"---->字符串常量池
new String("abc")--->堆内存
"a"+"b"+"c"+"d"
*String中常用的方法
31 StringBuilder和StringBuffer
StringBuffer
StringBuilder
1.所属的包 java.lang包
2.继承AbstractStringBuilder 间接继承 Object
实现接口Serializable,CharSequence,Appendable
StringBuffer/StringBuilder没有compareTo方法
StringBuffer/StringBuilder含有一个String没有的方法 append();拼接
3.特性
可变字符串 char[] value; 动态扩容
4.对象的构建
//无参数构造方法 构建一个默认长度16个空间的对象 char[]
StringBuilder builder = new StringBuilder();
//利用给定的参数 构建一个自定义长度空间的对象 char[]
StringBuilder builder = new StringBuilder(20);
//利用带String参数的构造方法 默认数组长度字符串长度+16个
StringBuilder builder = new StringBuilder("abc");
5.StringBuilder中常用的方法
最主要的方法 append() 频繁的拼接字符串的时候使用此方法 提高性能
ensureCapacity(int minimumCapacity) 确保底层数组容量够用
capacity();//字符串底层char[]的容量
length();//字符串有效元素个数(长度)
setLength();//设置字符串的有效元素个数
char = charAt(int index);
int = codePointAt(int index);
String = substring(int start [,int end]);
注意需要接受返回值 看见截取出来的新字符串效果
StringBuilder = delete(int start [,int end]);
StringBuilder类中独有的方法String类没有
将start到end之间的字符串删掉 不用接受返回值就看到效果啦
StringBuilder = deleteCharAt(int index);
String类中没有的方法
将给定index位置的某一个字符删除掉啦
int = indexOf(String str [,int fromIndex]);
int = lastIndexOf(String str [,int fromIndex])
找寻给定的str在字符串中第一次出现的索引位置 带重载 则从某一个位置开始找
insert(int index,value);
将给定的value插入在index位置之上
replace(int start,int end,String str);
将start和end之间的部分替换成str
builder.replace(2,5,"zzt");
setCharAt(int index,char value);
将index位置的字符改成给定的value
toString()
将StringBuilder对象 构建成一个string对象 返回
trimToSize()
将数组中无用的容量去掉 变成length长度的数组
32 String和Stringbuilder的异同点
知识总结
1.StringBuilder类不一定需要 是为了避免String频繁拼接修改字符串信息的时候才用的
底层数组是可变的 提高了性能
2.常用方法
与String类不同的独有方法
append() insert() delete() deleteCharAt() reverse()
与String类相同的方法
length() charAt() codePointAt() indexOf() lastIndexOf()
substring() replace()名字相同 用法不一致
不是很常用的方法
ensureCapacity() capacity() setLength() trimToSize(); setCharAt();
3.String家族笔试中经常容易考察的知识点
1.String所属的包 继承关系 实现接口
java.lang 继承Object 接口Serializable,CharSequence,Comparable
2.String构建方式
常量 构造方法
3.String对象内存结构
字符串常量区 new堆内存对象
== equals()区别
"a"+"b"+"c"
4.String不可变特性
长度及内容
5.String中的常用方法---与StringBuilder的区别
concat(); toUpperCase();
6.String和StringBuilder区别 | String和StringBuffer区别
String不可变字符串
JDK1.0
有一个接口Comparable
不可变体现在长度及内容
有一些方法StringBuilder没有 concat compareTo toUpperCase
StringBuilder可变字符串
JDK1.5
有一个接口Appendable
可变字符串 没有final修饰 底层可以进行数组扩容
有一些方法String没有 append() insert() delete() reverse()
7.StringBuffer和StringBuilder的不同
StringBuffer早期版本1.0
StringBuilder后来的版本1.5
早期版本 线程同步 安全性比较高 执行效率相对较低
后期版本 线程非同步 安全性比较低 执行效率相对较高
33 正则
Regular有规律的 Expression表达式
正则表达式regex
一个带有一定规律的表达式
匹配字符串格式的
正则表达式通常的作用如下:
1.字符串的格式校验 String类中提供的一个方法 boolean = str.matches("regex");
2.字符串的拆分及替换 String类中提供的方法replace split
3.字符串的查找 Pattern模式 Matcher匹配器
如下的所有都用来描述字符的信息
[abc] abc其中的一个
[^abc] 不能是abc其中的一个 其他都可以
[a-zA-Z] 表示必须是这两个范围内的
[a-z&&[^bc]] 表示a-z其中的一个但不能是b和c
| 或者
. 代表任意一个字符
\d digit数字 [0-9]
\D 非数字 [^0-9]
\s space留白 一个空格 一个回车 一个换行。。。
\S 非留白
\w word单词 [0-9A-Za-z] 数字或字母都可以
\W 非单词 [^0-9A-Za-z]
如下的所有都用来描述字符出现的次数
? 0-1次 [0-9]?
* 0-n次
+ 1-n次
{n} 固定n次
{n,} 至少出现n次
{m,n} m-n次
//所有的字串中找寻满足如下规则的信息 邮政编码
String str = "123456abc222333abc654321abc";
//1.利用Pattern类创建一个模式 理解为是一个正则表达式对象
Pattern pattern = Pattern.compile("\\d{6}");//邮编
//2.需要提供一个字符串
//3.利用pattern模式对象创建一个匹配器
Matcher matcher = pattern.matcher(str);
//4.找寻字符串中出现满足上述格式的字串
while(matcher.find()){
System.out.println(matcher.group());//找到满足字符串格式的那一串文字
}
\\中的第一个\表示java的转义字符\由编译器解析，第二个\是正则表达式\由正则表达式引擎解析。
Java正则表达式中匹配一个普通的反斜杠是\\\\
34 集合之ArrayList
变量---容器
存储一个元素
数组---容器
一组具有某种特性的数据存放在一起
存储一组元素(数据类型一致) 长度固定
集合---容器 与数组类似 集合的长度存储之后还能改变
集合是用来存储一组元素
可以理解为集合是我们封装的Box 只不过比我们写的更加的优秀 更多的方法
集合java.util
Collection Map
存储的都是value 存储的是以key-value形式存在
List Set
有序可重复 无序无重复 key无需无重复 value无需可重复
序 : 顺序 添加进去的元素 取得元素的顺序一致 注意指的不是集合自己的顺序
重复：两个对象元素一致
ArrayList Vector区别--->StringBuilder StringBuffer
List集合
1.ArrayList 3.Vector 2.LinkedList
1.ArrayList----->底层就是一个数组
所属的包 java.util
如何创建对象
无参数构造方法 带默认空间的构造方法 带collection参数的构造方法
常用的方法---小容器
存 add
取 get
删 remove
改 set
个数 size
add(E e) add(int index,E e)
addAll(Collection c); add(int index,Collection c)
clear();将集合内的全部元素清除
boolean = contains(Object);找寻某一个给定的元素是否在集合中拥有
ensureCapacity(int minCapacity);
E = get(int index);
int = indexOf(Object obj); lastIndexOf();
boolean = isEmpty();
Iterator = list.iterator();//迭代器
remove(int index) remove(Object obj)
removeAll()差集
retainAll();交集
E = set(int index,E value)
int size();
List = subList(int begin,int end);
toArray(); 集合变成数组
toArray(T[] );
trimToSize();// 变成有效元素个数那么长
35 泛型
关于泛型的问题：//必须是引用类型
由于arrayList底层是一个Object[] 什么类型都可以存进去
取出来的时候多态的效果 需要自己造型 显得用起来非常的麻烦
JDK1.5之后--->泛型
用来规定数据类型的，定义的时候用一个符号代替某种类型
在使用的时候用具体的数据类型 将定义的那个符号替换掉
泛型可以用在哪里?
1.泛型类
类定义的时候描述某种数据类型 集合的使用就是这样
2.泛型接口
与泛型类的使用基本一致 子类实现接口时必须添加泛型
3.泛型方法
方法调用时传参数 方法的泛型与类无关 带有泛型的方法可以不放在带有泛型的类中
4.高级泛型 规范边界 extends super
36 集合之Vector、Stack、Queue、LinkedList
Vector类
1.java.util包
2.是ArrayList集合的早期版本 (StringBuffer早期 StringBuilder后来)
Vector底层也是利用(动态)数组的形式存储
Vector是线程同步的(synchronized) 安全性高 效率低
3.扩容方式与ArrayList不同
默认是扩容2倍 可以通过构造方法创建对象时修改这一机制
4.构造方法
5.常用方法
Stack类 栈
1.java.util包
2.构造方法只有一个无参数
3.除了继承自Vacton类的方法外还有特殊的方法
push(E e)将某一个元素压入栈顶(add())
E = pop()将某一个元素从栈顶取出并删掉(E = remove())
E = peek()查看栈顶的一个元素 不删除(get())
boolean = empty()判断栈内元素是否为空(isEmpty())
int = search()查找给定的元素在占中的位置(indexOf())
4.中国象棋 悔棋
栈中存储每一次操作的步骤
撤销功能
Queue接口
1.java.util 通常子类LinkedList ArrayDeque
2.通常无参数构造方法创建
3.一般方法
add()
element()---->get()
remove()
boolean = offer(E e);//相当于add 不会抛出异常
E = peek();//相当于 element方法
E = poll();剪短// 相当于remove()
4.双十一零点秒杀
所有进入秒杀系统的人存入队列
ArrayList
LinkedList类
1.java.util包 自己封装过LinkedBox 内部类Node<T>对象(节点 prev item next)
2.底层使用双向链表的数据结构形式来存储
适合于插入或删除 不适合遍历轮询
3.构建对象
无参数构造方法 带参数的构造方法(collection)
4.常用的方法
增删改查 add() remove() set() get() size() offer poll peek
手册中提供的其他常用方法
addAll addFist addLast() clear() contains()
element() getFirst() getLast() indexOf() lastIndex()
.....
5.插入删除的特性是否像想的那样
对比ArrayList Linked
37 集合之HashSet、TreeSet
Collection 以value形式存在
Set 无序无重复
1.具体的实现类
HashSet
TreeSet
2.基本的使用
3.无序 无重复
无序：我们使用集合存放元素的顺序 集合内取出来的顺序不一致
集合本身是有自己的算法排布顺序 hash算法
HashSet---->(HashMap (数组+链表) 散列表 临接连表)
1.java.util
2.如何创建对象 无参数 有参数
3.集合容器的基本使用
增删改查
boolean = add(value) addAll(collection c) retainAll removeAll
boolean = remove(Object)
没有修改方法
iterator() 获取一个迭代器对象
size()
4.无重复的原则
首先通过String类型和Person类型存储
大概猜测 无重复的原则 利用equals方法进行比较
如果我们想要让Person对象的name一致 认为是同一个对象
我们可以重写equals方法
重写了equals方法 发现还没有产生无重复的效果
证明可能原则不止equals一个方法这么简单
还有另一个规则同时起着作用 hashCode方法 int
五个Person对象只剩一个 第一次存储的 还是最后一次存储
set集合是发现重复的元素 拒绝存入 存储的是第一个
TreeSet-----(TreeMap 二叉树 利用Node(left item right))
无序无重复 java.util
无参数构造方法 带Collection构造方法
基本常用方法
add(E e) iterator() remove(E e) 没有修改 size()
无重复的规则是如何实现的
treeSet集合本身有顺序 我们指的无序存入的和取出来的不一致
compareTo---->String类 按照字母的自然顺序排布(Unicode)
如果想要把自己写的类型 比如Person对象存入TreeSet集合里
不能随意的存储 需要让自己写的类先实现Comparable接口
38 集合之HashMap、TreeMap
Map 映射 通过某一个key可以直接定位到一个value值
存储的方式以 键值对 存储 key-value
key无序无重复 value无序可重复
key无序还是一样，指的是存入顺序与取得顺序不一致
key无重复当然指的是 元素不能一致
1.map基本使用
HashMap
TreeMap
Properties
HashMap
1.包 java.util
2.如何创建对象
3.基本方法
增删改查
增put(key,value) 存放一组映射关系 key-value
1.key存储的顺序与取得顺序不同
2.不同的key可以存储相同的value
3.key若有相同的 则将 原有的value覆盖而不是拒绝存入(跟set刚好相反)
删E = remove(key);
改put(key,value1) put(key,value2)
replace(key,newValue)
查E = get(key)
遍历map集合? key不一定什么样
获取到所有的key 遍历key 通过key获取value
Set<Key> = keySet()获取全部的key
Set<Entry> = entrySet();
size();
4.除了上述几个常用的方法外 其他API中提供的方法
clear containsKey(key) containsValue(value)
getOrDefault(key,defaultValue);如果key存在就返回对应的value 若没有找到则返回默认值
isEmpty()
putAll(map)
putIfAbsent(key,value);//如果key不存在才向集合内添加 如果key存在就不添加啦
5.map集合在什么情形下用?
1.想要存储一组元素
数组 or 集合 如果存储的元素以后长度不变用数组 如果长度以后不确定 用集合
2.如果发现长度以后不确定--->集合
List Set Map
List家族有序的 存储有顺序用这个
ArrayList 更适合遍历轮询
LinkedList 更适合插入和删除
Stack LIFO
Set家族无重复 存储元素希望自动去掉重复元素用这个
Hash 性能更高
Tree 希望存进去的元素自动去重复 同时还能自动排序
Map家族k-v 通过唯一的k快速找寻v用这个
Hash 性能更高
Tree 希望存进去的元素key自动排序
6.登录小流程
能体会每一个不同集合的特点
7.HashMap底层的数据结构存储
散列表的形式 数组+链表
Person对象存入HashMap中? 可以
hashCode方法---->不同的对象 可以产生相同的hashCode码的
不同的hashCode码-->不同的对象
TreeMap 自然有序 按照Unicode编码自然有序
map集合中的key需要可比较的 key的对象需要实现Comparable接口
1.java.util包
2.构造方法
无参数 带map参数
3.常用方法
put get remove replace size
4.底层数据结构的存储
红黑二叉树
39 异常
添加处理异常的手段
处理异常不是 异常消失了
处理异常指的是 处理掉异常之后 后续的代码不会因为此异常而终止执行
两种手段
try{}catch(){}[ finally{} ]
1.try不能单独的出现
2.后面必须添加catch或finally
3.catch有一组括号 (NullPointerException) 目的是为了捕获某一种异常
4.catch可以有很多个存在
捕获的异常之间没有任何的继承关系
捕获的异常需要从小到大进行捕获
5.finally不是必须存在的
若存在finally结构 则必须执行
引申一个小问题: final finally finalize区别
final 特征修饰符 修饰变量 属性 方法 类
修饰变量 基本类型 值不能改变 引用类型 地址不能改变(如果变量没有初值 给一次机会赋值)
修饰属性 特点与修饰变量类似 (要求必须给属性赋初始值 否则编译报错)
修饰方法 不能被子类重写
修饰类 不能被其他的子类继承
finally 处理异常手段的一部分
try{}catch(){}后面的一个部分
这个部分可有可无 如果有只能含有一份 且必须执行
finalize 是Object类中的一个protected方法
对象没有任何引用指向的时候 -- 会被GC回收
当对象回收的时候 默认调用finalize方法
若想要看到对象回收的效果 可以重写 public void finalize(){}
6.处理异常放在方法内部 可能还会有小问题
如果在方法内部含有返回值
不管返回值return关键字在哪里 finally一定会执行完毕
返回值的具体结果 看情况
------------------------------------------------------------
throws抛出
1.异常只能在方法上抛出 属性是不能处理异常的
2.方法 构造
3.方法可以抛出不止一个异常 通过，隔开
4.抛出的异常与多个catch类似 要么没关系 要么先抛出小异常
-------------------------------------------------------------
Throwable的分支
Exception Error
运行时
编译时
两种处理异常的手段 try throws
常用的运行时异常 后续见到的编译时异常
我们也可以自己创建异常----自定义异常
1.自己描述一个异常的类
2.让我们自己的类继承
如果继承是RuntimeException---->运行时异常(不需要必须添加处理手段)
如果继承是Exception-------------->编译时异常(必须添加处理手段)
3.创建一个当前自定义异常类的对象
通过throw关键字 主动产生异常
4.当我们设计描述的方法(事情) 之前没有相关的异常能描述我的问题Box
这个时候才会利用自定义异常来描述
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
