Java基本点

1、面向对象的特征有哪些方面？

面向对象的特征主要有以下几个方面：

• 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
• 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
• 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装，我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单，我们现在使用的智能手机也是封装的足够好，因为几个按键就搞定了所有的事情）。
• 多态性：多态性是指允许不同子类型的对象对同一消息做出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者使用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事情：1)方法重写（子类继承父类并重写父类中已有的或抽象的方法；2)对象造型（使用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

2、访问修饰符public、private、protected，以及不写（默认）时的区别？

修饰符当前类同包子类其他包public是是是是protected是是是否default是是否否private是否否否类的成员不写访问修饰符时默认为default。默认对于同一个包中的其他类相当于公开(public)，对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。Java类中，外部类的修饰符只能是public或默认，类的成员（包括内部类）的修饰符可以是以上四种。

3、String是基本类型吗？

不。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型(primitive type)和枚举类型(enumeration type)，剩下的都是引用类型(reference type)。

4、float f = 3.4；是否正确？

不正确。3.4是双精度，将双精度(double)赋值给浮点型(float)属于向下转型(down-casting，也称为窄化)会造成精度损失，因此需要强制类型转换float f = (float)3.4;或者写成float f = 3.4F;。

5、short s1 = 1; s1 = s1 + 1;有错吗？short s1 = 1; s1 += 1; 有错吗？

对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1 + 1运算结果也是int类型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1 += 1；相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

6、Java有没有goto？

goto是Java的保留字，在目前版本的Java中没有使用。（根据James Gosling(Java之父)编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）。

7、int和Integer有什么区别？

Java是一个近乎纯洁的面向对象的编程语言，为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型(wrapper class)，int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

Java为每个原始类型提供了包装类型：

• 原始类型：boolean，char，byte，short，int，long，float，double
• 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

package com.universe.inboxing;/** * Created by universe on 16-9-29. */public class AutoUnboxingTest {    public static void main(String[] args) {        Integer a = new Integer(3);        Integer b = 3;// 将3自动装箱为Integer类型        int c = 3;        System.out.println(a == b);// false两个引用没有引用同一对象        System.out.println(a == c);// true a自动拆箱成int类型再和c比较    }}

最近还遇到一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：

package com.universe.inboxing;/** * Created by littlewolf on 9/29/2016. */public class Test {    public static void main(String[] args) {        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;        System.out.println(f1 == f2);        System.out.println(f3 == f4);    }}

如果不明其中道理很容易就会认为两个输出要么是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢？当我们给一个Integer对象赋予一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。

    public static Integer valueOf(int i) {        if (i >= IntegerCache.low && i <= IntegerCache.high)            return IntegerCache.cache[i + (-IntegerCache.low)];        return new Integer(i);    }    // IntegerCache是Integer的内部类，其代码如下所示：    /**    * Cache to support the object identity semantics of autoboxing for values between    * -128 and 127 (inclusive) as required by JLS.    *    * The cache is initialized on first usage. The size of the cache    * may be controlled by the {@code -XX:AutoBoxCacheMax=} option.    * During VM initialization, java.lang.Integer.IntegerCache.high property    * may be set and saved in the private system properties in the    * sun.misc.VM class.    */    private static class IntegerCache {        static final int low = -128;        static final int high;        static final Integer cache[];        static {            // high value may be configured by property            int h = 127;            String integerCacheHighPropValue =                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");            if (integerCacheHighPropValue != null) {                try {                    int i = parseInt(integerCacheHighPropValue);                    i = Math.max(i, 127);                    // Maximum array size is Integer.MAX_VALUE                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);                } catch( NumberFormatException nfe) {                    // If the property cannot be parsed into an int, ignore it.                }            }            high = h;            cache = new Integer[(high - low) + 1];            int j = low;            for(int k = 0; k < cache.length; k++)                cache[k] = new Integer(j++);            // range [-128, 127] must be interned (JLS7 5.1.7)            assert IntegerCache.high >= 127;        }        private IntegerCache() {}    }

简单的说，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果为true，而f3==f4的结果为false。

提醒：越是貌似简单的面试题其中的玄机就越多，需要面试者有相当深厚的功力。

8、解释内存中的栈(stack)、堆(heap)和静态区(static area)的用法。

通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；而通过new关键字和构造器创建的对象放在堆空间；程序中的字面量(literal)，如直接书写的100、"hello"和常量都是放在静态区的。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，理论上整个内存没有被其他进程使用的空间甚至硬盘上的虚拟内存都可以被当成堆空间来使用。

String str = new String("hello");

上面的语句中变量str放在栈中，用new创建出来的字符串对象放在对上，而“hello”这个字面量放在静态区。

9、当一个对象被当做参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

值传递。Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的。

10、重载(Overload)和重写(Override)的区别？重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类和父类之间，重写要求子类被重写方法与父类重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊要求。

面试题：华为的面试题中曾经问过这样一个问题：“为什么不能根据返回类型来区分重载”，快说出来你的答案。

11、描述一下JVM加载class文件的原理机制？

JVM中类的装载是由类加载器(ClassLoader)和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。

由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后，就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后JVM对类进行初始化，包括：1)如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；2)如果类中存在初始化语句，就依次执行这些初始化语句。

类的加载是由类加载器完成的，类加载器包括：根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器(java.lang.ClassLoader的子类)。从Java 2(JDK 1.2)开始，类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的BootStrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对BootStrap的引用。下面是几个类加载器的说明：

BootStrap：一般用本地代码实现，负责加载JVM基础核心类库(rt.jar)；

Extension：从java.ext.dirs系统属性所指定的目录中加载类库，它的父加载器是BootStrap；

System：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中加载类，是用户自定义加载器的默认父加载器。

12、抽象类(abstract class)和接口(interface)有什么异同？

抽象类和接口都不能实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的，而接口中的成员全都是public的。抽象类中可以自定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须声明为抽象类，而抽象类未必要有抽象方法。

13、静态嵌套类（Static Nested Class）和内部类（Inner Class）的不同？

Static Nested Class是被声明为静态(static)的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化，其语法看起来挺诡异的，如下所示：

package com.universe.test;/** * 扑克类 * Created by littlewolf on 9/29/2016. */public class Poker {    private static String[] suites = {"黑桃", "红桃", "草花", "方块"};    private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};    private Card[] cards;    /**     * 构造器     */    public Poker() {        cards = new Card[52];        for (int i = 0; i < suites.length; i++) {            for (int j = 0; j < faces.length; j++) {                cards[i * 13 + j] = new Card(suites[i], faces[j]);            }        }    }    /**     * 洗牌(随机乱序)     */    public void shuffle() {        for(int i = 0, len = cards.length; i < len; i++) {            int index = (int)(Math.random() * len);            Card temp = cards[index];            cards[index] = cards[i];            cards[i] = temp;        }    }    /**     * 发牌     * @param index 发牌的位置     * @return     */    public Card deal(int index) {        return cards[index];    }    /**     * 卡片类（一张扑克）     * 内部类     */    public class Card {        private String suite; //花色        private int face; //点数        public Card(String suite, int face) {            this.suite = suite;            this.face = face;        }        @Override        public String toString() {            String faceStr = "";            switch (face) {                case 1:                    faceStr = "A";                    break;                case 11:                    faceStr = "J";                    break;                case 12:                    faceStr = "Q";                    break;                case 13:                    faceStr = "K";                    break;                default:                    faceStr = String.valueOf(face);            }            return suite + faceStr;        }    }}

package com.universe.test;/** * Created by littlewolf on 9/29/2016. */public class PokerTest {    public static void main(String[] args) {        Poker poker = new Poker();        poker.shuffle();//洗牌        Poker.Card c1 = poker.deal(0);//发第一张牌        //对于非静态内部类Card，只有通过其外部类Poker对象才能创建Card对象        Poker.Card c2 = poker.new Card("红心", 1);//自己创建一张牌        System.out.println(c1);//洗牌后的第一张        System.out.println(c2);//打印：红心A    }}

面试题：下面的代码哪些地方会产生编译错误？

class Outer {    class Inner {}    public static void foo() { new Inner(); }    public void bar() { new Inner(); }    public static void main(String[] args) {        new Inner();    }}

注意：Java中非静态内部类对象的创建必须要依赖于其外部类对象，上面的面试题中foo和main方法都是静态方法，静态方法中没有this，也就是说没有所谓的外部类对象，因此无法创建内部类对象，如果要在静态方法中创建内部类对象，可以这样做：

new Outer().new Inner();

14、Java中会存在内存泄漏吗，请简单描述。

理论上Java因为有垃圾回收机制（GC）不会存在内存泄漏问题（这也是Java广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收，因此也会导致内存泄漏的发生。例如，Hibernate的Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭(close)或清空(flush)一级缓存就可能导致内存泄漏。下面的例子中的代码也会导致内存泄漏：

package com.base;import java.util.Arrays;import java.util.EmptyStackException;/** * Created by universe on 9/29/16. */public class MyStack<T> {    private T[] elements;    private int size = 0;    private static final int INIT_CAPACITY = 16;    public MyStack() {        elements = (T[]) new Object[INIT_CAPACITY];    }        public void push(T elem) {        ensureCapacity();        elements[size++] = elem;    }        public T pop() {        if(size == 0)             throw new EmptyStackException();        return elements[--size];    }        private void ensureCapacity() {        if(elements.length == size) {            elements = Arrays.copyOf(elements, 2*size+1);        }    }}

上面的代码实现了一个栈(先进后出FILO)结构，乍看之下，似乎没有什么明显的问题，它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄漏问题，当我们使用pop方法弹出栈中的对象时，该对象不会被当作垃圾回收，即使使用栈的程序不再引用这些对象，因为栈内部维护着对这些对象的过期引用(obsolete reference)。在支持垃圾回收的语言中，内存泄漏是很隐蔽的，这种内存泄漏其实就是无意识的对象保持。如果一个对象引用被无意识地保留了起来，那么垃圾回收器不会处理这个对象，也不会处理这个对象引用的其他对象，即使这样的对象只有少数几个，也可能会导致很多的对象被排除在垃圾回收之外，从而对性能造成很大影响，极端情况下会引起Disk Paging(物理内存与硬盘的虚拟内存交换数据)，甚至造成OutOfMemoryError。

15、如何实现对象克隆？

有两种方式：

1)实现Cloneable接口并重写Object类中的clone()方法；

2)实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。

package com.base;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;/** * Created by universe on 9/29/16. */public class MyUtil {    public static Object clone(Object obj) throws Exception {        ByteArrayOutputStream bout = new ByteArrayOutputStream();        ObjectOutputStream oos = new ObjectOutputStream(bout);        oos.writeObject(obj);        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());        ObjectInputStream ois = new ObjectInputStream(bin);        return ois.readObject();        //说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义        //这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源(如文件流)的释放    }}

package com.base;import java.io.Serializable;/** * Created by root on 9/29/16. */public class Person implements Serializable {    private String name;    private int age;    private Car car;    public Person(String name, int age, Car car) {        this.age = age;        this.name = name;        this.car = car;    }    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;    }    public Car getCar() {        return car;    }    public void setCar(Car car) {        this.car = car;    }    @Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", age=" + age +                ", car=" + car +                '}';    }}

package com.base;import java.io.Serializable;/** * Created by root on 9/29/16. */public class Car implements Serializable {    private String brand;    private int maxSpeed;    public Car(String brand, int maxSpeed) {        this.brand = brand;        this.maxSpeed = maxSpeed;    }    public String getBrand() {        return brand;    }    public void setBrand(String brand) {        this.brand = brand;    }    public int getMaxSpeed() {        return maxSpeed;    }    public void setMaxSpeed(int maxSpeed) {        this.maxSpeed = maxSpeed;    }    @Override    public String toString() {        return "Car{" +                "brand='" + brand + '\'' +                ", maxSpeed=" + maxSpeed +                '}';    }}

package com.base;/** * Created by root on 9/29/16. */public class CloneTest {    public static void main(String[] args) {        try {            Person p1 = new Person("TaeMin", 22, new Car("Benz", 300));            Person p2 = (Person) MyUtil.clone(p1); //深度克隆            p2.getCar().setBrand("BYD");            // 修改克隆的Person对象p2关联的汽车对象的品牌属性            // 原来的Person对象p1关联的汽车不会受到任何影响            // 因为在克隆Person对象时其关联的汽车对象也被克隆了            System.out.println(p1);        } catch (Exception e) {            e.printStackTrace();        }    }}

16、GC是什么？为什么要有GC？

GC是垃圾回收，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显式操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc()或Runtime.getRuntime().gc()，但JVM可以屏蔽掉显式的垃圾回收调用。

垃圾回收可以有效的防止内存泄漏，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期，垃圾回收是Java最大的亮点之一，因为服务端的编程需要有效的防止内存泄漏问题，然而时过境迁，如今的Java回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS系统比Android系统有更好的用户体验，其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

补充：垃圾回收机制有很多种，包括：分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量，堆保存了创建的对象，Java平台对堆内存回收和再利用的基本算法被称为标记和清除。但是Java对其进行了改进，采用“分代式垃圾收集”。这种方法会根据Java对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象移动到不同区域：

• Eden：这是对象最初诞生的区域，并且对大多数对象来说，这里是它们唯一存在过的区域。
• Survivor：从Eden幸存下来的对象会被挪到这里。
• Tenured：这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象及时按要求回收，就会触发一次完全收集(Major-GC)，这里可能还会牵扯到压缩，以便为大对象腾出足够空间。

与垃圾回收相关的JVM参数：

-Xms / -Xmx ：堆的初始大小 / 堆的最大大小

-Xmn ：堆中年轻代的大小

-XX:DisableExplicitGC ：让System.gc()不产生任何作用

-XX:+PrintGCDetail ：打印GC的细节

-XX:+PrintGCDateStamps ：打印GC操作的时间戳

-XX:NewSize / -XX:MaxNewSize ：设置新生代大小 / 新生代最大大小

-XX:NewRatio ：可以设置老生代和新生代的比例

-XX:PrintTenuringDistribution ：设置每次新生代GC后输出幸存者乐园中对象年龄的分布

-XX:InitialTenuringThreshold / -XX :MaxTenuringThreshold：设置老年代阈值的初始值和最大值

-XX:TargetSurvivorRatio：设置幸存区的目标使用率

17、日期和时间：

如何取得年月日、小时分钟秒？

如何取得从1970年1月1日0时0分0秒到现在的毫秒数？

如何取得某月的最后一天？

如何格式化日期？

问题1：创建java.util.Calendar实例，调用其get()方法传入不同的参数即可获得参数所对应的值。Java 8中可以使用java.time.LocalDateTime来获取。代码如下：

package com.base;import java.time.LocalDateTime;import java.util.Calendar;/** * Created by root on 9/29/16. */public class DateTimeTest {    public static void main(String[] args) {        Calendar cal = Calendar.getInstance();        System.out.println(cal.get(Calendar.YEAR));        System.out.println(cal.get(Calendar.MONTH));// 0-11        System.out.println(cal.get(Calendar.DATE));        System.out.println(cal.get(Calendar.HOUR_OF_DAY));        System.out.println(cal.get(Calendar.MINUTE));        System.out.println(cal.get(Calendar.SECOND));        // Java 8        LocalDateTime dt = LocalDateTime.now();        System.out.println(dt.getYear());        System.out.println(dt.getMonthValue());// 1-12        System.out.println(dt.getDayOfMonth());        System.out.println(dt.getHour());        System.out.println(dt.getMinute());        System.out.println(dt.getSecond());    }}

问题2：以下方法均可获得该毫秒数

        System.out.println(Calendar.getInstance().getTimeInMillis());        System.out.println(System.currentTimeMillis());        System.out.println(Clock.systemDefaultZone().millis());

问题3：代码如下所示：

        Calendar time = Calendar.getInstance();        System.out.println(time.getActualMaximum(Calendar.DAY_OF_MONTH));

问题4：利用java.text.DateFormat的子类(如SimpleDateFormat类)中的format(Date)方法可将日期格式化。Java 8中可以用java.time.format.DateTimeFormatter来格式化时间日期，代码如下所示：

package com.base;import java.text.SimpleDateFormat;import java.time.LocalDate;import java.time.format.DateTimeFormatter;import java.util.Date;/** * Created by root on 9/29/16. */public class DateFormatTest {    public static void main(String[] args) {        SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");        Date date1 = new Date();        System.out.println(oldFormatter.format(date1));        // Java 8        DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");        LocalDate date2 = LocalDate.now();        System.out.println(date2.format(newFormatter));    }}

补充：Java的时间日期API一直以来是被诟病的东西，为了解决这个问题，Java 8中引入了新的时间日期API，其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等类，这些类的设计都使用了不变模式，因此是线程安全的设计。