Java课程笔记

Basics

---

数据类型

基本数据类型
byte short int long
float double
char
boolean
class
interface
Array

运算符

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

赋值运算符
= += -= *= /= %=

比较运算符
> < >= <= == !=

逻辑运算符
&& || ! ^

条件运算符
(bool_condition_expression ? expression1 : expression2)

条件语句

if(condition){
//....
}else if{
//.....
}else{
//...
}

switch(expression){
case value1:
    ...
    break;
case value2:
    .....
    break;
default:
    ....
}

循环语句

for (int i=1; i<=3; i++){
//函数体
}

//do-while 先循环后判断 
do{
//....
} while(condition);

//while 先判断，后循环 
while(condition){
//.....
}

break   //跳出循环
continue    //立即跳到下一次循环

Methods(Functions)

访问修饰符 [static] 返回值类型 方法名(形参表) {
方法体
}

Arrays

---

声明数组

数据类型 数组名[ ];
数据类型[ ] 数组名;
String[] names;
int a[];
double b[8];

分配空间

数组名 = new  数据类型 [ 数组长度 ];
a=new int[8];
int[] a={1,2,3,4,5,6,7,8};
int[] c=new int[]{33,44,55,66,2223};

赋值

name[i]=xxx;

class java.util.Array

Arrays.sort()
Arrays.toString()

foreach

for (元素类型 元素变量:便利对象){ .....}
for (int a:input_array){System.out.println(a);}

多维数组

int[][] matrix= new int[2][5];
int[][] matrix2={{1,2,3,4,5},{4,5,6,7,8}};
int[] a={1,3,4,5,6,7};
int c=a.length;    //c=6

Package

---

包名全部小写

package package_name;  //放在程序第一行
import package_name.* ;    //导入包

Class & Object

---

public class ABC {
//properties

    int a;
//methods

    public void method1(int parm) {
//......
    }
}

public class ABC {

    //properties

    static int object_count;

    public ABC() {
        ABC.object_count++;
    }

    public void print() {
        System.out.println(ABC.object_count);
    }
}

public class Class_practice {
//properties 

    int abc;
    static int xyz; //静态变量
    boolean hahaha;
//普通初始化块

    {
        abc = 33;
        hahaha = true;
    }
//静态初始化块

    static {
        xyz = 233;
    }
//Constructors

    public Class_practice() {
//无参构造方法
    }

    public Class_practice(int input, float mem) {
//有参数的构造方法
    }
}

创建对象

ABC aa=new ABC();

使用对象

System.out.println(ABC.a);
ABC.method1(233);

成员变量

定义在class,可以被所有本类中的方法调用。成员变量会有初始值。

局部变量

定义在方法中，只能在该方法中调用。局部变量没有初始值。

静态变量

所有该类的实现对象都可以使用的共享的成员变量，用static修饰。

静态方法

public static void xyz(){//.......}
静态方法中可以调用静态成员变量，但是不能调用非静态成员变量。

构造方法(Constructor)

无返回值，方法名与class名相同。
如果没有任何Constructor，会自动生成一个无参数的构造方法。

普通初始化块

在每次类实例化/对象初始化时执行

静态初始化块

只在类加载时执行一次
只能初始化静态变量

public class ABC {
//properties

    int a;
//methods

    public void method1(int parm) {
//......
    }
}

public class ABC {

    //properties

    static int object_count;

    public ABC() {
        ABC.object_count++;
    }

    public void print() {
        System.out.println(ABC.object_count);
    }
}

public class Class_practice {
//properties 

    int abc;
    static int xyz; //静态变量
    boolean hahaha;
//普通初始化块

    {
        abc = 33;
        hahaha = true;
    }
//静态初始化块

    static {
        xyz = 233;
    }
//Constructors

    public Class_practice() {
//无参构造方法
    }

    public Class_practice(int input, float mem) {
//有参数的构造方法
    }
}

执行顺序： 类加载->静态初始化块执行->类实例化->普通初始化块执行->构造函数执行

封装

---

private修饰符
setter/getter，过滤数据，隐藏细节

访问修饰副 public/private/protected

本类	同包	子类	其他
private	*	-	-
默认	*	*	同包的子类可以访问
protected	*	*	*
public	*	*	*

*代表可以访问的范围
属性一般用private
方法一般用public

this关键字

一般在setter()中使用。

内部类（类里面再声明一个类）

???有什么作用呢???
1.不允许同一个包中的其他类访问内部类 (???用private修饰不就好了么??? !!!不对，这个限制是针对其他内部类的，而private是针对类外面的东西，比如其他外部类的。!!!)
2.内部类可以直接访问外部类的数据包括私有数据
3.内部类实现的功能用外部类一样可以实现，只是有时候用内部类更方便(???为啥。。。啥时候更方便???)

成员内部类

• 普通内部类

  1. Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等
  2. Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a
  3. 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );
  4. 编译上面的程序后，会发现产生了两个 .class 文件

     Outer.java
     Outer$Inner.java

     其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

  5. 在内部类中引用外部类的成员或者方法时需使用Outer.this.xxxx()，必须使用this关键字。(为什么一定要使用this呢？因为只要外部类的成员或者方法不是静态的（static），那就一定会有对象，有对象就要使用this来指代当前对象，当然如果是静态的就不需要this关键字了)

• 静态内部类

  1. 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
  2. 如果外部类的静态成员与内部类的成员名称相同，可通类名.静态成访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员
  3. 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类名 对象名= new 内部类(); 或者可以这样外部类名.内部类名 对象名 = new 外部类名.内部类名(),注意，在使用第二种方法的时候实际上也没有创建外部类，只是创建了静态内部类。

  为什么静态内部类不能访问外部类的普通成员呢？

  • 在创建普通内部类的实例时候，连带外部类实例一起创建了，所以有了外部类的普通成员。
  • 而在创建静态内部类实例的时候，不需要创建外部类的实例，所以外部类的普通成员自然也就不存在，所以无法访问。只能访问那些不需要实例也可以访问的静态成员。
  • 静态内部类可以通过 new 外部类().成员 的方式访问外部类的普通成员，其本质就是创建了一个外部类的实例来访问其成员。
  • this关键字应该指代的是当前实例，但是静态内部类创建实例的时候没有创建外部类的实例，自然也就没办法用外部类名.this.xxx()访问外部类非静态成员或者方法。

  思考：静态内部类和子类的区别(子类能实现静态内部类的功能么？）
  *子类的创建必须先创建父类，但是静态内部类可以独立创建，不需要先创建外部类。

方法内部类

方法内部类就是在方法内部定义的类，只能在方法内部使用。
由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
方法内部类不能添加访问修饰符!!! No public/private/protected!!!

public class Class_inner_class_practice {

    //外部类的私有属性name
    private String name = "imooc";
    private String s1 = "This is non-static private string of outer class";
    private static String s2 = "This is static private string of outer class";
    //外部类的成员属性
    int age = 20;

    //成员内部类Inner
    public class Inner {

        String name = "爱慕课";

        //内部类中的方法
        public void show() {
            System.out.println("Inner_class访问外部类中的name：" + Class_inner_class_practice.this.name);//Must include keyword this because name is not a static member
            System.out.println("Inner_class访问外部类中的s2：" + Class_inner_class_practice.s2);//Used without keyword this because s2 is a static string/member, pay attention that s2 is a !!!private!!! string of outer class
            System.out.println("Inner_class访问内部类中的name：" + name);
            System.out.println("Inner_class访问外部类中的age：" + age);
            System.out.println("Inner_class:" + toString());
            System.out.println("Inner_class:" + super.toString());
        }
    }

    //静态内部类Static_Inner
    public static class Static_Inner {

        public String static_inner_s1 = "This is a public string in the public static class Static_Inner";

        public void test() {
            System.out.println("Static_Inner_class:" + static_inner_s1);
            System.out.println("Static_Inner_class:" + Class_inner_class_practice.s2);  //Static_Inner can access static members of outer class 
            // System.out.println("Static_Inner_class:"+Class_inner_class_practice.s1);   //this will result in compile error as s1 is not static
            System.out.println("Static_Inner_class:" + new Class_inner_class_practice().s1);    //static inner class can access the non-static members of outer class once the outer class is initialized
            System.out.println("Static_Inner_class:" + toString());
            System.out.println("Static_Inner_class:" + new Class_inner_class_practice().toString());//Could tell that the result of toString() is different from the Static_class
        }
    }

    //测试方法内部类的外部类方法 
    public void test_method_inner() {
        String method_s1 = "This is string within method test_method_inner";
        class Method_Inner {

            public void test() {
                System.out.println("Method_inner_class:" + "This is output from class Method_Inner within method test_method_inner of the outer class");
                System.out.println("Method_inner_class:" + method_s1);  //Method_Inner class can access variables defined in outer method
                System.out.println("Method_inner_class:" + Class_inner_class_practice.this.s1); //Method_Inner class can access member of outer class
                //System.out.println("test_method_inner:"+Class_inner_class_practice.Static_Inner.static_inner_s1); //This will also result in error, class inside a method cannot access the static inner class of the outer class
                //test_method_inner();  //The Method_Inner class can even invoke the method that contains itself, but we comment this because it will result in endless loop...well, ended in error at last.
                System.out.println("Method_inner_class:"+ toString());
            }
        }
        Method_Inner method_inner_object = new Method_Inner();
        method_inner_object.test();
    }

    public void show() {
        System.out.println("Outer_class:" + toString());
    }

    //测试成员内部类

    public static void main(String[] args) {

        //创建外部类的对象
        Class_inner_class_practice o = new Class_inner_class_practice();
        //创建内部类的对象
        Inner inn = o.new Inner();
        //Class_inner_class_practice.Inner inn=new Class_inner_class_practice.Inner();//This will not work as non-static inner calls need an Instance of outer class to work

        //调用外部类对象的show方法
        o.show();
        //调用内部类对象的show方法
        inn.show();
        //可以看出Outer_class与Inner_class的toString()输出是不同的。
        System.out.println(inn.equals(o));

        //创建静态类对象 
        //Class_inner_class_practice.Static_Inner static_inn = new Class_inner_class_practice.Static_Inner();   //you can use this or directly define static_inner_class
        Static_Inner static_inn = new Static_Inner();
        static_inn.test();
        System.out.println(static_inn.equals(o));

        //测试方法内部类对象
        o.test_method_inner();

    }
}

继承

---

子类

Java是单继承的
private 修饰的属性和方法是不能继承的

class 子类 extends 父类

方法重载重写(Override)

子类可以重载重写父类的方法，子类重载重写父类方法时 返回值 方法名 形参表 都必须与父类中的方法一样。

继承时初始化顺序

• 先初始化父类再初始化子类
• 类的初始化遵循顺序: 类加载->静态初始化块执行->类实例化->普通初始化块执行->构造函数执行
• 子类的构造函数如果没有显示调用父类构造方法，则隐式执行父类的无参构造方法; 如果子类构造函数调用了父类的构造方法，则必须写在子类构造方法的第一行，以super(type parm);的形式，不会再隐式执行父类的构造方法。
  注意： 子类未显示调用父类的构造方法，而父类又没有无参数的构造方法(定义了一个有参数的构造方法时系统就不会生成默认的无参构造方法）时将会报错
  注意： 重载(Overload)和重写是两种不同的概念。重载(Overload)指的是相同方法名但是参数个数或者类型不同；重写(Override)指的是子类中的重写一个和父类中方法名，返回值，参数类型和个数都相同但是实现不同的方法，用来覆盖原来父类中的同名方法 要是看英文原著应该就不会出现这种错误了。。。翻成中文之后反而容易忽略这区别。。。
  感谢@DHChan指出错误
  

final关键字

• 修饰类： 此类不可被继承
• 修饰方法： 此方法不可被覆盖/重载重写
• 修饰属性： 该类属性不会隐式初始化,必须在初始化块或者构造方法中初始化
• 修饰变量： 该变量只能赋值一次,在声明时赋值(即该变量是常量)

super关键字

• 代表父类对象
• ???多层继承之后super指代顶层对象???

Object类

• Object类是Java中所有类的父类。
• toString()
• equals() 用于比较对象的引用指向的是否是同一个对象
• Object类中的方法可以被重载重写

多态

---

引用多态

• 父类的引用不但可以指向父类的对象，还可以指向子类的对象

方法多态

• 引用指向创建的父类本类对象时，调用父类对象的方法
• 引用指向创建的子类对象时，调用的是子类对象重载重写后的方法（如果子类重载重写了该方法的话）

引用类型转换

• 向上类型转换（隐式/自动转换），从小类型向大类型（子类向父类）。注意转换之后调用的方法仍是子类方法
• 向下类型转换（强制类型转换），从父类型向子类型
• instanceof 运算符: obj1 instanceof obj2

抽象类

• abstract 关键字修饰
• 抽象方法只包含方法，不包含实现
• 抽象类可以包含抽象方法，也可以包含普通方法； 也可以不包含抽象方法
• 抽象类不能直接创建

接口

• 接口内部全部都是常量和公共的抽象方法
• 规定某些类必须实现某些方法
• 接口可以多继承（跟类不一样）
• 接口可以通过匿名内部类来实现,不一定要新建一个类

//定义接口,修饰符常用public, abstract可以省略
[修饰符] [abstract] interface 接口名 [extends 父接口1，父接口2,父接口3...]{
public static final 常量定义;
public abstract 抽象方法定义;
}

//实现接口
[修饰符] class 类名 extends 父类 implements 接口1，接口2，接口3...{
......
}

//匿名内部类实现接口方法1  (???这跟内部类有什么关系???)
// * 注意接口名后面有() *
接口名 匿名内部类名 = new 接口名(){
    @Override
    public void xxx(){
        //接口的具体实现
    }
}

//匿名内部类实现接口方法2  (???这跟内部类有什么关系???)
// * 注意接口名后面有() *
new 接口名(){
    @Override
    public void xxx(){
        //接口的具体实现
    }
}.xxx();

接口与抽象类的区别？

• interface被继承时用的关键字是implements，而且可以同时implements多个interface，而abstract class被继承时用的关键字是extends，而且只能同时extends一个abstract class。
• interface内定义的方法都是public的，而abstract class内的则不一定。
• interface内定义的成员对象都是static & final的，而abstract class不是
• interface的方法不能有默认实现，只有一个申明，而abstract class内申明abstract的方法不能有实现，非申明abstract的方法可以有默认实现。

• interface被implements时，所有方法都必须被实现，必须申明是public的，而abstract class被extends时只有abstract的方法才必须被实现，别的有默认实现的直接被继承过来。

  一般情况下，建议使用interface（因为能同时implements多个interface的特性，能更好地实现多态），当需要有默认实现和成员对象时才考虑abstract class。

-	abstract class	interface
实例化	不能	不能
类	一种继承关系，一个类只能使用一次继承关系。可以通过继承多个接口实现多重继承	一个类可以实现多个interface
数据成员	可有自己的	静态的不能被修改即必须是static final，一般不在此定义
方法	可以私有的，非abstract方法，必须实现; abstract方法可以在子类中再次声明为abstract留给孙类实现	不可有私有的，默认是public，abstract 类型; 不能有static方法
变量	可有私有的，默认是friendly 型，其值可以在子类中重新定义，也可以重新赋值	不可有私有的，默认是public static final 型，且必须给其初值，实现类中不能重新定义，不能改变其值。
设计理念	表示的是“is-a”关系	表示的是“like-a”关系
实现	需要继承，要用extends	要用implements

什么时候用接口？

异常

异常的种类

Throwable -> Error/Exception
Error类

系统层面的错误,如VirtualMachineError/ThreadDeath。

Exception类

程序的编码或运行时错误。
RuntimeException 错误类型转换，数组越界，算术错误，空指针异常等等。由JVM抛出和自动捕获
CheckException 需要手动捕获及处理。 try-catch-finally

异常的处理

可以多重Catch，但是要注意子类和父类的关系。
对于子类ExceptionClass的Catch必须在父类之前，否则子类永远不会被Catch，因为已经被父类再之前Catch了。

try{
//可能会抛出异常的代码
...
}catch（ExceptionChildClass1 e){
//异常处理代码for ExceptionChildClass1
...
}catch（ExceptionChildClass2 e){
//异常处理代码for ExceptionChildClass2
...
}catch（ExceptionParentClass e){
//异常处理代码for ExceptionParentClass
...
}finally{
//无论有没有异常都会执行这段代码
//如果try或者catch中有return语句,那么Finally将在return语句执行之后，函数返回之前执行  
...
}

异常链

将捕获的异常包装成一个新的异常再抛出
使用Exception的基类方法Exception(String message, Throwable cause), Constructs a new exception with the specified detail message and cause.

/**
 * 自定义异常 ExceptionDrunk
 * @author Sniffer
 */
public class ExceptionDrunk extends Exception {
    public ExceptionDrunk(){
        System.out.println("调用ExcetionDrunk的无参构造器");
    }
    public ExceptionDrunk(String input_str){
        super(input_str);
        System.out.println("调用ExcetionDrunk的String参数构造器");
    }
}

/**
 * Exception Chain 演示， 依赖于ExceptionDrunk这个自定义异常类 
 * test1()抛出异常 
 * test2()捕获test1()抛出的异常,包装为运行时异常继续抛出 
 * @author Sniffer
 */
public class ExceptionChain {
    public static void main(String[] args){
        ExceptionChain a=new ExceptionChain();
        try{
            a.test2();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public void test1() throws ExceptionDrunk{
        throw new ExceptionDrunk("喝多了");    
    }
    public void test2() throws RuntimeException{
        try{
            test1();
        }catch(Exception e){
            /* 写法1
            //There is a warining in IDE in the following line, ide will prompt me to use the second way as it is easier? 
            //之所以有这个警报，是因为Exception这个基类中有以下构造方法
            //Exception(String message, Throwable cause), Constructs a new exception with the specified detail message and cause.
            RuntimeException a=new RuntimeException("司机一滴酒，亲人两行泪");
            a.initCause(e);
            throw a;
             */

            /*写法2*/
            throw new RuntimeException("司机一滴酒，亲人两行泪", e);
        }

    }

}

经验总结

• 处理运行时异常的时候采用合理逻辑规避的同时在用try-catch
• 多重catch写完之后还可以加上一个catch(Exception)来避免遗漏
• 对于不确定的代码也可以加入try-catch
• 尽量处理异常而不仅仅是printStackTrace()
• 尽量添加finally语句块来释放资源

Java中的String

---

String类型的对象存在于java.lang包，默认自动导入到所有程序。

String str="hahaha";
String str1-new String();
String str2=new String("imooc");

String的地址比较： ==

注意多次出现同一常量字符串的时候可能会被编译器优化，导致下面例子中s1==s2的结果为true;
另外注意==比较的是String的地址，不是String的内容

public class HelloWorld {
    public static void main(String[] args) {
        String s1 = "imooc";
        String s2 = "imooc";

        //定义字符串s3，保存“I love”和s1拼接后的内容
        String s3 = "I love"+s1;

        // 比较字符串s1和s2
        // imooc为常量字符串，多次出现时会被编译器优化，只创建一个对象
        System.out.println("s1和s2内存地址相同吗？" + (s1 == s2));

        //比较字符串s1和s3
        System.out.println("s1和s3内存地址相同吗？" +  (s1==s3) );

        String s4 = "I love " + s1;
         //比较字符串s4和s3
        // s1是变量，s4在运行时才知道具体值，所以s3和s4是不同的对象
        System.out.println("s3和s4内存地址相同吗？" + (s4 == s3));
    }
}

String的内容比较 boolean String.equals(Object obj)

String类常用方法

方法	说明
int length()	长度
int indexOf(int ch)	返回字符ch在String中第一次出现的位置
int indexOf(String str)	-
int lastIndexOf(int ch)	-
int lastIndexOf(String str)	-
String substring(int beginIndex)	截取从beginIndex到字符串结尾的子字符串
String substring(int beginIndex, int endIndex)	-
String trim()	-
boolean equals()	-
String toUpperCase()	-
String toLowerCase()	-
char charAt(int index)	获取指定位置的字符（注意与indexOf(int ch)区分）
String[] split(String regex, int limit）	通过正则表达式的匹配分割字符串为字符串数组
byte[] getBytes()	转换为字节数组

public class HelloWorld {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "aljlkdsflkjsadjfklhasdkjlflkajdflwoiudsafhaasdasd";

        // 出现次数
        int num = 0;

         // 循环遍历每个字符，判断是否是字符 a ，如果是，累加次数
        for ( int i=0; i<s.length(); i++ )
        {
            // 获取每个字符，判断是否是字符a
            if ( (s.atChar(i))='a') {
                // 累加统计次数
                num++; 
            }
        }
        System.out.println("字符a出现的次数：" + num);
    }
}

StringBuilder and StringBuffer

StringBuffer是线程安全的(即多个线程同时操作同一个StringBuffer时不会出现数据错乱）
StringBuilder不是线程安全的，所以性能也略高。

• 作用：频繁操作字符串时，避免创建很多临时变量。

  StringBuffer a=new StringBuffer("hahaha");
  System.out.println(a);

• StringBuffer常用方法

方法	说明
StringBuffer append(String str)	追加内容到字符串尾部
StringBuffer insert(int pos, StringBuffer str)	-
int length()	-
String toString()	-

Java中的包装类

---

• 包装类通过对原始数据类型进行包装使他们拥有更多方法以供调用

基本类型	对应包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

• 常用方法
  byte byteValue()
  double doubleValue()
  float floatValue()
  int intValue()
  long longValue()
  static int parseInt(String s) //字符串到整型数转换
  static Integer valueOf(String s) //字符串到整型数转换
  String toString()

• 手动装箱和自动装箱
  （感觉自动装箱就是一个隐式的类型转换？从基本类型到包装类的隐式转换？）
  注意： 不同的基本类型和包装类间无法自动装箱，如int无法自动装箱为Long

• 字符串和基本数据类型间的转换
  将基本类型转换为字符串 Integer.toString(int) 或者 String.valueOf(int)
  将字符串转换为基本类型 Integer.parseInt(String) 或者 Integer.valueOf(String)

        double m = 78.5;
        //将基本类型转换为字符串
        String str1 = new Double(m).toString() ;
        //也可以用 String str1 = Double.toString(m);
        //这种方法相对好些，因为只是调用static method，没有创建新的对象
        System.out.println("m 转换为String型后与整数20的求和结果为： "+(str1+20));

        String str = "180.20";
        //将字符串转换为基本类型
        Double a = Double.valueOf(str)                       ;
        System.out.println("str 转换为double型后与整数20的求和结果为： "+(a+20));

Date类 时间和日期（java.util.Date; java.text.SimpleDateFormat;）

Date xxx=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("format_string");
关于format_string, yyyy/MM/dd HH:mm:ss,yyyy表示年，MM表示月，其他依次类推，注意MM和mm的区别以及HH大写。（小写的hh表示什么？)
SimpleDateFormat方法：

方法	说明
Date parse(String)	parse certain string to Date object using the DataFormat
String format(Data)	convert Date object to a String indicating the date/time stored in Data obj

    public static void main(String[] args) throws ParseException {

        // 使用format()方法将日期转换为指定格式的文本
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm");
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // 创建Date对象，表示当前时间
        Date now=new Date();
        System.out.println(now);

        // 调用format()方法，将日期转换为字符串并输出
        System.out.println(sdf1.format(now));
        System.out.println(sdf2.format(now));
        System.out.println(sdf3.format(now));

        // 使用parse()方法将文本转换为日期
        String d = "2014-6-1 21:05:36";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

         // 调用parse()方法，将字符串转换为日期
        Date date = sdf.parse(d);

        System.out.println(date);
    }

Calendar类(java.util.Calendar)

Calendar是一个抽象类，必须用getInstance()来获取一个对象。

Calendar c=Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
Date d=c.getTime();
Long time= c.getTimeInMillis(); //当前毫秒数

Math类(java.lang.Math)

Method	Description
long round()	四舍五入
double floor()	取整，退一法
double ceil	取整，进一法
double random()	-