Java语法中微小细节

1.循环

for(int i=0; i<3; i++)
 Integer k = new Integer(i);

for(int i=0; i<3; i++)
 ++i;

Java中循环不加{}，只用于执行语句。赋值语句不行。故第二行编译报错，第五行编译通过。

2.判断

类似的，判断语句也需要{}，下面例子会编译出错。

if(x == 1) 
    int b = x;// 编译出错

3、类的访问性

一个类文件为Test.java,那么这个类一定是public？

并不是，这个类也可以是包级别的，即不加修饰符；java并不将其默认为public，而是确实是包级别的。包外无法访问这个类。

而访问性上： public > protected > package > private。这里跳过了protected。

4、String

下面语句创建了多少个对象？

String str = "a"+"b"+"c";

"a", "b", "c"是字符串常量，对于常量， 编译时就存储器字面值，而不是其引用，即编译时，等号右边成了"abc"。相当于String str = "abc"; 。这当然只会有一个对象了。

下面语句创建了多少个对象？

String str2 = new String("i am single");

两个，“i am single”首先会在常量池中创建，编译时完成； new 在java堆中创建一个对象，运行时完成。

其实，String对象还有一个intern方法，用于取常量池中对应的字符串。比如“abc”.intern()， 将会取得自己。那么下面的例子：

		System.out.println("ab".intern() == "ab");
		String s1 = new String("abc0099");
		String s2 = "abc";
		String s3 = s2 + "0099";
		String s4 = "abc0099";
		System.out.println(s1 == s3); // false
		System.out.println(s3 == s4); // false
		System.out.println(s3.intern() == s4); // true

上面例子主要强调s3，它无法再编译期间确定，所以是在运行时确定的，被分配在堆上。注意，String x = s4+“uuu”，不会在常量池中创建“abc0099uuu”这个字符串的，当然“uuu”是要创建的。

5、指定大小

StringBuffer， HashMap等对象的操作，如果可以指定大小，那么最好指定大小，每次底层扩容的代价都很大。

6、嵌套类

说明static nested class 和 inner class的不同。

nested class一般是c++的说法，表示一种专用的、紧耦合的关系，nested class在java中被映射为inline class。如果A是B的nested class，那么A是B的重要部分，或者完成B的重要功能。

inner class是java中的内部类，意义同上。

静态的内部类：创建这个内部类不需要外部类实例，通过这个内部类也无法确定一个外部类对象；简单说。然而，这个内部的静态类可以创建实例，且可以保存自己的状态。比如

public class Test {
	static class StaticInnerClass {
		static int stc_field = 0;
		int normal_field = 1;
	}	
	public static void main(String[] args) {
		StaticInnerClass sic = new StaticInnerClass();
		System.out.println(sic.normal_field);
		System.out.println(StaticInnerClass.stc_field);
    }
}

下面说明静态与非静态的区别。

首先说明，java“依托于类”。一个类中的类就是嵌套类，使得这个类自身成为外围类。嵌套类分四种，静态成员类，非静态成员类，匿名类，和局部类。从名字就可以看出他们出现的位置和类型。前两种是外围类的成员；匿名类一般出现在代码中，比较典型的应用是new Comparator；局部类一本会申明在方法中，它有自己的名字，其他方面与其他嵌套类都有些交集。而这里说明的内部类指的是非静态成员类。

    静态成员类只是一个类的成员，但是说它是成员，又有些特殊，因为是静态的。其实，最有效的理解就是这个类是普通的类，但是只有外围类可以使用它。非静态成员类的每个实例都与外围类的一个实例挂钩，如果嵌套类的实例想要独立于外围类，这个类就必须是静态成员类；如果没有外围实例的情况下，创建非静态成员类的实例是不可能的。匿名类只有出现在非静态环境中，它才能与外围类实例建立联系。其实，这些道理很容易想通的。

    结合上下两个例子，可以说明一些问题。（当然，下面的例子只用来说明问题，是非常不恰当的例子）：

package test.innerclass;

public class Out {
	public int ov;

	public void showME() {
		System.out.println(ov);
	}

	public class In {
		static final int in = 0;
		// static int ins = 1; // 将无法拥有可变的域
		int iv;
		public Out out;

		public In(Out o) {
			out = o;
		}

		public void showOut() {
			out.showME();
		}
	}

	public static void main(String[] args) {
		Out out = new Out();
		In in = out.new In(out);
		System.out.println(in.iv);
		System.out.println((new Out()).new In(new Out()));

	}
}

以上内容，如有错误，望不吝赐教。