1. 子父类间异常的注意事项:
子类重写父类方法时只能抛出相同异常或者该异常的子类。
如果父类方法没有抛出异常,子类进行方法重写时,只能通过try catch进行捕获。
2. IO体系:
InputStream/OutputStream 字节流的抽象类。 Reader/Writer 字符流的抽象类。
FileInputStream/FileOutputStream 节点流(操作文件) ByteArrayInputStream/ByteArrayOutputStream 节点流
ObjectInputStream/ObjectOutputStream 处理流(操作对象)
DataInputStream/DataOutputStream(操作基本数据类型与字符串)
FileReader/FileWriter 节点流(操作文件) BufferedReader/BufferedWriter(处理流,增加缓存功能,提高读写效率。)
BufferedInputStream/BufferedOutputStream(处理流,增加缓存功能,提高读写效率。)
InputStreamReader/OutputStreamWriter(处理流:将字节流对象转化成字符流对象。)
3. 序列化:把Java对象转换为字节序列的过程称为对象的序列化。
反序列化:把字节序列恢复为Java对象的过程称为对象的反序列化。
4. 序列化涉及的类和接口:
ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化。
ObjectInputStream代表对象输入流,它的readObject()方法输入流中读取字节序列,再把它们反序列化为一个对象。
只有实现了Serializable接口的类的对象才能被序列化。 Serializable接口是一个空接口,只起到标记作用。
5. 对象中的某些属性如果不想被序列化,不能使用static,而是使用transient修饰。
6. java.lang包下的包装类:八种基本数据类型都有对应的包装类,分别是:
Byte Short Integer Long Float Double Character Boolean
7. 包装类的主要用途:作为和基本数据类型对应的类型存在,方便涉及到对象的操作,如Object[]、集合等的操作。
8. 如果数据在-128~127这个区间,那么在类加载时就已经为该区间的每个数值创建了对象。
public class Test3 {
public static void main(String[] args) {
Integer in1 = -128;
Integer in2 = -128;
System.out.println(in1 == in2);//true 因为123在缓存范围内
System.out.println(in1.equals(in2));//true
Integer in3 = 1234;
Integer in4 = 1234;
System.out.println(in3 == in4);//false 因为1234不在缓存范围内
System.out.println(in3.equals(in4));//true
}
}
9. 自动装箱调用的是valueOf()方法。自动拆箱调用的xxxValue()方法。
10. DateFormat是一个抽象类,一般使用它的的子类SimpleDateFormat类来实现时间和字符串之间的转换。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDateFormat {
public static void main(String[] args) throws ParseException {
// new出SimpleDateFormat对象
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
// 将时间对象转换成字符串
String daytime = s1.format(new Date());
System.out.println(daytime);
System.out.println(s2.format(new Date()));
System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));
// 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
String time = "2007-10-7";
Date date = s2.parse(time);
System.out.println("date1: " + date);
time = "2007-10-7 20:15:30";
date = s1.parse(time);
System.out.println("date2: " + date);
}
}
11. 日历类:Calendar 类是一个抽象类,GregorianCalendar 是 Calendar 的一个具体子类。
12. 枚举:JDK1.5引入了枚举类型。枚举类型的定义包括枚举声明和枚举体。格式如下:
enum 枚举名 {
枚举体(常量列表)
}
import java.util.Random;
public class TestEnum {
public static void main(String[] args) {
// switch语句中使用枚举
int a = new Random().nextInt(4); // 生成0,1,2,3的随机数
switch (Season.values()[a]) {
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case AUTUMN:
System.out.println("秋天");
break;
case WINDTER:
System.out.println("冬天");
break;
}
}
}
/**季节*/
enum Season {
SPRING, SUMMER, AUTUMN, WINDTER//枚举实例默认都是public static final修饰的。
}
13. 进程:执行中的程序叫做进程(Process),是一个动态的概念。现代的操作系统都可以同时启动多个进程。比如:在用酷
狗听音乐,也可以使用eclipse写代码,也可以同时用浏览器查看网页。
14. 线程:线程是一个进程内部的一个执行单元,它是程序中的一个单一的顺序控制流程。 一个进程可以产生多个线程。
15. java中实现多线程的两种方式:
通过继承Thread类实现多线程 :
public class TestThread extends Thread {//自定义类继承Thread类
//run()方法里是线程体
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(this.getName() + ":" + i);//getName()方法是返回线程名称
}
}
public static void main(String[] args) {
TestThread thread1 = new TestThread();//创建线程对象
thread1.start();//启动线程
TestThread thread2 = new TestThread();
thread2.start();
}
}
通过Runnable接口实现多线程:
public class TestThread2 implements Runnable {//自定义类实现Runnable接口;
//run()方法里是线程体;
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public static void main(String[] args) {
//创建线程对象,把实现了Runnable接口的对象作为参数传入;
Thread thread1 = new Thread(new TestThread2());
thread1.start();//启动线程;
Thread thread2 = new Thread(new TestThread2());
thread2.start();
}
}
16. 线程的五个状态:创建 就绪 运行 阻塞 死亡
start()方法从创建状态到就绪状态。 获得cpu,通过run方法进入运行状态。 sleep(int millsecond)+wait()+join()三种方法
可使线程进入阻塞状态。
17 . 终止线程的典型方式:
public class TestThreadCiycle implements Runnable {
String name;
boolean live = true;// 标记变量,表示线程是否可中止;
public TestThreadCiycle(String name) {
super();
this.name = name;
}
public void run() {
int i = 0;
//当live的值是true时,继续线程体;false则结束循环,继而终止线程体;
while (live) {
System.out.println(name + (i++));
}
}
public void terminate() {
live = false;
}
public static void main(String[] args) {
TestThreadCiycle ttc = new TestThreadCiycle("线程A:");
Thread t1 = new Thread(ttc);// 新生状态
t1.start();// 就绪状态
for (int i = 0; i < 100; i++) {
System.out.println("主线程" + i);
}
ttc.terminate();
System.out.println("ttc stop!");
}
}
18. sleep()方法:可以让正在运行的线程进入阻塞状态,直到休眠时间满了,进入就绪状态。
19. yield()方法:可以让正在运行的线程直接进入就绪状态,让出CPU的使用权。
20. 线程A在运行期间,可以调用线程B的join()方法,让线程B和线程A联合。这样,线程A就必须等待线程B执行完毕后,才能
继续执行。
public class TestThreadState {
public static void main(String[] args) {
System.out.println("爸爸和儿子买烟故事");
Thread father = new Thread(new FatherThread());
father.start();
}
}
class FatherThread implements Runnable {
public void run() {
System.out.println("爸爸想抽烟,发现烟抽完了");
System.out.println("爸爸让儿子去买包红塔山");
Thread son = new Thread(new SonThread());
son.start();
System.out.println("爸爸等儿子买烟回来");
try {
son.join();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("爸爸出门去找儿子跑哪去了");
// 结束JVM。如果是0则表示正常结束;如果是非0则表示非正常结束
System.exit(1);
}
System.out.println("爸爸高兴的接过烟开始抽,并把零钱给了儿子");
}
}
class SonThread implements Runnable {
public void run() {
System.out.println("儿子出门去买烟");
System.out.println("儿子买烟需要10分钟");
try {
for (int i = 1; i <= 10; i++) {
System.out.println("第" + i + "分钟");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子买烟回来了");
}
}