Java语言特性备忘

简单的java代码示例

package com.test.helloworld

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

基本数据类型

类型	位数	最小值	最大值	默认值
byte(字节)	8	-128	127	0
short（短整型）	16	-32768	32768	0
int(整型)	32	-2147483648	2147483648	0
long(长整型)	64	-9233372036854477808	9233372036854477808	0
float(浮点型)	32	-3.40292347E+38	3.40292347E+38	0.0f
double(双精度)	64	-1.79769313486231570E+308	1.79769313486231570E+308	0.0d
char(字符型)	16	\u0000	\uffff	\u0000
boolean(布尔型)	1	true,false	true,false	false

运算符

-算数运算符

加号（+），减号（-），乘号（*），除号（/），取模（%）

-赋值运算符

=

-自动递增递减

递增（++），递减（–）

-关系运算符

大于（>），小于（<），大于等于（>=），小于等于（<=），等于（==），不等于（!=）。等于和不等于适用于所有内建的数据类型，但其他比较不适用于boolean 类型

-逻辑运算符

AND（&&），OR（||）,NOT（！）,只可将AND，OR 或NOT 应用于布尔值。与在C 及C++中不同，不可将一个非布尔值当作布尔值在逻辑表达式中使用。”短路”，一旦逻辑运算表达式的值已经求出，后续表达式不计算值。

-按位运算符

若两个输入位都是1，则按位AND运算符（&）在输出位里生成一个1；否则生成0。
若两个输入位里至少有一个是1，则按位OR 运算符（|）在输出位里生成一个1；只有在两个输入位都是0的情况下，它才会生成一个0。
若两个输入位的某一个是1，但不全都是1，那么按位XOR（^，异或）在输出位里生成一个1。
按位NOT（~，也叫作“非”运算符）属于一元运算符；它只对一个自变量进行操作（其他所有运算符都是二元运算符）。按位NOT生成与输入位的相反的值——若输入0，则输出1；输入1，则输出0。
按位运算符可与等号（=）联合使用，以便合并运算及赋值：&=，|=和^=都是合法的（由于~是一元运算符，所以不可与=联合使用）。

-移位运算符

移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）。
左移位运算符（<<）能将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）。
Java 也添加了一种“无符号”右移位运算符（>>>），它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C 或C++没有的。
若对char，byte 或者short 进行移位处理，那么在移位进行之前，它们会自动转换成一个int。只有右侧的5 个低位才会用到。这样可防止我们在一个int 数里移动不切实际的位数。
若对一个long 值进行处理，最后得到的结果也是long。此时只会用到右侧的6个低位，防止移动超过long 值里现成的位数。
但在进行“无符号”右移位时，也可能遇到一个问题。若对byte 或short 值进行右移位运算，得到的可能不是正确的结果（Java 1.0 和Java 1.1 特别突出）。它们会自动转换成int 类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1 的结果。

-三元if-else运算符

布尔表达式 ? 值0:值1

-逗号运算符

在C 和C++里，逗号不仅作为函数自变量列表的分隔符使用，也作为进行后续计算的一个运算符使用。在
Java 里需要用到逗号的唯一场所就是for 循环

-字符串运算符+

如果想通过“加号”连接字串（使用Java 的早期版本），请务必保证第一个元素是字串（或加上引号的一系列字符，编译能将其识别成一个字串）。

-造型运算符

void casts() {
    int i = 200;
    long l = (long)i;
    long l2 = (long)200;
}

控制流

-i f- e l s e

int result = 0;
if(testval > target)
    result = -1;
else if(testval < target)
    result = +1;
else
    result = 0; // match
return result;

-while

while(布尔表达式)
语句

-do while

do
语句
while(布尔表达式)

-for

for( char c = 0; c < 128; c++) {
    if (c != 26 ) // ANSI Clear screen
    System.out.println("value: " + (int)c +" character: " + c);
}

对于集合
List list = new ArrayList();            
list.add(3);  
list.add(2);  
list.add(10);  
list.add(4);  
list.add(70);  
for(Integer attribute : list) {
  System.out.println(attribute);
}

-break,continue

break 用于强行退出循环，不执行循环中剩余的语句。而continue 则停止执行当前的反复，然后退回循环起始和，开始新的反复。

-switch

switch(整数选择因子) {
case 整数值1 : 语句; break;
case 整数值2 : 语句; break;
case 整数值3 : 语句; break;
case 整数值4 : 语句; break;
case 整数值5 : 语句; break;
//..
default:语句;
}

类

-构造函数

如果没有定义构造函数，会默认生成一个无参构造函数
类可以有多个构造函数

-java访问指示符（public、private、protected）

public修饰对象、方法、字段，外部可访问
protected修饰方法、字段，继承对象可访问
private修饰对象、方法、字段，外部不可访问
类如果没有修饰，默认是包内可访问，字段和方法也是

-方法定义与重载

方法重载只能重载参数

-this关键字，super关键字

this表示对象本身
super表示父类

-static,final

static修饰静态方法，静态变量
final修饰变量表示常量，final修饰方法表示方法无法重载，final修饰对象表示对象无法继承，final修饰参数表示函数中不能修改该参数

final修饰的变量初始化
private final int i = 10;
或者
private final int i;
但所有构造函数中都需要初始化该变量

-finalize()方法

-变量初始化

定义时初始化
private int i = 10;

构造器初始化
或者
private int i；
构造函数中赋值

静态数据初始化
private static int i =10;

明确进行的静态初始化
class Cups {
static Cup c1;
static Cup c2;
static {
c1 = new Cup(1);
c2 = new Cup(2);
}
Cups() {
}
}
static 初始化只有在必要的时候才会进行。如果不创建一个Cups对象，而且永远都不引用Cups.c1 或
Cups.c2，那么static Cup c1和c2 永远都不会创建。然而，只有在创建了第一个Cups对象之后（或者
发生了第一次static 访问），它们才会创建。在那以后，static 对象不会重新初始化。

非静态数据明确进行初始化
class Cups {
Cup c1;
Cup c2;
{
c1 = new Cup(1);
c2 = new Cup(2);
}
}
比静态的少了个初始化字段，每次构造新对象都会调用。

-数组初始化

int[] a;
int a[]; （类似c++）
两种定义数组方式都是对的

基本类型数组
int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2;

对象类型数组
Integer[] a = {
new Integer(1),
new Integer(2),
new Integer(3),
};
// Java 1.1 only:
Integer[] b = new Integer[] {
new Integer(1),
new Integer(2),
new Integer(3),
};

Integer[][] a4 = {
{ new Integer(1), new Integer(2)},
{ new Integer(3), new Integer(4)},
{ new Integer(5), new Integer(6)},
};

接口

public interface Interface1 {
    void method1();
    void method2(int num);
}

抽象类

public abstract class AbstractClass1 {
    public void method1() {
        System.out.println("AbstractClass1");
    }

    public abstract void method2();
}
接口的所有方法默认是public

包定义、引用包以及类访问

package com.test.helloworld;

import com.test.tools;

不带public的class以及方法、字段，包外是无法访问的，这是隐藏细节的一个方法

继承

public class A {
    public A() {
        System.out.println("Construct A");
    };
}

public class B extends A {
    public B() {
        System.out.println("Construct B");
    }

    public static void main(String[] args) {
        B b = new B();
    }
}
会看到先调用A的构造函数，再调用B的。

public class A {
    public A(int i) {
        System.out.println("Construct A");
    };
}

public class B extends A {
    public B(int i) {
        super(i);    //显式调用
        System.out.println("Construct B");
    }

    public static void main(String[] args) {
        B b = new B(10);
    }
}
如果构造函数有参，需要显示调用父类的构造函数

可以继承一个类、多个接口
public class B extends A implements Interface1, Interface2 {
}

内部类

内部类可以隐藏实现代码
public class A {
public class B {
}
public static void main(String[] args) {
A a = new A();
A.B b = a.new B(); //构造非静态内部类
}
}
非静态内部类可以访问外部类的private方法和字段，自带指向对象外部类的指针

静态内部类不需要先构造外部类

违例控制

try{
}
catch(Exception1 e){
}
catch(Exception2 e) {
}
finally{

}
在catch区域中可以重新抛出exception到更外围违例控制处
finally区域中做资源释放等处理，防止因为违例导致资源等释放不了

• java所有对象都是继承自Object
• Object类的hashCode方法，按注释是给hash tables用的，有时需要重写以便生成自己需要的hashcode方便构建hash表
• 值类型用“==”比较相等是直接比较值，对象类型用“==”比较是比较地址，调用equals方法可以比较实际对象的内容是否相等，有些对象的equals方法需要重写