final
最终修饰符 可以修饰 类 方法 变量
修饰类 类不能被继承
修饰方法 方法不能被重写
修饰变量 只能赋值一次 不能2次赋值 是常量
1.final修饰引用数据类型变量 变量的地址值不能改变 但是属性值可以变
2.final修饰成员变量 不能使用默认值 创建对象之前赋值
直接显示赋值
所有构造方法中赋值
接口
接口是功能的集合 描述的是功能 接口中都是抽象方法(JDK1.8之前)
定义格式
public interface 接口名{
抽象方法;
}
接口的使用
1.接口不能创建对象
2.使用类实现接口
3.重写抽象方法
4.创建实现类对象 调用方法
实现的动作类似继承 就是关键字不同
public class 类 implements 接口{
重写方法
}
接口的成员特点
接口没有构造方法
接口中的成员变量 被public static final修饰 是常量
接口中的成员方法 被public abstract修饰
接口的特点
类与类 单继承
类与接口 多实现
接口与接口 多继承
类可以在继承一个类的同时 实现多个接口
接口与抽象类的区别
成员区别
构造方法
接口没有构造方法
抽象类有构造方法 给子类使用
成员变量
接口没有变量 只有常量
抽象类既可以有变量 也可以有常量
成员方法
接口中的方法都是抽象的
抽象类中 既可以有抽象方法 也可以有具体的方法
思想的区别
抽象类描述的是一类事物的共性内容
接口描述的是功能
多态
多态的前提
1.继承或者是实现关系
2.需要有方法重写
多态的格式
父类引用指向子类对象
具体类 变量 = new 子类对象();
抽象类 变量 = new 子类对象();
接口 变量 = new 实现类对象();
多态后访问的成员特点
成员变量
编译时 到父类中找 如果有编译通过 没有报错
运行时 打印的父类成员变量的值
编译时 看左边
运行时 看左边
成员方法
编译时 到父类中找 如果有编译通过 没有报错
运行时 子类重写后的方法
编译时 看左边
运行时 看右边
多态后 一切都是父类的表现形式 只有方法运行的子类重写后的方法.
向上转型
多态本身就是向上转型
Fu fz = new Zi();
向下转型
向上转型后 不能访问子类特有功能
要想访问 需要向下转型
Zi zf = (Zi)fz;
需要注意
Fu fu = new fu();
Zi zi = (Zi)fu; //抛运行时异常 ClassCastException 类型转换异常
instanceof关键字
boolean b = 对象 instanceof 类型;
if(对象 instanceof 类型){
向下转型 避免出现类型转换异常
}
static 静态修饰符
可以修饰类的成员 被static修饰的成员 属于类 而不单属于某个对象
被所有对象所共享
static 静态的访问
对象名.属性名; 不推荐
对象名.方法名(实际参数); 不推荐
类名.属性名;
类名.方法名(实际参数);
static的注意事项
静态内容随着类的加载而加载 优先于对象出现
所以静态只能直接访问静态 不能直接访问非静态
静态中不能使用this/super
局部代码块
限制变量的作用域范围
成员代码块
定义在类中方法外的代码块
创建对象时执行 也称为构造代码块
静态代码块
类加载时执行 类只加载一次 静态代码块只执行一次
1.创建对象
2.创建子类对象
3.访问静态成员
4.访问子类静态成员
类的加载
加载
连接
初始化
静态代码块执行
静态代码块> 构造代码块>构造方法
修饰词
public 公共权限 可以修饰 类 方法 成员变量 任意地方都可以访问 一个文件中只能有一个public修饰的类
public修饰的类 类名必须与文件名相同
protected 受包含的权限 可以修饰 内部类 方法 成员变量 当前包与其他包的子类可以访问
默认 包权限 可以修饰类 方法 成员变量 当前包下可以访问
private 私有权限 可以修饰 内部类 方法 成员变量 当前类可以访问
final 最终修饰符 可以修饰 类 方法 成员变量 局部变量
final修饰类不能继承 修饰的方法不能被重写 修饰的变量是常量
static 静态修饰符 可以修饰 内部类 方法 成员变量
abstract 抽象修饰符 可以修饰 类 方法
final和abstract能不能一起使用?
final和abstract修饰类 不能一起使用 final修饰的类不能继承 而abstract修饰的类 要求必须继承
final和abstract修饰符方法 也不能一起使用 final修饰不能重写 而abstract修饰的方法 要求子类必须重写
static和abstract能不能一起使用?
如果修饰内部类 可以一起使用
但是如果修饰方法 不能一起使用 假设可以的话 就会出现类名直接运行一个抽象方法 调用抽象方法没有意义
final和static能不能一起使用?
可以
private和abstract能不能一起使用?
如果修饰内部类 可以一起使用
如果修饰方法 不能一起使用 private修饰的方法 子类看不到 而abstract要求子类重写 冲突.
native 本地修饰符 可以修饰方法 如果被native修饰的方法 说明这个方法不是用java语言编写
用c语言编译 这个方法 与操作系统进行交互 我们看不到源码.
如果父类没有空参构造方法
//子类继承就会报错 因为子类的中含有空参构造
//并且在空参构造方法的第一行默认有super()调用父类的空参构造
//如果父类没有空参构造方法 则报错
java.lang.Object
java中所有类的根类 所有的类都直接或者间接继承自Object类
构造方法
public Object()
方法
public String toString()返回该对象的字符串表示。 类名+@+地址值(哈希值)
在Object类中打印的是地址值 ,我们查看地址值没有用
子类一般都会重写此方法 返回对象的属性值
Object类方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
如果不重写此方法 比较的是两个对象的地址值
子类一般都会选择重写此方法 不再比较地址值 而是比较属性值
== 如果比较基本类型 比较的是基本类型的数值是否相等
如果比较引用类型 比较的是地址值是否相同
Object类
public int hashCode() 获取对象的哈希值
哈希值:可以理解为一个唯一值 相当于人一出生的身份证号 可以理解为是逻辑地址
结论
如果不重写Object类的hashCode方法 比较两个对象的hashCode就是比较两个对象的地址值
如果重写了Object类HashCode方法 比较两个对象的hashCode就是比较两个对象的内容
如果想确定内容是否真的相同
可以先比较两个对象的hashCode
不同 说明这两个对象的内容一定不同
相同 不能说明这两个对象一定相同 需要继续比较equals
不同 一定不同
相同
java.lang.String
特点
1.所有字符串字面值 都是字符串对象 "abc"
2.字符串是常量 一旦创建 不能改变
3.因为不可改变 所以可以共享
字符串的比较
构造方法
public String();
public String(String str)
字符 字节数组 转换为字符串
String 构造方法
public String(char[] chs);
public String(char[] chs,int start ,int length)
public String(byte[] bytes)
public String(byte[] bytes,int start ,int length)
将字符串转换为字符数组
String 类
public char[] toCharArray();
将字符串转换为字节数组
String 类
public byte[] getBytes();
String类
public char charAt(int index) 根据索引找字符
长度
数组
length属性
集合
size()方法
字符串
length()方法
String 类
方法
int indexOf(int ch) 查找当前字符 在字符串中第一次出现的索引位置
int indexOf(int ch,int fromIndex) 从fromIndex开始查询
int lastIndexOf(int ch) 查询指定字符 在字符串中最后一次出现的索引
int lastIndexOf(String str)
字符串截取
String substring(int startIndex) 从开始索引截取到末尾
String substring(int startIndex,int endIndex) [start,end)
字符串大小写转换
String toUpperCase() 字符串转大写
String toLowerCase() 字符串转小写
字符串判断开头和结尾
boolean startsWith(String s) 判断开头
boolean endsWith(String s) 判断结尾
String 类
String concat(String s) 字符串拼接
String trim() 去掉字符串两端的空格
String replace(char oldChar,char newChar) 将字符串中 oldChar 替换成newChar
String repalce(String oldString,String newString)
java.lang.StringBuffer 线程安全 效率低
java.lang.StringBuilder 线程不安全 效率高
构造方法
public StringBuilder() 创建一个空的缓冲区
public StringBuilder(String str) 创建一个存储了str的缓冲区
方法
public StringBuilder append(Object obj) 向容器中追加数据
10 ---"10"
引用类型 ----自动调用引用类型的toString方法 添加
String toString() 将StringBuilder类型转换为字符串
StringBuilder reverse() 将缓冲区中的数据反转
java.util.Date 日期类
时间原点:1970年1月1日 00:00:00
1秒 = 1000毫秒
构造方法
public Date() 当前日期对象
public Date(long time) 指定毫秒值的日期对象
方法
long getTime() 获取日期对象的毫秒值
void setTime(long time) 设置毫秒值
java.text.DateFormat
方法
String format(Date date) 将日期转换为字符串
Date parse(String s) 将字符串 解析为日期对象
常用子类
java.text.SimpleDateFormat
构造方法
public SimpleDateFormat() 23-4-5 上午10:39
SimpleDateFormat(String pattern) 指定模式
y --- 年
M ---月
d --- 日
H ---- 时
m ---- 分
s ---- 秒
E ---- 星期
java.util.Calendar 日历类 抽象类
静态方法创建对象
public static Calendar getInstance() 获取当前日历对象 实际上返回的是 子类对象
方法
int get(int field) 返回给定日历字段的值。
0-11 代表 1- 12月
外国每周第一天 是周日
java.util.Calendar
方法
Date getTime() 将日历对象转为日期对象
void add(int field, int amount)根据日历的规则,为给定的日历字段添加或减去指定的时间量。
void set(int field, int value) 将给定的日历字段设置为给定值。
void set(int year, int month, int date)
java.lang.System 系统类
构造方法私有 所有方法静态
static void exit(int status) 退出虚拟机 0代表正常退出
public static void gc() 运行垃圾回收器
获取毫秒值
1.Date类的getTime方法
2.Calendar类的 getTimeInMillis()
3.System类静态方法 currentTimeMillis()
System类
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
Object src:源数组
int srcPos:源数组开始索引
Object dest:目标数组
int destPos:目标数组的开始索引
int length :要复制的个数
java.util.Arrays 数组工具类
构造方法私有 所有方法静态
静态方法
public static void sort(int[] arr) 排序
public String toString(int[] arr) 将指定的数组转换为字符串 [3,8,2,5,0]
public static int binarySearch(int[] arr ,int key) 二分查找
Arrays
static int[] copyOf(int[] original, int newLength) 数组复制
java.math.BigInteger
大整数运算
构造方法
public BigInteger(String s);
java.math.BigDecimal
可以进行精确的小数计算
构造方法
public BigDecimal(String str)
字符串与基本类型转换
String --- int
Integer静态方法
int parseInt(String num)
基本类型 ---->String
String s = 基本类型数值+ "";
String 方法
static String valueOf(int num)
基本类型 ---->包装类型
int ---> Integer
构造方法
public Integer(int n)
public Integer(String s);
Integer ---->int
Integer方法
int intValue()
异常
Throwable
Error 错误 不能处理
Exception 异常 编译时异常 编译时 就报错 必须处理 不处理代码 编译不通过
RuntimeException 运行时异常 编译时 不报错 运行时才报错
异常的第一种处理方式
try{
可能出现异常的代码
}catch(异常的类名 变量名){
打印异常的信息
}catch(异常的类名 变量名){
}..
多catch处理异常 有没有顺序
如果多个异常之间没有继承关系 没有顺序
如果有继承关系 有顺序 小的在前 大的在后
try{
}catch(){
}finally{
无论是否有异常 无论 是否捕获了异常 finally中的内容 一定会被执行
}
异常处理的第二种方式 声明异常
throw 异常的对象 抛出异常 在方法内使用
throws 异常的类名 声明异常 在方法的声明上使用
编译时异常
Exception及其子类 编译时就报错 必须处理 不处理代码无法运行
运行时异常
RuntimeException及其子类 编译时 不报错 运行时 才报错 可以处理 也可以不处理 推荐不处理
因为对于运行时异常来说 基本上都是代码写的有问题 需要改代码
打印异常信息的方式
Throwable
String getMessage() 获取异常的简短信息 文件没找到
String toString() 获取异常的简短信息 java.io.FileNotFoundException: 文件没找到
void printStackTrace() 直接打印异常的详细信息
异常后方法重写的注意事项
1.父类方法抛异常 子类方法能不能抛异常?
可以不抛
也可以抛异常 但是 抛出的异常 必须和父类方法抛出的异常相同 或者是其子类异常
2.父类方法不抛异常 子类方法能不能抛异常?
子类重写方法不能抛异常 如果子类方法中有异常 必须try catch
java.util.Collection 集合层次的根接口
方法
- public boolean add(E e): 把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素,存储到数组中
常用实现类
ArrayList
集合和迭代器
Collection
public abstract Iterator<E> iterator() 获取迭代器 方法是抽象方法 但是任意一个Collection的实现类都会
重写此方法 方法的返回值类型是Iterator接口 一定会返回接口的实现类对象
Iterator接口
boolean hasNext() 判断是否有元素
E next() 获取元素
定义一个集合 存储4个元素 柳岩 唐嫣 金莲 大郎
迭代集合 判断 如果遇到金莲 添加一个西门庆
ConcurrentModificationException
并发修改异常
当迭代器在迭代的同时 集合修改了自身的长度 就会抛出此异常
增强for循环 JDK1.5
作用
用来遍历数组 或 集合
原理
一个增强for循环 底层使用的就是一个迭代器
注意:迭代的同时 不能修改集合的长度
格式
for(数据类型 变量名:集合或数组){
}
泛型
定义泛型
泛型可以定义在 接口 类 方法上 将数据类型作为参数传递
定义泛型的好处
可以预先使用未知的类型
使用泛型
我们创建集合 指定集合中元素的类型 就是在使用泛型
使用泛型的好处
1.明确知道集合中存储元素的类型
2.将运行时异常 提前到编译时报错
3.避免强制类型转换的麻烦
泛型类
public class 类名<泛型变量>{
}
创建对象时 确定泛型的数据类型
泛型方法
public <泛型变量>返回值类型 方法名(形参){
}
调用方法 传递参数时 确定泛型的数据类型
泛型接口
public interface 接口名<泛型变量>
1.定义实现类时 直接确定泛型的数据类型
2.定义实现类时 不确定泛型的数据类型 实现类也是泛型类 创建实现类对象时 确定类型
java.util.List 接口
特点
有序 有索引 元素可重复
判断元素相同的依据是对象的equals方法
方法
- public void add(int index, E element): 将指定的元素,添加到该集合中的指定位置上。
- public E get(int index):返回集合中指定位置的元素。
- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
- public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
常用的实现类
ArrayList
底层数据结构是数组
查询快 增删慢
LinkedList
底层数据结构是链表
查询慢 增删快
java.util.ArrayList
特点
有序 有索引 元素可重复
底层数据结构是数组
查询快 增删慢
构造方法
public ArrayList() 构造一个初始容量为10的空列表
public ArrayList(int initialCapacity) 创建一个指定初始容量的列表
public ArrayList(Collection<? extends E> c) 创建一个ArrayList 存储Collection<? extends E> c集合中的元素
java.util.LinkedList
特点
有序 有索引 元素可重复
底层数据结构是链表
查询慢 增删快
特有方法
- public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public E getFirst():返回此列表的第一个元素。
- public E getLast():返回此列表的最后一个元素。
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。
- public void push(E e):将元素推入此列表所表示的堆栈。
java.util.Collections 集合工具类
构造方法私有 所有方法静态
方法
public static void shuffle(List list) 打乱集合中元素的顺序
public static void sort(List list) 对集合中元素进行排序 自然排序 集合中的元素 必须实现自然排序接口 Comparable 重写compareTo方法
Collections
方法
public static void sort(List list,Comparator c) 传入比较器 指定比较规则
匿名内部类
作用:临时创建一个类子类对象的快捷方式
格式
new 父类/接口(){
重写方法
}
java.util.Set
特点
元素唯一
方法和Collection一致
常用实现类
TreeSet
排序 唯一
HashSet
无序 唯一
LinkedHashSet
有序 唯一
java.util.TreeSet
构造方法
public TreeSet() 空参构造 集合中的元素必须实现自然排序接口Comparable接口 重写CompareTo方法
如果CompareTo方法 返回值为0 说明两个元素相同 不添加到集合
public TreeSet(Comparator c) 带参构造 需要传入一个比较器指定比较规则 如果传入比较器 自然排序不生效
此时 Set集合中的元素可以不实现Comparable接口
如果重写的compare方法 返回0 说明两个元素相同 不添加到集合
TreeSet集合 如何保证元素唯一
1.如果实现Comparable接口 compareTo方法 返回0 说明元素相同 添加失败
2.如果使用比较器 compare方法 返回0 说明元素相同 添加失败
java.util.HashSet
存储自定义类型 如果想保证元素唯一 必须重写hashCode和equals方法
特点
无序 唯一
先比较对象的hashCode
不同 添加到集合
相同 继续比较equals
不同 添加到集合
相同 不添加
java.util.LinkedHashSet extends HashSet
特点
底层数据结构是 链表+ 哈希表
链表保证元素有序 哈希表保证元素唯一
先比较hashCode
不同 添加到集合
相同 继续比较equals
不同 添加
相同 不添加
java.util.Map<K,V> 双列集合顶层接口
K: key 键 键是唯一的
V:value 值 值是可以重复的
方法
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。 返回值一般是null值 如果键相同 值会覆盖 会返回被覆盖的值
public V get(Object key) 根据指定的键,在Map集合中获取对应的值。
public boolean containsKey(Object key) 判断是否包含指定键
public V remove(Object key ) 根据键删除一对元素 并返回被删除的值
常用实现类
TreeMap
键 排序 唯一
HashMap
键 无序 唯一
LinkedHashMap
键 有序 唯一
Map集合的第一种遍历方式
核心方法
Set<K> keySet() 获取存储所有键的Set集合
1.定义Map集合 添加数据
2.调用keySet方法 获取存储所有键的Set集合
3.遍历Set集合 依次获取到每个元素(Map集合的key)
4.调用Map集合的get方法 根据键找到对应的值
Map集合的第二种遍历方式
核心方法
Set<Map.Entry<K,V>> entrySet() 获取到存储结婚证(键值对映射关系对象)的Set集合
1.创建Map集合 添加数据
2.调用entrySet 获取到存储结婚证(键值对映射关系对象)的Set集合
3.遍历Set集合 依次获取到每个结婚证 对象
4.调用结婚证对象的方法 获取到 键 和值
K getKey()
V getValue()
java.util.HashMap
底层数据结构是哈希表 允许null键和null值
键 无序 唯一
先比较hashCode
不同 元素不相同
相同 继续比较equals
相同
不同
HashMap集合 自定义类型作为键 需要重写hashCode和equals方法 保证键的唯一
java.util.TreeMap
特点
底层数据结构是红黑树 不允许null键 允许null值
键 排序 唯一
构造方法
public TreeMap() 如果是空参构造 集合中的键 必须实现自然排序接口
public TreeMap(Comparator c) 如果带参构造 需要传入一个比较器对象 键是否实现自然排序接口都可以
public TreeMap(Map<? extends K,? extends V> m)
java.util.Properties
特点
1.继承自Hashtable 实现了Map接口
2.没有泛型 键String 值String
3.唯一一个可以和IO流直接结合使用的集合
方法
setProperty(String key,String value) 添加元素 相当于 put
getProperty(Object key) 根据键找值 相当于 get
Set<String> stringPropertyNames() 获取存储键的Set集合 相当于 keySet