JavaSE必备知识点3

JavaSE必备知识点—杂七杂八

时间处理相关类

Date类

在计算机中,我们把1970年1月1日00:00:00定为基准时间(北京时间8点),每个度量单位是毫秒(1秒的千分之一)。我们用long类型的变量表示时间,从基准时间往前几亿年,往后几亿年都可以表示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.xiaolin.a;
import java.util.Date;
public class TestDate {
public static void main(String[] args) {
Date d1 = new Date(); //当前时刻
System.out.println(d1);
//从1970年1月1日00:00:00时刻开始所过的毫秒数(可为负)
Date d2 = new Date(2000);
System.out.println(d1.after(d2)); //true
System.out.println(d1.before(d2)); //false
Date d3 = new Date(2000);
System.out.println(d2.equals(d3)); //时间是否相等 true
System.out.println(d1.getTime()); //返回从基准点到当前时间所用的毫秒数
System.out.println(d1.toString()); //转换成字符串形式
}
}

以后遇到日期处理,要使用Canlendar日期类。

DateFormat类

作用:把时间对象转化成指定格式的字符串。也可以将指定格式的字符串转化成时间对象。DateFoemat是一个抽象类,一般使用它的子类SimpleDateFormat类来实现。下表是相应的一些格式,也给出了部分代码示例。

表8-2 格式化字符的含义.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.xiaolin.a;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDateFormat {

public static void main(String[] args) throws ParseException {
//后者是前者的子类 特殊标记不要变即可,其余地方可以随便加
//把时间对象转换成字符串
DateFormat d1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(d1.format(new Date()));

//将字符串按照“格式字符串指定格式”转成相应的日期
DateFormat d2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date = d2.parse("2016-9-01 20:44:10"); //上面这一行是什么格式,下面这一行就是什么模式
System.out.println(date);
//测试其他
DateFormat d3 = new SimpleDateFormat("D"); //表示今天是今年的多少天
System.out.println(d3.format(new Date()));
}
}

Calendar日期类

Calendar类是一个抽象类,为我们提供了关于日期计算的相关功能,比如:年、月、日、时、分、秒的展示和计算。GregorianCalendar时calendar的一个具体子类,提供了世界上大多数国家/地区使用的标准日历系统。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.xiaolin.a;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class TestCalendar {
public static void main(String[] args) {
//获得日期的相关元素
Calendar c1 = new GregorianCalendar();
//这个year就是常量,就是为了表示获得的是年份为不是其他
System.out.println(c1.get(Calendar.YEAR));

int month = c1.get(Calendar.MONTH); //0-11表示1-12月份 0:1月 11:12月
System.out.println(month);

int day = c1.get(Calendar.DATE); // DAY_OF_MONTH 都可以使用
System.out.println(day);

int weekday = c1.get(Calendar.DAY_OF_WEEK);//表示星期几 1-7 1:周日 2:周一 ... 7:周六
System.out.println(weekday);

//设置日期的相关元素
Calendar c2 = new GregorianCalendar(); //什么都不写 默认当前时间
c2.set(Calendar.YEAR, 9102); //设置年份
System.out.println(c2.get(Calendar.YEAR));

//日期的计算
Calendar c3 = new GregorianCalendar(); //什么都不写 默认当前时间
c3.add(Calendar.YEAR,100); //增加日期
System.out.println(c3.get(Calendar.YEAR));

//日期对象与时间对象的转化
Date d4 = c3.getTime();
Calendar c4 = new GregorianCalendar();
c4.setTime(new Date());

//上面三种类的结合
printCalendar(c1);
}
public static void printCalendar(Calendar c){
Date a = c.getTime();
DateFormat d1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(d1.format(a));
}
}

综合运用:可视化日历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package com.xiaolin.a;
/**
* 可视化日历程序
*/
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

public class VisualCalendar {
public static void main(String[] args) throws ParseException {
Calendar n1 = changeString(); //确定当前时间
System.out.println();
System.out.println("日\t一\t二\t三\t四\t五\t六");
//Date now = new Date();
int month = n1.get(Calendar.MONTH)+1; //确定当前月份 符合中国人习惯
int year = n1.get(Calendar.YEAR); //确定当前年份
int day = n1.get(Calendar.DATE); //确定当前时间
Calendar n2 = new GregorianCalendar(year,month-1,1); //设置当年当月1号的时间 上面加了1,下面就要减回去
int n2_dayWeek = n2.get(Calendar.DAY_OF_WEEK); //看1号是周几

n2_dayWeek--; //为下面的代码做准备
if(month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12){
printCal(n2_dayWeek,31,day);
}else if(month == 2&& year%4==0){ //
printCal(n2_dayWeek,29,day);
}else if(month == 2){
printCal(n2_dayWeek,28,day);
}else{
printCal(n2_dayWeek,30,day);
}
}
public static Calendar changeString() throws ParseException{
Calendar a = new GregorianCalendar();
System.out.print("请输入日期(格式为2019-11-6): ");
Scanner in = new Scanner(System.in);
String str = in.nextLine();
in.close();
DateFormat b = new SimpleDateFormat("yyyy-MM-dd");
Date c = b.parse(str); //在进行转码的时候自动进行month-1
a.setTime(c);
return a;
}
public static void printCal(int n2_dayWeek,int lastDay,int day){
int printDay = 1; //从1号开始打印
while(true){
for(int i=0;i<7;i++){
if(n2_dayWeek>0){
System.out.print("\t");
n2_dayWeek--;
}else{
if(day == printDay) System.out.print(printDay+"*\t");
else System.out.print(printDay+"\t");
if(++printDay>lastDay) break;
}

}
if(printDay>lastDay) break;
System.out.println();
}
}
}

Math类

Math类的常用方法:(这些都是静态方法,使用类名直接进行调用的)

  1. abs 绝对值

  2. acos,asin,atan,cos,sin,tan 三角函数

  3. sqrt 平方根

  4. pow(double a, double b) a的b次幂

  5. max(double a, double b) 取大值

  6. min(double a, double b) 取小值

  7. ceil(double a) 大于a的最小整数

  8. floor(double a) 小于a的最大整数

  9. random() 返回 0.0 到 1.0 的随机数

  10. long round(double a) double型的数据a转换为long型(四舍五入)

  11. toDegrees(double angrad) 弧度->角度

  12. toRadians(double angdeg) 角度->弧度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class TestMath {
public static void main(String[] args) {
//取整相关操作
System.out.println(Math.ceil(3.2));
System.out.println(Math.floor(3.2));
System.out.println(Math.round(3.2)); //四舍五入
System.out.println(Math.round(3.8)); //四舍五入
//绝对值、开方、a的b次幂等操作
System.out.println(Math.abs(-45));
System.out.println(Math.sqrt(64));
System.out.println(Math.pow(5, 2));
System.out.println(Math.pow(2, 5));
//Math类中常用的常量
System.out.println(Math.PI);
System.out.println(Math.E);
//随机数
System.out.println(Math.random());// [0,1)之间的随机数 double类型
}
}

Random类

Math类中虽然为我们提供了产生随机数的方法Math.random(),但是通常我们需要的随机数范围并不是[0, 1)之间的double类型的数据,这就需要对其进行一些复杂的运算。如果使用Math.random()计算过于复杂的话,我们可以使用例外一种方式得到随机数,即Random类,这个类是专门用来生成随机数的,并且Math.random()底层调用的就是Random的nextDouble()方法。 这个不是静态方法,使用时要注意!!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Random;
public class TestRandom {
public static void main(String[] args) {
Random rand = new Random();
//随机生成[0,1)之间的double类型的数据
System.out.println(rand.nextDouble());
//随机生成int类型允许范围之内的整型数据
System.out.println(rand.nextInt());
//随机生成[0,1)之间的float类型的数据
System.out.println(rand.nextFloat());
//随机生成false或者true
System.out.println(rand.nextBoolean());
//随机生成[0,10)之间的int类型的数据
System.out.println(rand.nextInt(10));
//随机生成[20,30)之间的int类型的数据
System.out.println(20 + rand.nextInt(10));
//随机生成[20,30)之间的int类型的数据(此种方法计算较为复杂)
System.out.print(20 + (int) (rand.nextDouble() * 10));
}
}

Arrays类

Arrays类是一个工具类,里面全部都是静态方法,构造器被private修饰,不可以进行对象声明。该工具类中包含用于操作数组的各种方法(如排序和搜索)。该类还包含一个静态工厂,可以将数组视为列表。如果指定的数组引用为空,则该类中的方法都抛出一个NullPointerException ,除非另有说明。

下面将一些常用的方法陈列在下面:

方法 说明
Arrays.toString(array) 数组转字符串
Arrays.sort(array) 数组排序
Arrays.equals(array1,array2) 比较一维数组
Arrays.deepEquals(array1,array2) 比较多维数组
Arrays.asList() 数组转为ArrayList,用toArray可转回数组
Arrays.fill() 数组填充
Arrays.copyOf() 数组拷贝
Arrays.binarySearch() 使用二进制搜索算法搜索指定值的指定字节数组。

详细信息请查看源码或者对应的API。

File类

代表文件或者目录,可用于读取文件、生成文件、删除文件、修改文件等操作。

https://www.bilibili.com/video/av47088187/?p=121

异常

Exception,就是指一些例外的情况。异常机制的本质就是当程序出现错误的时候,程序安全退出的机制。

Java是采用面向对象的方式来处理异常的。处理过程如下:

1.抛出异常:在执行一个方法时,如果发生异常,则这个方法生成代表该异常的一个对象,停止当前执行路径,并把异常对象提交给JRE。

2.捕获异常:JRE得到该异常后,寻找相应的代码来处理该异常。JRE在方法的调用栈中查找,从生成异常的方法开始回溯,直到找到相应的异常处理代码为止。

1
2
3
4
5
6
7
8
9
10
public class TestException {
public static void main(String[] args) {
try{
int a = 1/0;
System.out.println(a);
}catch(Exception e){
System.out.println("TestException.main()"); //结果会打印这句话
}
}
}

Exception类是所有异常类的父类,其子类对应了各种各样可能出现的异常事件。通常Java的异常可分为:RuntimeException运行时异常 和 CheckedException 已检查异常。

运行时异常

运行时异常,如被0除、数组下标越界、空指针等,其产生比较频繁,处理麻烦,如果总是显式的声明或捕获将会对程序可读性和运行效率产生很大影响。因此由系统自动检测并将它们交给缺省的异常处理程序(用户可不必对其处理)。

这类异常多是程序员自身编写代码时引起的,多是些逻辑错误。

通常主要多加一些判断,来避免这些运行时异常。

已检查异常

所有不是RuntimeException的异常,统称为CheckedException。这类异常在编译时就必须做出处理,否则无法通过编译。处理方式有两种:使用“try/catch”捕获异常,使用“throws”声明异常。

捕获异常

捕获异常是通过3个关键字来实现的:try-catch-finally。用try来执行一段程序,如果出现异常,系统抛出一个异常,可以通过它的类型来捕获(catch)并处理它,最后一步是通过finally语句为异常处理提供一个统一的出口,finally所指定的代码都要被执行(catch语句可以有多条;finally语句最多只能有一条,根据自己的需要可有可无)。

1
2
3
4
5
6
7
8
9
try{

}catch(Exception1 e){

}catch(Exception2 e){

}finally{ //无论是否发生异常,finally都会被执行

}

下面举一个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.x1aolin.b;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestException {
public static void main(String[] args) {
FileReader reader = null;
try {
reader = new FileReader("c:/a/b.txt"); //模拟文件不存在的情况
System.out.println("Step1");
char c1 = (char)reader.read();
System.out.println(c1);
//因为Exception是所有异常的父类,有的时候我们就直接用父类定义一个对象,当然这样的一场就太笼统了
}catch (FileNotFoundException e) {
System.out.println("Step2");
e.printStackTrace(); //打印异常信息

}catch(IOException e){ //一般子类异常在父类异常前面 这样可以打印更加准确的信息
e.printStackTrace();
}finally{
try {
System.out.println("Step3");
if(reader!=null){
reader.close(); //无论是否遇到异常,都应该将该对象进行关闭
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

这里模拟的是文件不存在的情况,也就是故意发生异常。

1
2
3
4
5
6
7
8
9
Step2
java.io.FileNotFoundException: c:\a\b.txt (系统找不到指定的文件。)
at java.io.FileInputStream.open0(Native Method)
at java.io.FileInputStream.open(Unknown Source)
at java.io.FileInputStream.<init>(Unknown Source)
at java.io.FileInputStream.<init>(Unknown Source)
at java.io.FileReader.<init>(Unknown Source)
at com.x1aolin.b.TestException.main(TestException.java:11)
Step3

声明异常throws

CheckedException产生时,不一定立刻处理它,可以再把异常throws出去。

在方法中使用try-catch-finally是由这个方法来处理异常。但是在一些情况下,当前方法并不需要处理发生的异常,而是向上传递给调用它的方法处理。

如果一个方法中可能产生某种异常,但是并不能确定如何处理这种异常,则应根据异常规范在方法的首部声明该方法可能抛出的异常。

如果一个方法抛出多个已检查异常,就必须在方法的首部列出所有的异常,之间以逗号隔开。

方法重写中声明异常原则:子类重写父类方法时,如果父类方法有声明异常,那么子类声明的异常范围不能超过父类声明的范围。

自定义异常

在程序中,可能会遇到JDK提供的任何标准异常类都无法充分描述清楚我们想要表达的问题,这种情况下可以创建自己的异常类,即自定义异常类。

自定义异常类只需从Exception类或者它的子类派生一个子类即可。

自定义异常类如果继承Exception类,则为受检查异常,必须对其进行处理;如果不想处理,可以让自定义异常类继承运行时异常RuntimeException类。

习惯上,自定义异常类应该包含2个构造器:一个是默认的构造器,另一个是带有详细信息的构造器。

泛型

泛型可以帮助我们建立类型安全的集合。泛型的本质就是”数据类型的参数化”。我们可以把”泛型“理解为数据类型的一个占位符(形式参数),即告诉编译器,在调用泛型的时候必须传入实际类型。

我们可以在类的声明处增加泛型列表,如:<T,E,V>。 此处,字符可以是任何标识符,一般采用这3个字母。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.x1aolin.a;

import java.util.List;

public class TestGeneric {
public static void main(String[] args) {
MyCollection<Integer> mc = new MyCollection<Integer>();//jdk1.7后,后面的<>内容可省略
// mc.set(0, "xxx");
mc.set(1, 111);

// System.out.println((String)mc.get(0));
System.out.println(mc.get(1));//加了泛型,直接返回Integer类型,不用强制转换;
mc.get(1);
List ls;
}
}
class MyCollection<E>{ // E:表示泛型;
//Object类是所有类的父类,所以这里可以使用 父类引用指向子类对象 这一技巧
private Object[] ob= new Object[8];
public void set(int index,E a){
ob[index] = a;
}
public E get(int index){
return (E)ob[index];
}
}

javaBean

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean,类必须是具体的和公共的,并且具有无参数的构造器

JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性,set和get方法获取。众所周知,属性名称符合这种模式,其他Java 类可以通过自省机制(反射机制)发现和操作这些JavaBean 的属性。

通俗一点来说,Java Bean 实际是就是一个普通的 Java Class,但是需要满足三个要求 1、所有属性为 private,只允许通过getter方法和setter方法访问对象的属性 2、必须具有一个无参的构造函数 3、实现serializable接口 。

您的每一份支持将鼓励我继续创作!
-------------本文结束感谢您的阅读-------------