静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同

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

/**

* 扑克类（一副扑克）

* @author 骆昊

*

*/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 发牌的位置

*

*/public Card deal(int index) {

return cards[index];

}

/**

* 卡片类（一张扑克）

* [内部类]

* @author 骆昊

*

*/public class Card {private String suite; // 花色private int face; // 点数public Card(String suite, int face) {

this.suite = suite;

this.face = face;

}

@Overridepublic 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;

}

}

}

测试代码：

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();

---------------------------静态内部类的用法------------------------------------------------------------------

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import net.sf.json.JsonConfig;

import net.sf.json.processors.JsonValueProcessor;

public class JsonUtil {

public static final String obj2Json(Object obj, String formatStr) {

String jsonStr = "[]";

if (CommonUtil.isEmpty(obj)) {

LoggerHelper.warn("传入的Java对象为空,不能将其序列化为Json格式");

} else {

JsonConfig cfg = new JsonConfig();

cfg.registerJsonValueProcessor(java.sql.Timestamp.class,
new JsonValueProcessorImp(formatStr));

cfg.registerJsonValueProcessor(java.util.Date.class,
new JsonValueProcessorImp(formatStr));

cfg.registerJsonValueProcessor(java.sql.Date.class,
new JsonValueProcessorImp(formatStr));

if (obj instanceof ArrayList) {

JSONArray jsonArray = JSONArray.fromObject(obj, cfg);

jsonStr = jsonArray.toString();

} else {

JSONObject jsonObject = JSONObject.fromObject(obj, cfg);

jsonStr = jsonObject.toString();

}

}

return jsonStr;

}

static class JsonValueProcessorImp implements JsonValueProcessor
{

/**

* 默认的格式

*/

private String format = "yyyy-MM-dd HH:mm:ss";

public JsonValueProcessorImp() {

};

public JsonValueProcessorImp(String format) {

this.format = format;

}

/**

* 格式化数组

*/

public Object processArrayValue(Object value, JsonConfig jsonConfig) {

String[] obj = {};

if (value instanceof java.util.Date[]) {

SimpleDateFormat sf = new SimpleDateFormat(format);

java.util.Date[] dates = (java.util.Date[]) value;

obj = new String[dates.length];

for (int i = 0; i < dates.length; i++) {

obj[i] = sf.format(dates[i]);

}

}

if (value instanceof Timestamp[]) {

SimpleDateFormat sf = new SimpleDateFormat(format);

Timestamp[] dates = (Timestamp[]) value;

obj = new String[dates.length];

for (int i = 0; i < dates.length; i++) {

obj[i] = sf.format(dates[i]);

}

}

if (value instanceof java.sql.Date[]) {

SimpleDateFormat sf = new SimpleDateFormat(format);

java.sql.Date[] dates = (java.sql.Date[]) value;

obj = new String[dates.length];

for (int i = 0; i < dates.length; i++) {

obj[i] = sf.format(dates[i]);

}

}

return obj;

}

/**

* 格式化单一对象

*/

public Object processObjectValue(String key, Object value,

JsonConfig jsonConfig) {

if(CommonUtil.isEmpty(value))

return "";

if (value instanceof Timestamp) {

String str = new SimpleDateFormat(format).format((Timestamp) value);

return str;

} else if (value instanceof java.util.Date) {

String str = new SimpleDateFormat(format).format((java.util.Date) value);

return str;

} else if (value instanceof java.sql.Date) {

String str = new SimpleDateFormat(format).format((java.sql.Date) value);

return str;

}

return value.toString();

}

public String getFormat() {

return format;

}

public void setFormat(String format) {

this.format = format;

}

}

}