java 基本语法

欢迎访问个人站点 java 基本语法

1. Java 的主要类型

Java 主要类型

类型	大小(bit)	对应类类型
boolean	1	Boolean
char	16	Character
byte	8	Byte
short	16	Short
int	32	Integer
long	64	Long
float	32	Float
double	64	Double
void		·
·	·	BigInteger
·	·	BigDecimal
·	·	String

BigInteger 和 BigDecimal 作为 java 提供的高精度类型，分别用来存储整型和浮点型数字，只要内存足够大，两个类型没有最大值的限制，在比值计算、财务管理等方面十分常用。
上表中并没有给出相应类型的变量创建后 JVM 所赋予的默认值，首先，局部变量并不会被初始化为默认值，而类成员变量虽然会被初始为默认的 0，但是实际的程序中并不应该依赖这样的初始化机制。

2. 名字可见性

为了避免名字冲突，java 引入了包的概念，类放置在独一无二的包中，点分字符串的包名代表了目录结构，因此也就避免了同名包的产生，这样，即使是相同的类名，单在不同的包中也就意味着是不同的类了，从而避免了类名的冲突。
目前整个软件包都以小写字母为标准，当引用类外部的某个类时，需要 import 的相应的包名，或在使用类名时指定完整的包名。
如果 import java.util.*; 则引入对应包名下的所有子包。

3. 对象的比较

关系运算符 == 和 != 适用于所有基本类型和对象的比较。
需要注意：
1. 对于基本类型的变量，== 和 != 比较的是变量的值
2. 对于类对象，== 和 != 比较的是对象的地址
3. 对于类对象，如果想要比较类的成员，需要使用 equals 方法，java 的所有的类都继承于 Object 方法，Object 方法实现了很多默认的成员变量和成员方法，equals 也是其中之一，默认的实现是 ==，所以如果没有重载该方法，其作用依然是比较对象的地址

4. 对象的初始化

对象会首先初始化 static 成员，然后初始化非 static 成员，最后调用相应构造方法完成初始化过程。
对于类成员，如果没有指定初始值，会自动初始化为 0、null 或 false，如果指定了初值，则会初始化为对应的初值。
对于方法的局部变量，则会赋予随机值。

//: StaticInitialization.java
// Specifying initial values in a
// class definition.
class Bowl {
	Bowl(int marker) {
		System.out.println("Bowl(" + marker + ")");
	}
	void f(int marker) {
		System.out.println("f(" + marker + ")");
	}
}

class Table {
	static Bowl b1 = new Bowl(1);
	Table() {
		System.out.println("Table()");
		b2.f(1);
	}
	void f2(int marker) {
		System.out.println("f2(" + marker + ")");
	}
	static Bowl b2 = new Bowl(2);
}

class Cupboard {
	Bowl b3 = new Bowl(3);
	static Bowl b4 = new Bowl(4);
	Cupboard() {
		System.out.println("Cupboard()");
		b4.f(2);
	}
	void f3(int marker) {
		System.out.println("f3(" + marker + ")");
	}
	static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
	public static void main(String[] args) {
		System.out.println(
				"Creating new Cupboard() in main");
		new Cupboard();
		System.out.println(
				"Creating new Cupboard() in main");
		new Cupboard();
		t2.f2(1);
		t3.f3(1);
	}
	static Table t2 = new Table();
	static Cupboard t3 = new Cupboard();
} ///:~”

这段代码输出了：

Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)

static 成员只有在第一次使用前会被初始化，此后将不会被再次重复初始化。

5. java 的数组操作

5.1. 数组的创建

String[] aArray = new String[5];
String aArray[] = new String[5];
String[] bArray = {"a","b","c", "d", "e"};  
String[] cArray = new String[]{"a","b","c","d","e"};  

java 提供了基本的数组类型，如上所示，String[] aArray 与 String aArray[] 的创建方式是等效的，但是推荐使用前一个的风格。
创建数组时指定大小 String aArray[5] 这样的写法是不允许的，因为创建数组时只是获取了一个数组的句柄，而并没有为数组分配实际的存储空间，直到初始化时，这段空间才会被分配。
需要注意的是，如果将一个数组赋值给另一个数组，实际上赋值的是句柄，因此，如果在赋值后通过一个句柄修改了数组中某元素的值，则另一个句柄查询得到的值将也会被更新。
已经初始化后，数组空间的大小分配固定，此后不能够再扩展空间。

5.2. 数组的输出

java 的数组实际上是一个对象。

String[] aArray = {"a","b","c", "d", "e"};
System.out.println(aArray);
System.out.println(Arrays.toString(aArray));

上述程序输出了：
[I@7150bd4d。
[a, b, c, d, e]

5.3. 检测数组是否包含某个值

String[] stringArray = { "a", "b", "c", "d", "e" };  
boolean b = Arrays.asList(stringArray).contains("a");  
System.out.println(b); 

5.4. 连接两个数组

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] intArray2 = { 6, 7, 8, 9, 10 };  
// Apache Commons Lang library  
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);  

5.5. 移除数组中的元素

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array  
System.out.println(Arrays.toString(removed));  

可以看到，无论是为数组增加元素还是移除元素，都是通过返回新的句柄实现的，事实上完成了一次新空间的创建和拷贝工作，因为 array 一经初始化后空间是不可变的。

6. java 成员访问控制

java 有三个关键字用来声明成员的可见性，分别是：
1. public
2. protected
3. private
如果没有声明可见性关键字，则通常称为“friendly”。

java 成员可见性

关键字	同包	有继承关系	外部可见
public		·
friendly	·		X
protected	X		·
private		X

对于访问控制关键字，还有以下限制：
1. 每个文件中只能有一个 public 类，但可以拥有多个 friendly 类，当然，也可以没有 public 类
2. 如果文件拥有 public 类，文件中的 public 类名必须与文件名完全一致
3. 类不可以被 private 或 protected 修饰

欢迎关注微信公众号