一.Object类
1.Object类介绍(了解)
- java.lang.Object 注意:lang包中的类无需导包可以直接使用
- 类
Object
是类层次结构的根类(最顶层的类 祖宗类)。 - 每个类都使用
Object
作为超类。任何一个类都直接或者间接的继承了Object类 - 所有对象(包括数组)都实现这个Object类的方法。任何一个类都可以使用Object类中的方法
2.Object类的toString方法(重点)
import java.util.ArrayList;
import java.util.Random;
/*
Object类中的常用方法:
String toString() 返回该对象的字符串表示。
Object类toString方法的底层源码:
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
getClass().getName():使用反射技术获取类的全类名(包名+类名)
com.itheima.demo01toString.Person
"@" :字符串原样输出,分割的作用
hashCode():Object类中的方法,可以获取对象的哈希值,哈希值是一个系统随机给出的十进制的整数 123123123
Integer.toHexString(hashCode());把十进制的整数转换为十六进制 0-9 a-f
组合在一起: com.itheima.demo01toString.Person@AC123(对象在堆内存中的地址值)
*/
public class Demo01ToString {
public static void main(String[] args) {
/*
Person类默认继承了Object类,所以可以使用Object类中的toString方法
*/
Person p = new Person("aa",18);
String s = p.toString();
System.out.println(s);//com.itheima.demo01toString.Person@4554617c Person{name = 迪丽热巴 ,age = 18}
//直接打印对象的名字,就是调用对象的toString方法
System.out.println(p);//com.itheima.demo01toString.Person@4554617c Person{name = 迪丽热巴 ,age = 18}
/*
注意:
以后看一个类是否重写toString方法,打印名看看是否为地址值即可(默认调用toString方法)
是地址值:类没有重写toString方法
不是地址值:类重写了toString方法
*/
String str = new String("aaa");
System.out.println(str);//aaa 不是地址值String类重写了toString方法
Random r = new Random();
System.out.println(r);//java.util.Random@74a14482 是地址值,Random类没有重写toString方法
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
System.out.println(list);//[1, 2] 不是地址值,ArrayList集合重写toString方法
}
}
//ctrl+鼠标左键点击一个类名或者方法名,就可以进入到类|方法中
public class Person extends Object {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*
Obejct类中的toString方法,默认打印对象的地址值没有意义
需要重写toString方法,打印对象的属性值(成员变量)
*/
/*@Override
public String toString() {
return "Person{name = "+name+" ,age = "+age+"}";
}*/
//快捷键:alt+insert==>toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
3.Object类中的equals方法(重点)
import java.util.Random;
/*
Object类中的方法equals:
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
Object类中的equals方法的源码:
public boolean equals(Object obj) {
return (this == obj);
}
==:比较运算符
基本数据类型:比较的是值是否相等 10==20
引用数据类型(数组,集合,类Person):比较的是地址值是否相等 @1ac1==@223
*/
public class Demo01Equals {
public static void main(String[] args) {
Student s1 = new Student("aa",35);
Student s2 = new Student("式",22);
//使用Object类的toString方法,打印对象的地址值
System.out.println(s1.toString());//com.itheima.demo02equals.Student@4554617c
System.out.println(s2.toString());//com.itheima.demo02equals.Student@74a14482
//使用Object类的equals方法,比较两个对象的地址值是否相等
boolean b = s1.equals(s2);
System.out.println(b);//false
s1=s2;//把s2的地址值赋值给s1
System.out.println(s1);//com.itheima.demo02equals.Student@74a14482
System.out.println(s2);//com.itheima.demo02equals.Student@74a14482
boolean b2 = s1.equals(s2);
System.out.println(b2);//true
Student s3 = new Student("式",18);
Student s4 = new Student("工",18);
System.out.println(s3);//com.itheima.demo02equals.Student@1540e19d
System.out.println(s4);//com.itheima.demo02equals.Student@677327b6
Random r = new Random();
//boolean b3 = s3.equals(s4);
//boolean b3 = s3.equals(r);
//boolean b3 = s3.equals(null);
boolean b3 = s3.equals(s3);
System.out.println(b3);
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/*
比较两个对象的地址值没有意义,所以我们需要重写Object类的equals方法
比较两个对象的属性(name和age)
*/
@Override
public boolean equals(Object obj) {
/*
如果obj就是this本身,那么就没有比较在强转进行属性的比较,直接返回true,可以提高效率
*/
if(obj == this){
return true;
}
/*
如果obj的值是null,那么直接返回false,可以提高程序的效率
*/
if(obj==null){
return false;
}
/*
ClassCastException: java.util.Random cannot be cast to com.itheima.demo02equals.Student
为了防止类在转换异常,强转之前使用instanceof关键字进行判断
*/
if(obj instanceof Student){
/*
问题:多态==>无法使用子类特有的成员==>需要向下转型
Object obj = s2 = new Student("韦德",38);
*/
Student s = (Student)obj;
//比较this(s1)和s(obj=s2)两个对象的属性name和age
// 詹姆斯 韦德 35 38
boolean b = this.name.equals(s.name) && this.age == s.age;
return b;
}
//obj不是Student,直接返回false
return false;
}
//重点:快捷键 alt+insert 重写equals方法
/*@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
//getClass() != o.getClass() 使用反射技术判断对象的类型 相当于 obj instanceof Student
if (o == null || getClass() != o.getClass()) {
return false;
}
Student student = (Student) o;
if (this.age != student.age) {
return false;
}
return name != null ? this.name.equals(student.name) : student.name == null;
}*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
4.native本地方法
native修饰的方法:说明这个方法不是java语言编写的
调用的是其他语言编写的代码或者操作系统底层的代码,看不到具体的方法
Object:
public native int hashCode();
public final native Class<?> getClass();
5.Objects对象的工具类(了解)
import java.util.Objects;
/*
java.util.Objects类:操作对象的工具类,里边的方法都是静态的
Objects中的方法都是防止空指针异常的
注意:
工具类中的方法一般都是静态的,可以通过类名直接使用
Obejcts工具类中的equals方法
static boolean equals(Object a, Object b) :判断两个对象是否相等,相等返回true,不相等返回false
底层源码:
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
*/
public class Demo01Objects {
public static void main(String[] args) {
//String s1 = "aaa";
String s1 = null;
String s2 = "bbb";
//boolean b1 = s1.equals(s2);// s1=null null是不能调用方法的,会抛出空指针异常NullPointerException
boolean b1 = s1 != null ? s1.equals(s2) : s2 == null;
System.out.println(b1);
boolean b2 = Objects.equals(s1,s2);
System.out.println(b2); //(s1 == s2) || (s1 != null && s1.equals(s2))
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
二.Date类
1.毫秒值的概念和作用(了解)
java.util.Date类:用于描述日期和时间的类
类 Date 表示特定的瞬间,精确到毫秒。
1秒=1000毫秒
1 天 = 24 × 60 × 60 = 86400 秒 = 86400*1000 = 86400000毫秒
-----------------------------------------------
时间原点:0毫秒的时间点
1970 年 1 月 1 日 00:00:00 英国格林威治时间(世界标准时间)
中国:东八区 时间+8个小时的时差
1970 年 1 月 1 日 08:00:00
把日期和时间转换为毫秒值:就是时间原点和当前时间的一个差值
当前时间(2020年4月27日11:26:33)-时间原点(1970年1月1日 00:00:00)=把当前时间转换为毫秒值(12312412514312)
毫秒值的作用:用于对时间进行计算
工作:计算两个时间的差值,把时间转换为毫秒值计算
"2020年4月27日11:26:33" - "2019年3月5日12:26:33" = 没法计算
把时间转换为毫秒值,使用毫秒值相减
15888123123123 - 15734324324233 = 324324毫秒==>转换为时间(324324毫秒/1000/60/60/24)天
2.Date类的构造方法和成员方法(重点)
import java.util.Date;
/*
java.uti.Date类
构造方法:
Date() 重点
Date(long date) 参数传递毫秒值
成员方法:
long getTime() 重点
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
void setTime(long time)
设置此 Date 对象,以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
*/
public class Demo01Date {
public static void main(String[] args) {
show04();
}
/*
void setTime(long time) 参数传递毫秒值,把毫秒值转换为Date日期
设置此 Date 对象,以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
此方法相当于Date类的带参构造方法的作用
Date(long date) 参数传递毫秒值,把毫秒值转换为Date日期
*/
private static void show04() {
Date date = new Date();
System.out.println(date);//Mon Apr 27 11:43:53 CST 2020
date.setTime(0L);
System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
}
/*
long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
把当前日期转换为毫秒值(当前日期和时间原点之间共经历了多少毫秒)
*/
private static void show03() {
Date date = new Date();
System.out.println(date);//Mon Apr 27 11:42:35 CST 2020
long time = date.getTime();
System.out.println(time);//1587958955907
}
/*
Date类的带参数构造方法:
Date(long date) 参数传递毫秒值,把毫秒值转换为Date日期
注意:
在时间和日期相关的类中,long类型的值传递的就是毫秒值
*/
private static void show02() {
Date d1 = new Date(0L);
System.out.println(d1);//Thu Jan 01 08:00:00 CST 1970
Date d2 = new Date(31124324324234L);
System.out.println(d2);//Fri Apr 16 13:38:44 CST 2956
}
/*
Date类的空参数构造方法:
Date() 获取当前系统的时间和日期
CST:中国标准时间(北京)
*/
private static void show01() {
Date date = new Date();
System.out.println(date); //Mon Apr 27 11:37:07 CST 2020
}
}
三.DateFormat类
1.DateFormat类介绍(了解)
java.text.DateFormat类
public abstract class DateFormat extends Format
DateFormat 是日期/时间格式化子类的抽象类==> DateFormat是Format类的子类,DateFormat本身还是一个抽象类
无法直接创建对象使用
作用:
它以与语言无关的方式格式化并解析日期或时间。
格式化(也就是日期 -> 文本)
解析(文本-> 日期)
DateFormat类的成员方法:
String format(Date date) 传递指定的日期,把日期格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串解析为Date日期
-----------------------------------------------------------------
DateFormat本身还是一个抽象类,无法直接创建对象使用,需要使用DateFormat类的子类创建对象使用
java.text.SimpleDateFormat类 extends DateFormat类
SimpleDateFormat类构造方法
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
参数:
String pattern:传递日期和时间的模式
在模式中写y代表年
在模式中写M代表月
在模式中写d代表日
在模式中写H代表时
在模式中写m代表分
在模式中写s代表秒
在模式中写S代表毫秒
"yyyy-MM-dd HH:mm:ss" "2020-04-27 11:57:03"
"yyyy/MM/dd HH:mm:ss"
"yyyy年MM月dd日 HH时mm分ss"
注意:
1.表示模式的字母不能改变(y,M...),字母的连接符号可以改变(-,/...)
2.表示模式的字母严格区分大小写
2.DataFormat类的常用方法(重点)
import java.text.SimpleDateFormat;
import java.util.Date;
/*
使用DateFormat类中的常用方法
*/
public class Demo01DateFormat {
public static void main(String[] args) {
/*
String format(Date date) 传递指定的日期,把日期格式化为符合模式的字符串
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递执行的模式
2.调用SimpleDateFormat对象中的方法format把日期格式化为符合模式的字符串
*/
//SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");
Date date = new Date();
System.out.println(date);//Mon Apr 27 14:05:38 CST 2020
String s = sdf.format(date);
System.out.println(s);//2020-04-27 14:05:38 2020年04月27日 14时06分37
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo02DateFormat {
public static void main(String[] args) throws ParseException {
/*
Date parse(String source) 把符合模式的字符串解析为Date日期
实现步骤:
1.创建SimpleDateFormat对象,构造方法中传递执行的模式
2.调用SimpleDateFormat对象中的方法parse,把符合模式的字符串解析为Date日期
*/
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
/*
public Date parse(String source) throws ParseException
parse方法抛出了解析异常ParseException
当传递的字符串参数"2000-1-11"和构造方法中的模式"yyyy-MM-dd"不匹配的时候,就会抛出ParseException解析异常
调用了一个抛出异常的方法,有两种处理方式:
1.使用throws关键字继续把异常抛出给方法的调用者处理,最终抛出给JVM
2.使用try...catch自己手动的处理异常
快捷键: 把鼠标放在报异常的位置 alt+回车
*/
Date date = sdf.parse("2000-1-11");
System.out.println(date);
}
}
四.Calendar类
1.Calendar类介绍&创建对象的方式(重点)
import java.util.Calendar;
/*
java.util.Calendar类:日历类
我们可以使用Calendar类中的方法获取日历上的字段(年,月,日,时,分,秒...)
我们可以使用Calendar类中的方法修改日历上的字段的值 2020-->2030 4月-->6月
我们可以使用Calendar类中的方法把日历上字段的值增加|减少 2020-5=2015 4月+3月=7月
我们可以使用Calendar类中的方法把日历对象转换为Date日期对象
Calendar 类是一个抽象类,无法直接创建对象使用,在Calendar类中有一个静态方法叫getInstance
获取Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
注意:
西方的月份:0-11月
东方的月份:1-12月
西方的星期:星期日-星期六
东方的星期:星期一-星期日
*/
public class Demo01Calendar {
public static void main(String[] args) {
/*
多态
Calendar cal = null;
cal = new GregorianCalendar(zone, aLocale);
-------------------------------
Animal a = getAnimal(); new Cat() new Dog():
*/
//父类 = 子类对象
Calendar c = Calendar.getInstance();
System.out.println(c);
}
}
输出结果:
java.util.GregorianCalendar[time=1587968983189,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=3,WEEK_OF_YEAR=18,WEEK_OF_MONTH=5,DAY_OF_MONTH=27,DAY_OF_YEAR=118,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MINUTE=29,SECOND=43,MILLISECOND=189,ZONE_OFFSET=28800000,DST_OFFSET=0]
2.Calendar类中的常用成员方法(重点)
import java.util.Calendar;
import java.util.Date;
/*
Calendar类的常用方法
int get(int field) 获取给定日历字段的值。
void set(int field, int value) 将给定的日历字段设置为给定值。
void add(int field, int amount) 把日历字段增加|减少指定的值
Date getTime() 把日历转换为日期对象
注意:
以上方法的参数(int field),让我们传递指定的日历字段,这些日历字段在Calendar类中被定义为了常量
年:public final static int YEAR = 1;
月:public final static int MONTH = 2;
日:public final static int DATE = 5;
日:public final static int DAY_OF_MONTH = 5;
时:public final static int HOUR = 10;
分:public final static int MINUTE = 12;
秒:public final static int SECOND = 13;
毫秒:public final static int MILLISECOND = 14;
*/
public class Demo02Calendar {
public static void main(String[] args) {
show05();
}
/*
void setTime(Date date) 把Date日期转换为日历对象
*/
private static void show05() {
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DATE)+"日");//2020年3月27日
c.setTime(new Date(0L));
System.out.println(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DATE)+"日");//1970年0月1日
}
/*
Date getTime() 把日历转换为日期对象
*/
private static void show04() {
Calendar c = Calendar.getInstance();
Date date = c.getTime();
System.out.println(date);//Mon Apr 27 14:58:05 CST 2020
}
/*
void add(int field, int amount) 把日历字段增加|减少指定的值
参数:
int field:指定的日历字段
int amount:给字段增加|减少的值
传递正数:增加
传递负数:减少
*/
private static void show03() {
//获取Calendar对象
Calendar c = Calendar.getInstance();
//把年-5年
c.add(Calendar.YEAR,-5);
//把月份+3月
c.add(Calendar.MONTH,3);
//把日-10天
//c.add(Calendar.DATE,-10);//17号
c.add(Calendar.DATE,10);//8月6日
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year+"年");//2015年
//获取月
int month = c.get(Calendar.MONTH);
System.out.println((month+1)+"月");//7月
//获取日
int date = c.get(Calendar.DAY_OF_MONTH);
System.out.println(date+"日");//17日
}
/*
void set(int field, int value) 将给定的日历字段设置为给定值。
参数:
int field:指定的字段
int value:设置指定的值
同时设置年月日,建议使用以下方法
public final void set(int year, int month, int date)
*/
private static void show02() {
//获取Calendar对象
Calendar c = Calendar.getInstance();
//把年设置8888年
c.set(Calendar.YEAR,8888);
//把月份设置为8月
c.set(Calendar.MONTH,7);
//把日设置为8日
c.set(Calendar.DATE,8);
//同时设置年月日
c.set(9999,8,9);
//获取年
int year = c.get(Calendar.YEAR);
System.out.println(year+"年");
//获取月
int month = c.get(Calendar.MONTH);
System.out.println((month+1)+"月");
//获取日
int date = c.get(Calendar.DAY_OF_MONTH);
System.out.println(date+"日");
}
/*
int get(int field) 获取给定日历字段的值。
参数:
int field:传递指定的日历字段
*/
private static void show01() {
//获取Calendar对象
Calendar c = Calendar.getInstance();
//获取年
//int year = c.get(1);
int year = c.get(Calendar.YEAR);
System.out.println(year+"年");
//获取月
int month = c.get(Calendar.MONTH);
System.out.println((month+1)+"月");
//获取日
//int date = c.get(Calendar.DATE);
int date = c.get(Calendar.DAY_OF_MONTH);
System.out.println(date+"日");
}
}
五.Math类(重点)
/*
java.lang.Math类:数学工具类
Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。
Math类中的方法都是静态方法,通过类名.方法名(参数)可以直接使用
Math类中私有了构造方法,不让我们直接创建对象使用 private Math() {}
成员方法:
public static int abs(int a) 获取参数a的绝对值:
public static double ceil(double a) 向上取整 1.1 2.0 1.9 2.0
public static double floor(double a) 向下取整 1.1 1.0 1.99999 1.0
public static long round(double a) 四舍五入取整 5.5 6 5.49999 5
public static double pow(double a, double b) 获取a的b次幂 2^3 2^4
*/
public class Demo01Math {
public static void main(String[] args) {
//public static int abs(int a) 获取参数a的绝对值:
System.out.println(Math.abs(10));//10
System.out.println(Math.abs(-10));//10
System.out.println(Math.abs(0.1));//0.1
System.out.println(Math.abs(-0.1));//0.1
System.out.println("--------------------------------");
//public static double ceil(double a) 向上取整
System.out.println(Math.ceil(5.1));//6.0
System.out.println(Math.ceil(5.9));//6.0
System.out.println(Math.ceil(-5.1));//-5.0
System.out.println(Math.ceil(-5.9));//-5.0
System.out.println("--------------------------------");
//public static double floor(double a) 向下取整
System.out.println(Math.floor(5.1));//5.0
System.out.println(Math.floor(5.9));//5.0
System.out.println(Math.floor(-5.1));//-6.0
System.out.println(Math.floor(-5.9));//-6.0
System.out.println("---------------------------");
//public static long round(double a) 四舍五入取整
System.out.println(Math.round(5.5));//6
System.out.println(Math.round(5.499999999));//5
System.out.println("--------------------------");
//public static double pow(double a, double b) 获取a的b次幂
System.out.println(Math.pow(2.0,3.0));//8.0
System.out.println(Math.pow(2.0,-3.0));//0.125
System.out.println(Math.pow(-2.0,3.0));//-8.0
System.out.println(Math.pow(-2.0,-3.0));//-0.125
System.out.println("--------------------------");
/*
static double random() 获取一个随机的小数,该值大于等于 0.0 且小于 1.0。 [0.0,1.0)
0.6974873607317376
0.44954296961350837
0.07532574147331605
0.4034629488590904
0.7121695638217205
0.26027976396027486
0.6562874871560727
0.3795562141362999
0.7662793537891729
0.2813382012117768
*/
for (int i = 0; i < 10; i++) {
System.out.println(Math.random());
}
}
}
六.System类(重点)
import java.util.Date;
/*
java.lang.System类
System 类包含一些有用的类字段和方法。它不能被实例化(私有了构造方法)。
里边的方法都是静态的,通过类名.方法名(参数)可以直接使用
成员方法:
public static void exit(int status) 终止当前运行的 Java 虚拟机,非零表示异常终止
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组复制
*/
public class Demo01System {
public static void main(String[] args) {
show03();
}
/*
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组复制(了解)
参数:
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
需求:
把原数组[1,2,3,4,5]的前3个元素复制到目标数组中的前3个索引处[6,7,8,9,10]
复制前:目标数组[6,7,8,9,10]
复制后:目标数组[1,2,3,9,10]
*/
private static void show03() {
int[] src = {1,2,3,4,5};
int[] dest = {6,7,8,9,10};
System.out.println("复制前遍历数组目标数组dest");
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
//数组复制
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后遍历数组目标数组dest");
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
}
/*
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
返回的当前时间到1970 年 1 月 1 日00:00:00所经历的毫秒值
和new Date().getTime()是等价的
作用:
可以测试程序的效率
需求:
在控制台输出1-10000,计算这段代码执行了多少毫秒
*/
private static void show02() {
long s = System.currentTimeMillis();
//System.out.println(s);//1587973244384
for (int i = 1; i <=10000 ; i++) {
System.out.println(i);
}
long e = new Date().getTime();
//System.out.println(e);//1587973244386
System.out.println("程序执行共耗时:"+(e-s)+"毫秒值!");//程序执行共耗时:267毫秒值!
}
/*
public static void exit(int status) 终止当前运行的 Java 虚拟机,非零表示异常终止
参数:
int status:状体码 0:正常终止 非0:表示异常终止
*/
private static void show01() {
while (true){
System.out.println("我想有一个女同桌!");
//break;
System.exit(1);//终止JVM
}
//System.out.println("后续代码!");
}
}