目录
eclipse快捷键:
Ctrl+1 快速修复
Ctrl+D: 删除当前行
Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴
Alt+↑ 当前行和上面一行交互位置(同上)
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
Ctrl+M 最大化当前的Edit或View (再按则反之)
Ctrl+/ 注释当前行,再按则取消注释
Ctrl+O 快速显示 OutLine
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer
什么是类
类:是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。
类与对象的关系:
对象是具体的,真是存在的物种。
类是对象的抽象出来的,理论上的概念物种
类:
我说现在已经开始公布HUAWEI手机 P50的概念机,那就是说这款手机还没有实体机存在,只是官方还在设计这个手机。
其中包含:颜色、尺寸、分辨率等。以上说的是这款概念机中的属性、
另还包含:上网、打电话、发短信、拍照、看电视等。这是在说的是这款概念机所具有的功能,也就是行为! 对象: 我说现在已经开始公布HUAWEI手机 P30的实体机,那就是说这款手机已经存在实体机。
但是有这款手机之前,也一定会先有该机的设计图或是概念机。
接下来通过一幅图来认识一下成员和局部
重点
】 重点
】 重点
】 重点
】 重点
】 Java的数据类型划分为两大类:基础数据类型和引用数据类型
定义格式:
权限修饰符 构造方法名(参数列表){
// 方法体
}
构造方法的写法上,方法名与它所在的类名相同。它没有返回值,所以不需要返回值类型,甚至不需要void。
函数定义格式:
权限修饰符 [修饰符] 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
// 上方用方括号包括的修饰符可以有、也可以没有。
// 修饰符有抽象修饰符abstract、有静态修饰符static、也有线程同步锁方法 synchronized 等。
如何定义方法
首先要确定返回值类型和参数列表
调用方法的流程图解
函数重载
数据类型 | 默认值 | |
---|---|---|
基础数据类型 | 整型【byte,short,int,long】 | 0 |
浮点型【float,double】 | 0.0 | |
字符【char】 | '\u0000' | |
布尔【boolean】 | false | |
引用数据类型 | 数组、类、接口 | null |
我们发现 setXxx
方法中的形参名字并不符合见名知意的规定,那么如果修改与成员变量名一致,是否就见名知意 了呢?代码如下:
public class Student {
private String name;
private int age;
public void setName(String name) {
name = name;
}
public void setAge(int age) {
age = age;
}
}
经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了 setXxx()
的形参变量名后,方 法并没有给成员变量赋值!这是由于形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无 法访问到成员变量,从而赋值失败。所以,我们只能使用this
关键字,来解决这个重名问题。
this代表的是当前类对象。
概述
关于 static 关键字的使用,它可以用来修饰的成员变量和成员方法,被修饰的成员是属于类的,而不是单单是属 于某个对象的。
也就是说,既然属于类,就可以不靠创建对象来调用了。
静态成员变量:
当 static 修饰成员变量时,该变量称为类变量。
该类的每个对象都共享同一个类变量的值。
任何对象都可以更改 该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作。
静态成员变量初始化
静态成员只会在每个类中初始化一次 【静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次】
【Java笔试题】:构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是什么样的?
答:先后顺序是:静态成员变量、成员变量、构造方法。
原因:
a. 当类第一次被加载的时候,静态变量会首先初始化,接着编译器会把实例变量初始化为默认值,然后执行构造方法。
b. Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减):
① 静态对象(变量)优先于非静态对象(变量)初始化,其中,静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次;
② 父类优先于子类进行初始化;
③ 按照成员变量定义顺序进行初始化,即使变量定义散布于方法定义中,它们依然在任何方法(包括构造方法)被调用之前先初始化。
Java中的内存分配:
Java程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对数据进行了不同空间的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
具体划分为如下5个内存空间:
概述:
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要 继承那一个类即可。
如图所示:
其中,多个类可以称为子类,单独那一个类称为父类、超类(superclass)或者基类。 继承描述的是事物之间的所属关系,这种关系是: is-a 的关系。例如,图中兔子属于食草动物,食草动物属于动 物。可见,父类更通用,子类更具体。我们通过继承,可以使多种事物之间形成一种关系体系。
定义:
继承:就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。
子类可以直接 访问父类中的非私有的属性和行为。
好处:
1. 提高代码的复用性。
2. 类与类之间产生了关系,继承是多态的前提。
继承的格式:
通过 extends 关键字,可以声明一个子类继承另外一个父类,定义格式如下:
class 父类 {
...
}
class 子类 extends 父类 {
...
}
继承演示,代码如下:
/*
* 定义员工类Employee,做为父类
*/
class Employee {
String name; // 定义name属性
// 定义员工的工作方法
public void work() {
System.out.println("尽心尽力地工作");
}
}
/*
* 定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
// 定义一个打印name的方法
public void printName() {
System.out.println("name=" + name);
}
}
/*
* 定义测试类
*/
public class ExtendDemo01 {
public static void main(String[] args) {
// 创建一个讲师类对象
Teacher t = new Teacher();
// 为该员工类的name属性进行赋值
t.name = "小明";
// 调用该员工的printName()方法
t.printName(); // name = 小明
// 调用Teacher类继承来的work()方法
t.work(); // 尽心尽力地工作
}
}
当类之间产生了关系,其中各类中的构造方法,又产生了哪些影响呢?
首先我们要回忆两个事情,构造方法的定义格式和作用。
1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中,必须先执行父类的初始化动作。
子类的构造方法中默认有一个 super() ,表示调用父类的构造方法,父类成员变量初始化后,才可以给子类使用。
代码如下
class Aminal {
private int age;
Aminal() {
System.out.println(age);
}
}
class Dog extends Aminal {
// 不写 super(); Jvm 也会调用执行super();
Dog() {
System.out.println("wangcai");
}
}
public class TestExtendsDemo {
public static void main(String[] args) {
Dog dog = new Dog();
}
}
// 打印出结果是:0 wangcai
super :代表父类的存储空间标识(可以理解为父亲的引用)。
this : 代表当前对象的引用(谁调用就代表谁)。
instanceof关键字 1:用于判断某个对象是否是某种类型。 2:格式 对象名 instanceof 子类(实现)名
动态绑定(后期绑定)是指:在程序运行过程中,根据具体的实例对象才能具体确定是哪个方法。
java.lang.Object
类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是Object。
如果一个类没有特别指定父类, 那么默认则继承自Object类
根据JDK源代码及Object类的API文档,Object类当中包含的方法有11个。今天我们主要学习其中的2个:
public String toString()
:返回该对象的字符串表示。public boolean equals(Object obj)
:指示其他某个对象是否与此对象“相等”。toString方法
public String toString()
:返回该对象的字符串表示。
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
equals方法
public boolean equals(Object obj)
:指示其他某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否是相同的。
这里的“相同”有默认和自定义两种方式。
在Java中提供了四种访问权限,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限,
不同权限的访问范畴:
public | protected | default | private | |
---|---|---|---|---|
同一类中 | √ | √ | √ | √ |
同一包中(子类与无关类) | √ | √ | √ | |
不同包的子类 | √ | √ | ||
不同包中的无关类 | √ |
根据上表可知,public具有最大权限。private则是最小权限。
编写代码时,如果没有特殊的考虑,建议这样使用权限:
学习了继承后,我们知道,子类可以在父类的基础上改写父类内容,比如,方法重写。那么我们能不能随意的继承 API中提供的类,改写其内容呢?显然这是不合适的。为了避免这种随意改写的情况,Java提供了 final 关键字, 用于修饰不可改变内容。
使用方式:
final class 类名 {
}
通过查询API回发现像 public final class String 、 public final class Math 、 public final class Scanner 等,很多我们学习过的类,都是被final修饰的,目的就是供我们使用,而不让我们所以改变其内容
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,只有声明还有 意义,而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定,包含抽象方法 的类就是抽象类。
abstract使用格式:
使用 abstract 关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。
权限修饰符 abstract 返回值类型 方法名 (参数列表);
public abstract void playBall();
抽象类: 如果一个类包含抽象方法,那么该类必须是抽象类。
public abstract class Animal {
public abstract void run();
}
abstract注意:
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
public interface UserService {
public abstract void userLogin();
}
默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
public interface UserService {
public default void set() {
// 方法内容
}
}
静态方法:使用 static 修饰,供接口直接调用。
public interface UserService {
public static void get() {
// 方法内容
}
}
私有方法:使用 private 修饰,供接口中的默认方法或者静态方法调用。
public interface UserService {
public static void getById(Integer id) {
// 方法内容
}
}
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。
实现格式:
public class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}
接口特点:
什么是内部类
将一个类A定义在另一个类B里面,里面的那个类A就称为内部类,B则称为外部类。
成员内部类:
定义在类中方法外的类
定义格式:
class 外部类 {
class 内部类{
}
}
在描述事物时,若一个事物内部还包含其他事物,就可以使用内部类这种结构。比如,笔记本电脑类 Laptop 中包含主板 类 Mainboard,如此, MainBoard 就可以采用内部类形式来描述,定义在成员位置。
public class Laptop {
class MainBoard{
}
}
访问特点:
实例化内部类格式:
/*
实例化格式:
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
*/
public class Laptop {
class MainBoard{
}
}
class Demo{
Laptop.MainBoard lm = new Laptop().new MainBoard();
}
String类:
// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 66, 88, 108 };// 注意: 这里数字范围是 { -128 ~ 127,包括0}
String str3 = new String(bytes);
常用方法:
public class Demo {
public static void main(String[] args) {
// 创建字符串对象
String s1 = "hello";
String s2 = "hello";
String s3 = "HELLO";
// boolean equals(Object obj):比较字符串的内容是否相同
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
System.out.println(s1.equalsIgnoreCase(s2)); // true
System.out.println(s1.equalsIgnoreCase(s3)); // true
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
//boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true,如果没有则返回false。
System.out.println(s1.contains("-")); // false
System.out.println(s2.contains("l")); // true
System.out.println(s2.contains("he")) ;// true
System.out.println(s2.contains("hl")); // false
System.out.println(s3.contains(".")); // false
}
}
public class Demo {
public static void main(String[] args) {
//创建字符串对象
String s = "helloworld";
// int length():获取字符串的长度,其实也就是字符个数
System.out.println("字符串s的长度是:" + s.length());// 10
System.out.println("‐‐‐‐‐‐‐‐");
// String concat (String str):将将指定的字符串连接到该字符串的末尾.
String s1 = "helloworld";
String s2 = s1.concat("**Cheer HuaWei");
System.out.println(s2);// helloworld**Cheer HuaWei
// char charAt(int index):获取指定索引处的字符
System.out.println(s.charAt(0));
System.out.println(s.charAt(1));
System.out.println("‐‐‐‐‐‐‐‐");
// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
System.out.println(s1.indexOf("l"));
System.out.println(s1.indexOf("owo"));
System.out.println(s1.indexOf("ak"));
System.out.println("‐‐‐‐‐‐‐‐");
// int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索引,没有返回‐1
System.out.println(s1.indexOf("l"));
System.out.println(s1.indexOf("owo"));
System.out.println(s1.indexOf("ak"));
System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start):从start开始截取字符串到字符串结尾
System.out.println(s.substring(0));
System.out.println(s.substring(5));
System.out.println("‐‐‐‐‐‐‐‐");
// String substring(int start,int end):从start到end截取字符串。含start,不含end。
System.out.println(s.substring(0, s.length()));
System.out.println(s.substring(3,8));
}
}
}
public class Demo {
public static void main(String[] args) {
//创建字符串对象
String s = "abcde";
// char[] toCharArray():把字符串转换为字符数组
char[] chs = s.toCharArray();
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// byte[] getBytes ():把字符串转换为字节数组
byte[] bytes = s.getBytes();
for (int x = 0; x < bytes.length; x++) {
System.out.println(bytes[x]);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
// 替换字母huawei为大写HuaWei
String str = "Cheer huawei";
String replace = str.replace("huawei", "HuaWei");
System.out.println(replace); // Cheer HuaWei
System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
}
}
public class Demo {
public static void main(String[] args) {
//创建字符串对象
String s = "forward:index";
String[] strArray = s.split(":"); // ["forward","index"]
System.out.println(strArray.length);// 2
for(int x = 0; x < strArray.length; x++) {
System.out.print(strArray[x] + " "); // forward index
}
}
}
StringBuilder类
java.lang.StringBuilder
的API,StringBuilder又称为可变字符序列,它是一个类似于 String 的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。构造方法:
public StringBuilder()
:构造一个空的StringBuilder容器。public StringBuilder(String str)
:构造一个StringBuilder容器,并将字符串添加进去。public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder();
System.out.println(sb1); // (空白)
// 使用带参构造
StringBuilder sb2 = new StringBuilder("you");
System.out.println(sb2); // you
}
}
常用方法:
public StringBuilder append(...)
:添加任意类型数据的字符串形式,并返回当前对象自身。public String toString()
:将当前StringBuilder对象转换为String对象分别介绍两个方法:
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder builder = new StringBuilder();
//public StringBuilder append(任意类型)
StringBuilder builder2 = builder.append("hello");
//对比一下
System.out.println("builder:"+builder);
System.out.println("builder2:"+builder2);
System.out.println(builder == builder2); //true
// 可以添加 任何类型
builder.append("hello");
builder.append("world");
builder.append(true);
builder.append(100);
// 在我们开发中,会遇到调用一个方法后,返回一个对象的情况。然后使用返回的对象继续调用方法。
// 这种时候,我们就可以把代码现在一起,如append方法一样,代码如下
//链式编程
builder.append("hello").append("world").append(true).append(100);
System.out.println("builder:"+builder);
}
}
public class StringBuilderDemo {
public static void main(String[] args) {
// 链式创建
StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
// 调用方法
String str = sb.toString();
System.out.println(str); // HelloWorldJava
}
}
字符 | 描述 |
---|---|
\ | 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如,"n"匹配字符"n"。"\n"匹配换行符。序列"\\\\"匹配"\\","\\("匹配"("。 |
^ | 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性,^ 还会与"\n"或"\r"之后的位置匹配 |
$ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性,$ 还会与"\n"或"\r"之前的位置匹配 |
* | 零次或多次匹配前面的字符或子表达式。例如,zo* 匹配"z"和"zoo"。* 等效于 {0,} |
+ | 一次或多次匹配前面的字符或子表达式。例如,"zo+"与"zo"和"zoo"匹配,但与"z"不匹配。+ 等效于 {1,} |
? | 零次或一次匹配前面的字符或子表达式。例如,"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1} |
{n} | n 是非负整数。正好匹配 n 次。例如,"o{2}"与"Bob"中的"o"不匹配,但与"food"中的两个"o"匹配 |
{n,} | n是非负整数。至少匹配 n 次。例如,"o{2,}"不匹配"Bob"中的"o",而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o* |
{n,m} | m 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。例如,"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意:您不能将空格插入逗号和数字之间 |
? | 当此字符紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串,而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如,在字符串"oooo"中,"o+?"只匹配单个"o",而"o+"匹配所有"o" |
. | 匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符,请使用诸如"[\s\S]"之类的模式 |
x|y | 匹配 x 或 y。例如,'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food" |
[xyz] | 字符集。匹配包含的任一字符。例如,"[abc]"匹配"plain"中的"a" |
[^xyz] | 反向字符集。匹配未包含的任何字符。例如,"[^abc]"匹配"plain"中"p","l","i","n" |
[a-z] | 字符范围。匹配指定范围内的任何字符。例如,"[a-z]"匹配"a"到"z"范围内的任何小写字母 |
[^a-z] | 反向范围字符。匹配不在指定的范围内的任何字符。例如,"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符 |
\b | 匹配一个字边界,即字与空格间的位置。例如,"er\b"匹配"never"中的"er",但不匹配"verb"中的"er" |
\B | 非字边界匹配。"er\B"匹配"verb"中的"er",但不匹配"never"中的"er" |
\cx | 匹配 x 指示的控制字符。例如,\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样,则假定 c 就是"c"字符本身 |
\d | 数字字符匹配。等效于 [0-9] |
\D | 非数字字符匹配。等效于 [^0-9] |
\f | 换页符匹配。等效于 \x0c 和 \cL |
\n | 换行符匹配。等效于 \x0a 和 \cJ |
\r | 匹配一个回车符。等效于 \x0d 和 \cM |
\s | 匹配任何空白字符,包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效 |
\S | 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效 |
\t | 制表符匹配。与 \x09 和 \cI 等效 |
\v | 垂直制表符匹配。与 \x0b 和 \cK 等效 |
\w | 匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效 |
\W | 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效 |
\xn | 匹配 n,此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如,"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码 |
\num | 匹配 num,此处的 num 是一个正整数。到捕获匹配的反向引用。例如,"(.)\1"匹配两个连续的相同字符 |
\n | 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式,那么 n 是反向引用。否则,如果 n 是八进制数 (0-7),那么 n是八进制转义码 |
System类
java.lang.System
类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:
public static long currentTimeMillis()
:返回以毫秒为单位的当前时间。public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
:将数组中指定的数据拷贝到另一个数组中。currentTimeMillis方法
实际上,currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值
public class Demo {
public static void main(String[] args) throws ParseException {
//获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); // 1562038452052
}
}
public class Demo {
/*
需求: 验证for循环打印数字1-9999所需要使用的时间(毫秒)
*/
public static void main(String[] args) throws ParseException {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时毫秒:" + (end - start));
}
}
Runtime类
Date类
java.util.Date
类 表示特定的瞬间,精确到毫秒
继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把毫秒值转成日期对象。
public Date()
:分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。public Date(long date)
:分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。提醒:我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。
通俗来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。
例如
import java.util.Date;
/*
* 注意:
* 在使用println方法时,会自动调用Date类中的toString方法。
* Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串
*/
public class Demo {
public static void main(String[] args) {
// 创建日期对象,把当前的时间
System.out.println(new Date()); // Tue Jul 02 11:22:10 CST 2019
// 创建日期对象,把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
}
}
DateFormat类
java.text.DateFormat
是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
构造方法:
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat
。
这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
public SimpleDateFormat(String pattern)
:用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。 格式规则:
常用的格式规则为:
标识字母(区分大小写 ) | 文字描述含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
public class Demo {
public static void main(String[] args) {
// 对应的日期格式如:2019-07-02 11:28:29
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(format.format(new Date()));// 输出结果:2019-07-02 11:28:29
}
}
常用方法:
DateFormat类的常用方法有:
public String format(Date date)
:将Date对象格式化为字符串。public Date parse(String source)
:将字符串解析为Date对象。Math类
java.lang.Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。类似这样的工具 类,其所有方法均为静态方法,并且不会创建对象,调用起来非常简单。
基本运算的方法:
double d1 = Math.abs(‐2); //d1的值为2
double d2 = Math.abs(2); //d2的值为2
double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0
double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(‐3.3); //d2的值为‐4.0
double d3 = Math.floor(5.1); //d3的值为 5.0
long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0
Random类
此类的实例用于生成伪随机数。
Random r = new Random();
int randomNumber = r.nextInt();
使用Random类,完成生成5个20以内的随机整数的操作,代码如下:
//1. 导包
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Random random = new Random();
for (int i = 0; i < 5; i++) {
//3. 随机生成一个数据
int randomNumber = random.nextInt(20);
//4. 输出数据
System.out.println("randomNumber:" + randomNumber);
}
}
}