一 . Charactor 类
1. 概念:
Charactor 类是基本数据类型 char 类型的包装类型,包含 char 的值,此外,该类还提供了几种方法来确定字符的类别 ( 小写字母 , 数字等),并将字符从大写转换为小写,反之亦然.
2. 构造方法:
Charactor ( char value )参数里面也可以为 int---char : 将一个字符内容构造成包装类类型
3. 成员方法:
判断功能:
public static boolean isDigit(char ch):判断当前ch字符是否为数字
public static boolean isLowerCase(char ch):判断当前ch字符是否为小写字母字符
public static boolean isUpperCase(char ch)确定指定的字符是否为大写字符。
二 . date 类
1 . 概念
表示日期格式 : 精确到瞬间毫秒
2 . 构造方法
public Date () : 无参构造方法,获取当前系统时间的日期格式 默认使用当前的系统时间
public Date ( long date ) : 将long类型--构造成 Date 对象 : long 指定时间毫秒值 (与1970年1月1日)
3 . 成员方法
public long getTime () : 将Date日期格式--转换成long类型返回自1970年1月1日以来的 Date毫秒数
4 . 日期文本格式与 Date 格式之间转换
DateFormat 是日期/时间格式化子类的抽象类,它以语言无关的方式格式化和分析日期或时间.但是它是一个抽象类,抽象类不能实例化,他提供了更具体的子类 SimpleDateFormat 进行操作
(1)Date-----String
<1>创建日期对象
<2>创建SimpleDateFormat对象:中间桥梁,格式化/解析工具
<3>利用public final String format(Date date)完成转换
yyyy:表示年 2009
* MM:月 07/11
* dd:月中的天 01
*
* HH:小时数 14 (24小时制)
* mm:分钟数 02
* ss:描述 03
Date date = new Date() ;//1
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;//2
String dateStr = sdf.format(date);//3(2)String-----Date
<1>创建String文本
注意:当前的SimpleDateFormat的模式必须和字符串文本格式对应!,否则解析出问题
<2>创建SimpleDateFormat对象
<3>利用public Date parse(String source)解析完成
String sourc = "2008-5-12" ;//1
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd" ) ;//2
Date date2 = sdf2.parse(sourc);//3三 . Calendar 类
1 . 概念 :
表示的特定的一组时间 : 诸如 YEAR , MONTH , DAY_OF_MONTH
2 . 如何实例化
如果一个类定义为抽象类 , 那么目的是不让这个类实例化 , 它肯定会有静态功能 , 返回值它本身
3 . 静态功能
public static Calendar getInstance ()
4 . 成员变量----常量
public static final int YEAR : 年
public static final int MONTH : 月:角标是从0开始计算, 计算出来+1
public static final int DATE : 月中的日期 和DAY_OF_MONTH同义词
5 . 成员方法
public int get (int filed) : 获取当前的日历字段
public abstract void add (int filed , int amount) : 设置时间偏移量 , 针对当前日历字段 , 减去或者添加指定 amount ( 偏移量 )
四 . System 类
1 . 概念:
不能实例化 , 里面提供一些标准的输入流
静态字段 (常量)
public static final InputSteam in ;
public static final PrintStream out ;
2 . 静态功能
public static void gc() //手动开启垃圾回收器
public static void exit(int status)//:参数为0,正常终止JVM
public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)//复制数组
public static long currentTimeMillis()//:计算当前系统时间毫秒值
五 . Random 类
1 . 概念:
伪随机数生成器
2 . 构造方法
Random():创建随机数生成器,通过它调用功能获取的随机是不同的 (使用无参构造居多)
Random(long seed):创建随机数生成器,通过它调用功能,产生随机数值相同的
3 . 成员方法
public int nextInt():获取随机数int类型范围
public int nextInt(int n):获取0-n之间随机数,不包括n (重点)
六 . Math 类
1 . 概念
java . lang . Math : 数学的运算工具类
2 . 功能都是静态
public static double abs(double/int a):求绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static double max(double a,double b):获取最大值
public static double min(double a,double b):获取最小值
public static double random():[0,1) :获取0,1随机数,不包含1
public static long round(double a):四舍五入
public static double sqrt(double a):开正方根
public static double pow(double a,double b):a的b次幂
七 . BigDecimal 类
1 . 概念 :
对小数进行精确计算
public BigDecimal(String val) :将数字字符构造成BigDecimal对象
2 . 功能
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, RoundingMode roundingMode)
参数1:指定的除数
参数2:保留的有效位数
参数3:指定舍入模式: ROUND_HALF_UP 四舍五入
八 . 选择排序 :
1 . 选择排序思想 :
使用 0 角标对应的元素依次和后面角标对应的元素进行比较 , 小的往前方 , 第一次比较完毕 , 最小值出现在最小索引出 , 依次比较 , 比较的次数 : 数组长度 - 1次
2 . 核心代码
for(int i = 0;i < arr.length-1;i++){
for(int j = i + 1;j < arr.length;j++){
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
九 . Collection集合
1 . 集合的概念 :
一种容器 , 能够存储引用数据类型的容器 , 长度可变 !
2 . Collection 集合
某些集合允许重复元素( List ),而其他集合不允许( Set ). 有些有序和有些无序
JDK 不提供此接口的任何直接实现,提供了更具体的子接口----->子实现类 间接实现!
集合的有序性 : 存储和取出一致!
无序性: 存储和取出不一致!
3 . Collection 的基本功能
boolean add(Object e)：添加任意类型
boolean remove(Object o)：删除指定的元素
void clear()：暴力删除，将集合中所有元素删除
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean isEmpty():判断是否为空,不为空,false;空,true
int size():获取集合的元素数
Collection 的高级功能
<1>boolean addAll(Collection c):添加一个集合中的所有元素
<2>boolean containsAll(Collection c):包含一个集合的所有元素:包含所有算包含
<3>boolean removeAll(Collection c):删除一个集合中包含另一个集合中的某个元素,就算删除,返回
true
<4>boolean retainAll(Collection c):将交集的元素保存A集合中,boolean表达的意思:将保存在A集合
中的元素是否和之前的元素发生变化,如果前后发生变化,则返回true;没有变化,则返回false.
4 . 集合和数组的区别
1) 长度的区别:
数组长度 : 固定
集合长度 : 可变
2) 存储数据类型的区别
数组 : 既可以存储基本数据类型 , 而且存储引用数据类型
int [] arr = new Student [3] ;
Student [] student = new Student [3];
3) 存储元素的区别
数组 : 既存储基本数据类型,也可以存储引用类型,元素类型必须统一
集合 : 虽然只能存储引用数据类型 , 但是可以存储任意引用类型 , 没有泛型
5 . 泛型
1 . 概念 :
泛型就是集合对象在创建同时明确数据类型,并且将运行时期异常提前到编译时期(模拟数组定
义).使用<引用数据类型>
2 . 好处
1) 提高程序安全性
2) 解决黄色警告线
3) 使用集合的迭代器避免强制类型转换
3 .
JDK5以后,提供了<E>泛型,提高程序安全性,将运行时期异常,提前编译时期,
4 . 泛型的定义方式
1) 泛型定义在类上
public class ObjectTool<T> {}
ObjectTool<String> ot = new ObjectTool<>() ;
ot.show("hello") ;
ObjectTool<Integer> ot2 = new ObjectTool<>() ;
ot2.show(100) ;
2 泛型定义在方法上
public <T> void show(T t){}
泛型定义在方法上的格式:权限修饰符 <T> 返回值类型 方法名(T 参数名){}3) 泛型定义在接口上
1> 接口的子实现类已经明确了类型
明确了泛型,集合添加只能当前类型,直接添加不了其他类型,后期通过反射
public interface Inter<T> {
void show(T t) ;
}
情况1:接口的子实现类已经明确了类型
public class InterImpl<String> implements Inter<String> {
@Override
public void show() {
System.out.println("show InterImpl...");
}
}
Inter<String> inter = new InterImpl<>() ;
inter.show();
2> 接口的子实现类不明确里面存储的类型
情况2:子实现类不明确泛型的类型
public class InterImpl<T> implements Inter<T>{
@Override
public void show(T t) {
System.out.println(t) ;
}
}
Inter<Integer> inter = new InterImpl<>() ;
inter.show(100) ;
Inter<String> inter2 = new InterImpl<>() ;
inter2.show("helloworld") ;
4 . 泛型的通配符
1) <?>:代表Object或者任意的Java类型(jdk提供/自定义的)
2) <? extends E>:向下限定,E这个类型以及它的子类
3) <? super E> :向上限定,E这个类以及它的父类
十 . 迭代器
1 . 概念
迭代器是集合专有的遍历方式 , 迭代器是接口,是通过ArrayList的内部类来实现他里面的hasNext()和next().
2 . 迭代器是接口而不是类的原因
如果是类,使用继承的特点,子类继承父类,可以继承父类非私有的成员,继承具有局限性,不仅获取到
了需要的,其他不需要的也获取过来了;提供接口,面向接口编程,提高功能扩展,谁实现了接口,就具备
当前这个额外功能.
3 . 迭代器的使用
Iterator<E> iterator():迭代器:集合专有遍历方式
Iterator:接口 1) boolean hasNext() 判断是否有下一个可以迭代的元素 (判断功能)
2) Object next():获取下一个可以迭代的元素(获取功能)
Collection c = new ArrayList() ;
c.add("hello") ;
c.add("world") ;
c.add("java") ;
Iterator it = c.iterator();
while(it.hasNext()){
String s = (String) it.next();
System.out.println(s+"---"+s.length());
}
十一 . List 集合
1. List 集合特点 :
有序 : 存储和取出一致 ; 元素可以重复
2 . List 集合的特有功能 :
void add(int index, Object element): 在指定位置处添加一个新的元素
Object remove(int index): 删除指定位置处的元素
E set(int index, Object element): 修改指定位置处的元素内容
Object get(int index): 获取指定位置处的元素
ListIterator<E> listIterator() : 列表迭代器
ListIterator接口:
boolean hasNext() : 判断当前列表中是否有下一个可以遍历的元素
Object next(): 获取下一个元素
boolean hasPrevious(): 判断当前列表中是否有上一个可以遍历的元素
Object previous(): 获取上一个元素
3 . List 集合的 5 种遍历方式
1):Collection集合的toArray()----Object[]
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("javaee");
Object[] objects = list.toArray();
for(int i = 0;i < objects.length;i++){
String s = (String)objects[i];
System.out.println(s+"---"+s.length());
}
2):Coillection集合的Iterator迭代器
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
3):get(int index) + size() 的普通for循环
for(int i = 0;i < list.size();i++){
String s = list.get(i);
System.out.println(s);
}
4):使用列表迭代器
ListIterator<String> stringListIterator = list.listIterator();
while(stringListIterator.hasNext()){
String next = stringListIterator.next();
System.out.println(next);
}
5):增强for循环
for(泛型数据类型 变量名 : 集合对象名称){
输出变量名;
}
for(String s:list){
System.out.println(s);
}4 例题
(1)使用List存储字符串数据,遍历这个list集合,如果当前元素内容有"world",需要给List中添加一个新
的元素"php".
解决方案:1)使用集合判断,使用集合添加或者修改
2)使用迭代器,使用迭代器添加/修改
for(int x = 0 ; x < list.size() ; x ++){
String s = list.get(x) ;
判断
if("world".equals(s)){
集合添加
list.add("php");
}
}
System.out.println(list);
使用ListIterator列表迭代器中添加功能void add(E e)
ListIterator<String> listIterator = list.listIterator();
while(listIterator.hasNext()){
获取
String s = listIterator.next();
if("world".equals(s)){
迭代器添加
listIterator.add("php"); 在指定元素后面插入
}
}
(2)使用List存储多个字符串,有重复元素,如何去重
List<String> newList = new ArrayList<>() ;
遍历旧集合获取每一个元素:增强for
for(String s:list){
在新集合中判断是否包含这个元素,如果不包含,才给新集合中添加
if(!newList.contains(s)){
newList.add(s) ;
}
}
遍历新集合
for(String s:newList){
System.out.println(s);
}
}
方式2:选择排序思想
for(int x = 0 ; x < list.size()-1; x++){
for(int y = x+1 ; y < list.size() ; y ++){
业务思想:如果前面的元素和后面元素一致,将后面的重复元素删除掉
if(list.get(y).equals(list.get(x))){
将后面的元素删除
list.remove(y) ;
y -- ;
}
}
}
遍历当前这个集合
for(String s :list){
System.out.println(s);
}
十二 . List 集合子实现类
ArrayList:底层数据结构是数组,数组的特点:查询快,增删慢.从线程角度考虑:由于实现是不同步的,执
行效率高,线程不安全.默认容量为10个,以1.5倍扩容.
Vector:底层数据结构是数组,查询快,增删慢.线程角度:实现同步的,里面的成员方法大部分都会有
synchronized同步锁,保证安全性安全性很高,但是执行效率低,单线程程序中,使用ArrayList替代
Vector.
LinkedList:底层数据结构是一个链表,线程角度:不同步的,单线程中执行效率高,安全性低!链表:数据
域和指针域组成.
1. ArrayList
(1)构造方法:
<1>public ArrayList():构造一个初始容量为十的空列表
<2>public ArrayList(int initialCapacity):指定容量大小
(2)ArrayList嵌套for使用
ArrayList<ArrayList<Student>> bigArray = new ArrayList<>() ;
for(ArrayList<Student> array :bigArray){
for(Student s :array ){
System.out.println(s.getName()+"\t"+s.getAge());
}
}
2 . Vector
1) Vector集合:在List集合中最明显的特点:线程安全
2) 特有功能
<1>public void addElement(Object obj):添加元素
<2>public boolean removeElement(Object obj):直接从Vector集合中删除指定的元素
<3>public Object elementAt(int index):通过指定的索引值获取元素
<4>public Enumeration<Object> elements():(特有迭代器)获取Vector集合中的枚举组件接口---------------类似于public Iterator iterator():迭代器
boolean hasMoreElements() ---->类似于 boolean hasNext() 判断是下一个遍历的元素
Object nextElement() ---类似于 Object next() 获取下一个元素
(5)Vector集合另两种遍历方式
使用特有功能: public Object elementAt(int index) +size()
for(int x = 0 ; x < v.size() ; x ++){
String s = v.elementAt(x);
System.out.println(s) ;
}
public Enumeration<Object> elements():(特有迭代器)获取Vector集合中的枚举组件接口
Enumeration<String> en = v.elements();
while(en.hasMoreElements()){
String s = en.nextElement();
System.out.println(s) ;
}
3 . LinkedList
1) LinkedList:不同步,线程不安全,执行效率高; 数据结构是:链表
2) 特有功能
<1>public void addFirst(Object e):在链表开头插入元素
<2>public void addLast(Object e):将元素追加到链表的末尾
<3>public Object getFirst():获取链表的第一个元素
<4>public Object getLast():获取链表的最后一个元素
<5>public Object removeFirst():删除链表第一个元素并获取第一个元素
<6>public Object removeLast():删除链表最后一个元素并获取
十三 : Set 集合子实现类
Set集合:无序.保证元素唯一
1. HashSet 子实现类
(1)HashSet:底层一个HashMap的实例,保证元素唯一(底层哈希表,和HashMap有关系),不能保证迭
代顺序恒久不变.
(2)Hash面试题:为什么HashSet<String>,添加重复的String数据,能够将元素唯一?
答:hashSet集合的添加功能add方法间接依赖于HashMap的put方法,底层依赖于hashCode()和
equals()方法;首先,要比较当前存储String类型数据的哈希码值是否相同,如果相同,比较是内容是否
一样,调用equals()方法,String类型已经重写了Object,比较内容.
2 . TreeSet
TreeSet<E>:底层依赖于TreeMap;是Red-Black-Tree数据结构:红黑树(自平衡的二叉树结构);有
两种排序:自然排序/比较器排序,取决于构造方法.
TreeSet集合的两种排序方式
<1>public TreeSet()构造一个新的,空的树组,根据其元素的自然排序进行排序;要实现自然排序,当
前存储对象的类型必须实现Comparable接口.
public class Student implements Comparable<Student>{
@Override
public int compareTo(Student s) { 需要后面的元素的年龄和当前根节点元素年龄的比较
int num = this.age - s.age ; 三元运算
int num2 = (num==0)?(this.name.compareTo(s.name)):num ;
return num2;
}
}
TreeSet<Student> ts = new TreeSet<>() ; 创建TreeSet集合对象
后续添加遍历
<2>TreeSet集合的另一种排序:比较器排序: public TreeSet(Comparator<? super E> comparator)
Comparator<T> 接口中有一个抽象方法: int compare(T o1,T o2)
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge() ; 主要条件:学生的年龄从小到大排序
次要条件:年龄相同的,按照学生的姓名:字典顺序比较
int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
return num2 ;
}
}) ;
后续添加遍历操作
十四 . Map
1. 概念
Map是Java提供的另一种方式Map<K,V>:K 键,V 值----存储一系列的键值对元素.
2.特点
Map集合特点:不能包含重复的键(必须唯一),如果重复,后面的值会将前面的值覆盖
3. Map和Collection的区别?
(1)存储结构不一样:
<1>Collection<E>,单例集合,只能存储一种引用数据类型
<2>Map<K,V>,双例集合,可以存储多个引用数据类型
(2)遍历方式不同
<1>Collection:迭代器遍历---最终使用的是增强for
<2>Map<K,V>: 通用的方式:将所有K获取到,通过键找值
(3)存在一定的关系
Collection里面Set子实现类都依赖于Map实现.
Map接口---->不能实例化
具体的子类
HashMap<K,V>
TreemMap<K,V>
4 . Map基本功能
(1)V put(K key,V value):
添加键值对元素,返回键对应的值,通过方法的返回值是为null,判断键是否是第一次添加
(2)void clear() 暴力删除,将Map清空
(3)V remove(Object key):删除指定的键,返回被删除的键对应的值
(4)boolean containsKey(Object key):是否包含指定的键
(5)boolean containsValue(Object value):是否包含指定的值
(6)int size():获取Map的键值对个数(元素)
(7)Set<K> keySet():获取所有的键的集合
(8)V get(Object key):通过键获取值
(9)Collection<V> values():获取Map中所有的值
(10)Set<Map.Entry<K,V>> entrySet():获取Map集合中的键值对对象
5. Map集合两种遍历方式
方式1:"夫妻对"(通用)
Set<K> keySet():获取所有的键的集合------>找到"丈夫"
V get(Object key):通过键获取值---------->通过"丈夫",找对应的"妻子"
方式2: "结婚证"
Set<Map.Entry<K,V>> entrySet():获取Map集合中的键值对对象 ------>获取到了所有的"结婚证"
K getKey() 键值对对象获取键----> 结婚证---丈夫
V getValue() 键值对对对象获取值--->结婚证---找妻子
HashMap
Map<String,String> map = new HashMap<>() ; 创建Map集合
map.put("杨过","小龙女") ; 添加键值对元素
map.put("郭靖","黄蓉") ;
Set<String> set = map.keySet(); 获取所有的键的集合
for(String key :set){
String value = map.get(key); 通过键获取值
System.out.println(key+"="+value) ;
}
Set<Map.Entry<String, String>> entrySet = map.entrySet(); 获取所有的键值对对象
for(Map.Entry<String, String> en:entrySet){
String key = en.getKey() ; K getKey() 键值对对象获取键
String value = en.getValue() ; V getValue() 键值对对象获取值
System.out.println(key+"="+value) ;
}
HashMap<String,ArrayList<Student>> map = new HashMap<>() ;
Set<String> set = map.keySet();
for(String key :set){
System.out.println(key);
ArrayList<Student> value = map.get(key);
for(Student s:value){
System.out.println("\t\t"+s.getName()+"\t"+s.getAge());
}
}
}
6 . TreeMap<K,V>:针对元素(键)自然排序或者比较器排序,取决于构造方法
<1>public TreeMap():自然排序
<2>public TreeMap(Comparator<? super K> comparator):比较器排序
//public TreeMap(Comparator<? super K> comparator):比较器排序
TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() -s2.getAge() ; 学生的年龄从小到大
int num2 = (num==0)?(s1.getName().compareTo(s2.getName())):num ;
return num2 ;
}
}) ;
十五 . Collections类
1 . Collections类:针对集合操作的工具类
2 . 特有功能
<1>public static void reverse(List<?> list):将List元素反转
<2>public static void shuffle(List<?> list):将List集合随机置换
<3>public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合自然排序
<4>public static <T> void sort(List<T> list,Comparator<? super T> c):针对List集合进行比较器排序
<5>public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key):
在集合中查询key元素第一次出现索引值 (集合有序!----List<Integer>)
<6>public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T>
coll): 获取集合中最大值和最小值元素
<7>public static <T> List<T> synchronizedList(List<T> list) :和多线程结合使用
十六 . 多线程
1 . 概念
多进程是指操作系统能同时运行多个任务（程序）。
多线程是指在同一程序中有多个顺序流在执行。
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口.
2 . 构造方法
<1>public Thread():创建线程
<2>Thread(Runnable target)分配一个新的 Thread对象
<3>Thread(Runnable target, String name):创建线程类对象,将资源类对象作为参数传递,并且给线程设置名称
3 . 常量字段
<1>public static final int MIN_PRIORITY = 1 :最小优先级
<2>public static final int NORM_PRIORITY = 5 默认优先级
<3>public static final int MAX_PRIORITY = 10 最大优先级
4 . 成员方法
<1>public final String getName():获取线程名称
<2>public final void setName(String name):设置线程名称
<3>public final void join() throws InterruptedException:等待该线程终止,才执行其他线程
<4>public final int getPriority():获取优先级
<5>public final int getPriority():设置优先级
优先级越大:抢占CPU的执行权越大/ 优先级越小:抢占到CPU执行权越小
<6>public static void yield():暂停当前正在执行的线程,执行同优先级的其他线程
<7>public final void setDaemon(boolean on):标记某个线程是否为守护线程
参数如果为true,就是守护线程,如果线程都是守护线程,则JVM退出;
注意事项:如果要设置某个线程为守护线程,必须在在启动线程之前,调用setDaemon(true)
<8>public static Thread currentThread():获取当前正在执行的线程,返回值为当前线程对象
5 . 多线程创建步骤
public class MyTherod extends Thread {//线程类
@Override
public void run() {//两个线程都要执行run方法
for(int i = 0;i < 100;i++){
System.out.println(getName()+" "+i);
}
}
}
public class Test01 {
public static void main(String[] args) {
//创建线程类对象
MyTherod th1 = new MyTherod();
MyTherod th2 = new MyTherod();
th1.setName("张三");
th2.setName("李四");
th1.start();
th2.start();
}
}
public class MyRunnable implements Runnable{//自定义一个类实现Runnable接口
@Override
public void run() {
for(int i = 0;i < 100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class TestRunnable {
public static void main(String[] args) {
MyRunnable run = new MyRunnable();
Thread s1 = new Thread(run,"线程1");//创建Thread类对象
Thread s2 = new Thread(run,"线程2");
s1.start();
s2.start();
}
}注意:一个线程只能调用一次start()方法,调用多次 :线程状态被修改,报错,
IllegalThreadStateException:非法线程状态异常.
6 . 实现方式
1.继承Thread类，重写run方法
2.多线程的实现方式
* 1)自定义一个类,实现Runnable接口,
* 2)重写接口中的run方法:就只有一个run
* 3)在main用户线程中,创建当前类的对象,
* 然后创建Thread类对象:将当前的那个类的对象作为参数传递
* 构造方法
* Thread(Runnable target)分配一个新的 Thread对象。
* Thread(Runnable target, String name):创建线程类对象,将资源类对象作为参数传递,并且给线程设置名称
十七 . final,finally,finalize的区别
(1)final：java中的关键字，修饰符。final用于声明属性，方法和类，分别表示属性不可交变，方法
不可覆盖，类不可继承。
(2)finally是对Java异常处理模型的最佳补充。finally是异常处理语句结构的一部分，表示总是执
行。
(3)finalize：Java中的一个方法名。finalize是Object类的一个方法，在垃圾收集器执行的时候会调
用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。
106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
