Java基础总结--1

基础部分

Java的String是不可变对象，比如：

public class Foo {
	public static void main(String arg[]) {
		String s = "hello world";
		String s1 = s + " !"; // 追加字符
		String s2 = s.s.substring(0, 5) + " foo";
	}
}

s1和s2是会共享原来s的字符的。

如果经常变化字符串，可以使用StringBuilder，可以与String互相转化：

public class Sample {
    public static void main(String[] arg) {
        StringBuilder sb = new StringBuilder();
        sb.append("124");
        String s = sb.toString();
    }
}

Java的数组，一维数组来说，声明后是null，需要具体进行实例化。而高维数组，本质上都是可变数组：

public class Sample {
    public static void main(String[] arg) {
        int[] a = {1, 2, 3};
        int[] b = new int[10];
        int[][] c = new int[10][6];
        int[][] d = new int[3][];
        for (int i = 0; i < 3; i++) {
            d[i] = new int[i + 1];
        }
		// 一般使用for range进行迭代
		for (int[] row: d) {
            for (int v: row) {
                System.out.println(v);
            }
        }
    }
}

Arrays为数组提供了排序、深拷贝等的操作，具体可以参考手册。

面向对象基础

对于Java来说，一切皆对象，对于定义的对象，如果仅仅是声明，那么它相当于C++中的指针，使用=赋值的时候，也是地址而已：

public class Sample {
    public static void main(String[] arg) {
        Data data; // C++等价为Data* data
        data = new Data();
        Data data1 = data; // C++ => Data* data1 = data
    }
}

所有的对象都是分配在堆上的，因此所谓的赋值只是传递指针而已，除非使用深拷贝。

可以这么理解，Java中全部都是传递值，没有传递引用的说法。所有的对象都是分配在堆上的，赋值的时候，都是隐式指针的形式

Java自定义的对象只有构造函数，没有析构函数。Java的构造函数支持重载，这点类比C++。

Java的final关键字可以限制类中成员变量是不可变的，类比C++的const。

public class Sample {
	private final double PI = 3.1415926;
}

Java的static关键字表示静态成员，这点直接类比C++即可。当然，调用的时候，还是使用.，代码实例：

public class Sample {
	public static int getNextId() {
		return nextId;
	}
	private static int nextId = 0;
}

/*
 *  .. some operation
**/
public class SampleMain {
	public static void main(String[] arg) {
		System.out.println(Sample.getNextId());  // 这里调用静态方法
	}
}

Java的类，需要声明package为同级别的目录，否则类就会被放置到一个默认的default包中。类和成员的可见性：

• public：包内外都可见
• private：类内部可见
• 不声明：同一个包内可见