【笔记】Java基础教程学习（更新中）

Java基础语法

Hello World 代码

public class HelloWorld{
    public static void  main(String[] args){
        System.out.println("HelloWorld!");
    }
}

常量定义（编码规范要求为大写）：
final 数据类型 常量名 = 值;
如 final double PI = 3.14;

常量可以先声明再赋值，且只能赋值一次，而且必须要有赋值。

数据类型：

数据类型	默认值	存储格式	数据范围	包装类型
short	0	2个字节	-32,768 到 32,767	Short
int	0	4个字节	-2,147,483,648 到 2,147,483,647	Integer
byte	0	1个字节	-128 到 127	Byte
char	空	2个字节	Unicode 的字符范围：\u0000（即为 0）到 \uffff（即为 65,535）	Character
long	0L 或 0l	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807	Long
float	0.0F 或 0.0f	4 个字节	32 位 IEEEE-754 单精度范围	Float
double	0.0 或 0.0D(d)	8 个字节	64 位 IEEE-754 双精度范围	Double
boolean	false	1 位	true 或 false	Boolean

long 修饰的变量需要在数值后面加上 L 或者 l，比如 long num = 1L;，一般使用大写 L，为了避免小写 l 与数值 1 混淆。
float 类型的数值后面需要加上 F 或者 f，否则会被当成 double 类型处理。double 类型的数值可以加上 D 或 d，也可以不加。
char 类型需要将字符用单引号括起来char a = 'a'，char 可以和整数互相转换，如果字符 a 也可以写成char a = 97。也可以用十六进制表示char a = '\u0061'。
Java 中布尔值不能和整数类型或者其它类型互相转换。

字符串：
字符串是常量，它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。

方法：

// 两种定义方法
String s = "test";
String s = new String("test");
// 可调用的方法
length()
equals()
equalsIgnoreCase()  // 忽略大小写比较
==  // 比较内存地址
concat()  // 或者直接用 + 号
charAt()  // 按照索引值获得指定字符

使用 + 进行连接，不仅可以连接字符串，也可以连接其他类型。但是要求进行连接时至少有一个参与连接的内容是字符串类型。

其他方法总结如下：

方法	返回值	功能描述
indexOf(char ch)	int	搜索字符 ch 第一次出现的索引
indexOf(String value)	int	搜索字符串 value 第一次出现的索引
lastIndexOf(char ch)	int	搜索字符 ch 最后一次出现的索引
lastIndexOf(String value)	int	搜索字符串 value 最后一次出现的索引
substring(int index)	String	提取从位置索引开始到结束的字符串
substring(int beginindex, int endindex)	String	提取 beginindex 和 endindex 之间的字符串部分
trim()	String	返回一个前后不含任何空格的调用字符串的副本

运算符：

算术运算符：+，-，*，/，%，++，--

前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算。

位运算符：&, |, ^, ~, <<, >>, >>>（按位右移补0）

位运算时先转换为二进制，再按位运算。

逻辑运算符：&&(或&), ||(或|), !, ^

关系运算符：==, !=, >, <, >=, <=, ?:（三目运算符）

运算符优先级：

输入Scanner:

import java.util.Scanner;

public class Sum {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        System.out.println(a + b);
    }
}

关键字：

方法：

访问修饰符 返回值类型 方法名(参数列表) {
    方法体
}

访问修饰符：代表方法允许被访问的权限范围， 可以是 public、protected、private 或者省略（default）.

实参和形参的区别：

流程控制：if，else，switch, while, do-while, for,

如果 if（或 else if，或 else) 条件成立时的执行语句只有一条，是可以省略大括号的！

int days = 31;
if(days > 30)  // 注意没有冒号
    System.out.println("本月是大月");
else
    System.out.println("本月是小月");

StringBuilder:

以删除字符串中的空白符为例

import java.util.Scanner;

public class StringUtil {
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        //获取String值
        String a=in.nextLine();
        StringBuilder stringBuilder = new StringBuilder(a);
        for (int i = 0; i < stringBuilder.length(); i++) {
            if (stringBuilder.charAt(i)==' ') {
                stringBuilder.deleteCharAt(i);
                i--;
            }
        }
        System.out.println(stringBuilder.toString());
    }
}

跳转语句：break, continue,

数组：

int ages[];  // 声明，或者 int[] ages;
ages = new ages[10];  // 分配空间
int [] ages = {12,18,9,33,45,60};  // 声明并初始化

int [] a1 = {1,2,3};
int [] a2;
a2 = a1;  // 只是复制了一个引用

// for-each语法
for(元素类型 元素变量 : 遍历对象){
    执行的代码
}
// 比如：
for(int age:ages){
  System.out.println("数组中第"+i+"个元素是"+age);
  i++;
}

面向对象

Java中一切皆对象。对象包含属性和行为。

具有相同属性和行为的一类实体被称为类。

一个类可以包含以下的类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

定义和使用对象：

类名 对象名 = new 类名();

//引用对象属性
对象名.属性

//引用对象方法
对象名.方法

定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法（默认构造方法是一个无参构造方法）。
构造方法的名称必须与类名相同，一个类可以定义多个构造方法。
构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。

创建对象实例时，object只是一个对象引用。

Object object=new Object();

静态成员与静态方法：
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
被 static 修饰的方法是静态方法，静态方法不依赖于对象，不需要将类实例化便可以调用，由于不实例化也可以调用，所以不能有 this，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

final:

final 修饰类，则该类不允许被继承，为最终类
final 修饰方法，则该方法不允许被覆盖（重写）
final 修饰属性：该属性一经初始化便不可改变（基本类型值不可变，对象属性引用不可变），初始化方式（二选一）：定义处，或者构造函数里
final 修饰变量，则该变量的值只能赋一次值，即常量

权限修饰符：

封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。

修改属性的可见性，在属性的前面添加修饰符 (private)
对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
在 getter/setter 方法里加入属性的控制语句，例如我们可以加一个判断语句，对于非法输入给予否定

this 关键字代表当前对象。使用 this.属性 操作当前对象的属性，this.方法 调用当前对象的方法。

继承：is-a关系

class 子类 extends 父类

子类会拥有父类除了private之外的所有方法和属性。

子类拥有父类除 private 以外的所有属性和方法。
子类可以拥有自己的属性和方法。
子类可以重写实现父类的方法。
Java 中的继承是单继承，一个类只有一个父类。

Java 实现多继承的一个办法是 implements（实现）接口，但接口不能有非静态的属性，这一点请注意。

super可以调用父类的属性和方法。
子类构造方法需要调用父类的构造方法时，在子类的构造方法体里最前面的位置：super()。

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

方法中的参数列表必须不同。比如：参数个数不同或者参数类型不同。
重载的方法中允许抛出不同的异常
可以有不同的返回值类型，但是参数列表必须不同。
可以有不同的访问修饰符。

方法重写一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。

多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
多态也称作动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

实现多态的三个条件：继承、重写和向上转型（即父类引用指向子类对象）。

Java中多态的实现方式：继承父类进行方法重写，抽象类和抽象方法，接口实现。

Animal b = new Dog(); //b是父类的引用指向的是子类的对象

由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。

不能使用一个子类的引用去指向父类的对象，因为子类对象中可能会含有父类对象中所没有的属性和方法。
如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能。但是对于只存在于子类的方法和属性就不能获取。

class Animal {
    //父类方法
    public void bark() {
        System.out.println("动物叫！");
    }
}

class Dog extends Animal {

    //子类重写父类的bark方法
    public void bark() {
        System.out.println("汪、汪、汪！");
    }
    //子类自己的方法
    public void dogType() {
        System.out.println("这是什么品种的狗？");
    }
}


public class Test {

    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Dog();
        Dog d = new Dog();

        a.bark();
        b.bark();
        //b.dogType();
        //b.dogType()编译不通过
        d.bark();
        d.dogType();
    }

}

因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写（方法名，参数都相同）。

抽象类：

用 abstract 修饰符定义抽象类。
用 abstract 修饰符定义抽象方法，只用声明，不需要实现。
包含抽象方法的类就是抽象类。
抽象类中可以包含普通的方法，也可以没有抽象方法。
抽象类的对象不能直接创建，通常是定义引用变量指向子类对象。

抽象类是限制规定子类必须实现某些方法，但不关注实现细节。抽象类作为子类的模板，从而避免了子类设计的随意性。

子类实现方法前要加 @Override。

接口：

接口不能用于实例化对象。
接口中方法只能是抽象方法、default 方法、静态方法。
接口成员是 static final 类型。
接口支持多继承。

// Animal.java
interface Animal {
        //int x;
        //编译错误,x需要初始化，因为是 static final 类型
        int y = 5;
        public void eat();
        public void travel();
}

接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

修饰符 interface A extends 接口1，接口2{

}

修饰符 class A implements 接口1，接口2{

}

内部类：

将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。
内部类的方法可以直接访问外部类的所有数据，包括私有的数据（反之不行）。
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
内部类允许继承多个非接口类型。

创建内部类对象： 内部类 对象名 = 外部类对象.new 内部类();

注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。
所以内部类的成员变量 / 方法名可以和外部类的相同。

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + name);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象，对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符。

如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如上述代码中：a.this。

成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类：

静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问。new People().name。
如果外部类的静态成员与内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过 成员名 直接调用外部类的静态成员。
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名 = new 内部类();。

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX";

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name：" + (new People().name));
            System.out.println("访问外部类中的ID：" + People.ID);
            System.out.println("访问内部类中的ID：" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象，对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

局部内部类，是指内部类定义在方法和作用域内。

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

// People.java
//外部类People
public class People {
    //定义在外部类中的方法内：
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex：" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内：===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内：===========");
        b.peopleInfo2(true);
    }
}

匿名内部类：

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

// Outer.java
public class Outer {

    public Inner getInner(final String name, String city) {
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "NewYork");
        System.out.println(inner.getName());
    }
}
interface Inner {
    String getName();
}

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的, 如果不先定义，编译时会报错该类找不到。

同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为 final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。

然而，因为匿名内部类没名字，是用默认的构造方法的，无参数的，如果需要该类有带参数的构造方法，示例如下：

public Inner getInner(final String name, String city) {
  return new Inner(name, city) {
    private String nameStr = name;

    public String getName() {
      return nameStr;
    }
  };
}

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造方法所使用，所以不必定义为 final。

package命名空间：

把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

包的命名规范是全小写字母拼写。

Java常用类

Arrays：

import java.util.Arrays;

方法	描述
List asList(T... a)	返回由指定数组构造的 List
void sort(Object[] a)	对数组进行排序
void fill(Object[] a, Object val)	为数组的所有元素都赋上相同的值
boolean equals(Object[] a, Object[] a2)	检查两个数组是否相等
int binarySearch(Object[] a, Object key)	对排序后的数组使用二分法查找数据

import java.util.Arrays;
import java.util.Random;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = new int[10];
        //将数组元素都设为9
        Arrays.fill(arr, 9);
        System.out.println("fill:" + Arrays.toString(arr));
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            //使用100以内的随机数赋值数组
            arr[i] = random.nextInt(101);
        }
        //重新赋值后的数组
        System.out.println("重新赋值：" + Arrays.toString(arr));
        //将索引为5的元素设为50
        arr[5] = 50;
        //排序
        Arrays.sort(arr);
        //排序后的数组
        System.out.println("sort排序后：" + Arrays.toString(arr));
        //查找50的位置
        int i = Arrays.binarySearch(arr, 50);
        System.out.println("值为50的元素索引："+i);
        //复制一份新数组
        int[] newArr = Arrays.copyOf(arr, arr.length);
        //比较
        System.out.println("equals:"+Arrays.equals(arr, newArr));
    }
}

StringBuilder:

StringBuilder 类是可变的。

构造方法	说明
StringBuilder()	构造一个其中不带字符的 StringBuilder，其初始容量为 16 个字符
StringBuilder(CharSequence seq)	构造一个 StringBuilder，它包含与指定的 CharSequence 相同的字符
StringBuilder(int capacity)	构造一个具有指定初始容量的 StringBuilder
StringBuilder(String str)	并将其内容初始化为指定的字符串内容

方法	返回值	功能描述
insert(int offsetm,Object obj)	StringBuilder	在 offsetm 的位置插入字符串 obj
append(Object obj)	StringBuilder	在字符串末尾追加字符串 obj
length()	int	确定 StringBuilder 对象的长度
setCharAt(int index,char ch)	void	使用 ch 指定的新值设置 index 指定的位置上的字符
toString()	String	转换为字符串形式
reverse()	StringBuilder	反转字符串
delete(int start, int end)	StringBuilder	删除调用对象中从 start 位置开始直到 end 指定的索引（end-1）位置的字符序列
replace(int start, int end, String str)	StringBuilder	使用一组字符替换另一组字符。将用替换字符串从 start 指定的位置开始替换，直到 end 指定的位置结束

Calendar:

Date 类附有两大功能：
允许用年、月、日、时、分、秒来解释日期。
允许对表示日期的字符串进行格式化和句法分析。

类 Calendar 来完成第一种功能，类 DateFormat 来完成第二项功能。
DateFormat 是 java.text 包中的一个类。与 Date 类有所不同的是，DateFormat 类可以接受用各种语言和不同习惯表示的日期字符串。

Calendar 类是一个抽象类，我们更多的是使用 Calendar 类的子类 GregorianCalendar 类。

构造方法	说明
GregorianCalendar()	创建的对象中的相关值被设置成指定时区，缺省地点的当前时间，即程序运行时所处的时区、地点的当前时间
GregorianCalendar(TimeZone zone)	创建的对象中的相关值被设置成指定时区 zone，缺省地点的当前时间
GregorianCalendar(Locale aLocale)	创建的对象中的相关值被设置成缺省时区，指定地点 aLocale 的当前时间
GregorianCalendar(TimeZone zone,Locale aLocale)	创建的对象中的相关值被设置成指定时区，指定地点的当前时间

TimeZone 是 java.util 包中的一个类，其中封装了有关时区的信息。每一个时区对应一组 ID。类 TimeZone 提供了一些方法完成时区与对应 ID 两者之间的转换。

//太平洋时区的 ID 为 PST
TimeZone tz0 = TimeZone.getTimeZone("PST")
//getDefault()可以获取主机所处时区的对象
TimeZone tz1 = TimeZone.getDefault()

Locale 只是一种机制，它用来标识一个特定的地理、政治或文化区域获取一个 Locale 对象的构造方法：

//调用Locale类的构造方法
Locale l0 = new Locale(String language)
Locale l1 = new Locale(String language, String country)
Locale l2 = new Locale(String languge, String country, String variant)

//调用Locale类中定义的常量
Locale  l1 = Locale.CHINA

示例：

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

public class CalendarDemo {
    public static void main(String[] args) {
        System.out.println("完整显示日期时间：");
        // 字符串转换日期格式
        DateFormat fdate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = fdate.format(new Date());
        System.out.println(str);

        // 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        // 初始化 Calendar 对象，但并不必要，除非需要重置时间
        calendar.setTime(new Date());

        // 显示年份
        System.out.println("年： " + calendar.get(Calendar.YEAR));

        // 显示月份 (从0开始, 实际显示要加一)
        System.out.println("月： " + calendar.get(Calendar.MONTH));


        // 当前分钟数
        System.out.println("分钟： " + calendar.get(Calendar.MINUTE));

        // 今年的第 N 天
        System.out.println("今年的第 " + calendar.get(Calendar.DAY_OF_YEAR) + "天");

        // 本月第 N 天
        System.out.println("本月的第 " + calendar.get(Calendar.DAY_OF_MONTH) + "天");

        // 3小时以后
        calendar.add(Calendar.HOUR_OF_DAY, 3);
        System.out.println("三小时以后的时间： " + calendar.getTime());
        // 格式化显示
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 重置 Calendar 显示当前时间
        calendar.setTime(new Date());
        str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime());
        System.out.println(str);

        // 创建一个 Calendar 用于比较时间
        Calendar calendarNew = Calendar.getInstance();

        // 设定为 5 小时以前，后者大，显示 -1
        calendarNew.add(Calendar.HOUR, -5);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 设定7小时以后，前者大，显示 1
        calendarNew.add(Calendar.HOUR, +7);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // 退回 2 小时，时间相同，显示0
        calendarNew.add(Calendar.HOUR, -2);
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));

        // calendarNew创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendarNew.getTime()));
        // calendar创建时间点
        System.out.println((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()));
        System.out.println("时间比较：" + calendarNew.compareTo(calendar));
    }
}

Date:

Date 类经常用来获取系统当前时间。

构造方法	说明
Date()	构造一个 Date 对象并对其进行初始化以反映当前时间
Date(long date)	构造一个 Date 对象，并根据相对于 GMT 1970 年 1 月 1 日 00:00:00 的毫秒数对其进行初始化

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

public class DateDemo {
    public static void main(String[] args) {
        String strDate, strTime;
        Date objDate = new Date();
        System.out.println("今天的日期是：" + objDate);
        long time = objDate.getTime();
        System.out.println("自1970年1月1日起以毫秒为单位的时间（GMT）：" + time);
        strDate = objDate.toString();
        //提取 GMT 时间
        strTime = strDate.substring(11, (strDate.length() - 4));
        //按小时、分钟和秒提取时间
        strTime = "时间：" + strTime.substring(0, 8);
        System.out.println(strTime);
        //格式化时间
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(formatter.format(objDate));
    }
}

Math:

Math 类在 java.lang 包中，常用方法如下：

方法	返回值	功能描述
sin(double numvalue)	double	计算角 numvalue 的正弦值
cos(double numvalue)	double	计算角 numvalue 的余弦值
acos(double numvalue)	double	计算 numvalue 的反余弦
asin(double numvalue)	double	计算 numvalue 的反正弦
atan(double numvalue)	double	计算 numvalue 的反正切
pow(double a, double b)	double	计算 a 的 b 次方
sqrt(double numvalue)	double	计算给定值的正平方根
abs(int numvalue)	int	计算 int 类型值 numvalue 的绝对值，也接收 long、float 和 double 类型的参数
ceil(double numvalue)	double	返回大于等于 numvalue 的最小整数值
floor(double numvalue)	double	返回小于等于 numvalue 的最大整数值
max(int a, int b)	int	返回 int 型 a 和 b 中的较大值，也接收 long、float 和 double 类型的参数
min(int a, int b)	int	返回 a 和 b 中的较小值，也可接受 long、float 和 double 类型的参数
rint(double numvalue)	double	返回最接近 numvalue 的整数值
round(T arg)	arg 为 double 时返回 long，为 float 时返回 int	返回最接近 arg 的整数值
random()	double	返回带正号的 double 值，该值大于等于 0.0 且小于 1.0