Java 中的关键字（下）

24.implements

implements用于接入接口。接上接口的类必须实现接口的抽象方法（可以不实现默认方法和静态方法）。

class A implements B{
    @Override
    do(){
        ...
    }
}

25.import

用于导入包。

import android.content.Intent;

26.instanceof

instanceof用于判断类与对象的关系。例如：

a instanceof b

若a是b的一个实例(或子类对象)，则整个表达式的结果是true，否则结果为false。

27.int

int是Java的基本类型之一（默认值为0）。表示32位、有符号的整数。

范围：[-231,231-1)

int a = 1;

28.interface

interface用于声明一个接口，例如：

public interface A{
    void b();
}

声明a为一个接口，若接上该接口，则必须实现其中的抽象方法b。

接口中的成员变量是static、final、public的。接口中的方法为静态方法或默认方法和静态方法(API>=24)。

29.long

long是Java的基本类型之一（默认值为0L），表示64位、有符号的整数。

范围：[-263,263)

long a = 3216846849646L;

30.native

native可以让Java运行非Java实现的方法。例如c语言，要编译后用javah产生一个.h文件。导入该.h文件并且实现native方法，编译成动态链接库文件。在Java加载动态链接库文件，这个native方法就可以在Java中使用了。

public native void aVoid();

31.new

new用于生成类的实例。

Object a = new Object()；

32.package

package用于规定当前文件的包。

package com.example.zhangyijun.testdefactivity;

33.private

访问控制的一种。

私有的方法和变量只能在本类中访问。类和接口不能为私有。

private int a = 1;
private void b(){
    ...
}

34.protected

访问控制的一种。

受保护的方法和变量只能给子类和基类访问。

protected int a = 1;
protected void b(){
    ...
}

35.public

访问控制的一种。

公有的方法、类、变量、接口能够被任何其他类访问。

36.return

方法中返回数据，并结束方法。

37.strictfp

使用strictfp关键字来声明一个类、接口或者方法时，那么该类、接口或者方法会遵循IEEE-754标准来执行，提高浮点运算的精度，并且减少不同硬件平台之间由于浮点运算带来的差异。

public strictfp double aDouble(){
    return 0d;
}

38.short

short是Java的基本类型之一（默认值0）,表示16位、有符号的整数。

范围：[-215,215)

short a = 0;

39.static

static修饰的语句块存放在堆的方法区中。

1. 静态变量：依附在类中的变量，可以被类的所有的实例共用。

static int a = 0;

1. 静态方法：依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。

1. publlic static void b(){
2.     ...
3. }
4.

1. 静态块：在类加载的时候执行块中的语句，块中不能访问非静态变量。

1. static{
2.     ...
3. }

1. 静态内部类：用static修饰内部类。

40.super

super即超类

1. 引用父类的的成员：

super.xxx

1. 变量或方法重名时用super调用父类的成员或方法。

2. 调用父类的构造方法:

super(xxx);

41.switch

switch用于分支结构，判断某个变量与一系列值是否相等。switch 语句中的变量类型可以是： byte、short、int 、char、String、enum。

switch(变量){
  case value1:语句1;
    break;
  case value2:语句2;
    break;
  ...
  default:语句;
}

1. 若变量和case后的值相等则执行语句。
2. 当语句执行到break时跳到switch块后，如果没有break会产生穿透现象。
3. default分支必须为最后一个分支，在没有值和case变量相等时执行该语句。

42.synchronized

synchronized关键字用于保证线程安全。由这个关键字修饰的方法或者代码块保证了同一时刻只有一个线程执行该代码。

synchronized(obj){...}

当一个线程访问同步代码块时，检查obj是否有锁，如果有就挂起。如果没有就获得这个obj的锁，也就是把其他线程锁在了外面。当代码执行完毕时释放该锁，其他线程获得锁继续执行代码。

43.this

1. 指向当前对象：this.xxx
2. 形参和成员名字重名时时用this区分。
3. 引用构造函数。

44.throw

用于抛出一个异常。

throw (Exception);

45.throws

在方法中将发生的异常抛出。

[控制访问](返回类型)(方法名)([参数列表])[throws(异常类)]{...}

46.transient

类接上序列化接口后，可以通过transient关键字将某些变量变得无法序列化。

transient int a = 1;

47.try

在try/catch中，将可能出现异常的语句放在try{}块中，出现异常之后代码将会终止并跳到catch中继续执行。

try{
    ...
}catch(Exception e){
    ...
}finally{
    ...
}

48.void

修饰方法，表示方法没有返回值。

49.volatile

volatile关键字修饰的变量在多线程中保持同步。相比synchronized效率要高，不会阻塞线程。但只能保证数据的可见性，不能保证数据的原子性。例如在处理i++的时候另外一个线程修改i的值，那么i的值将会发生错误，这是原子性导致的。

volatile int a;

50.while

while用于两种循环结构：

while(判读语句){
    循环体...
}
do{
  循环体...
}while(判读语句)

二、查漏补缺

1.多态

多态就是同一个行为，使用不同的实例而发生不同的作用。在使用多态调用方法的时候，编译器检查父类中是否有该方法，如果有才能编译通过，例如：

public class Animals{
    void voice(){动物叫}
}
class Cat extends Animals{
    void voice(){猫叫}
}
public static void testVoice(Animals a){
    a.voice();
}
public static void main(String[] args) {
    testVoice(new Cat())；
    Animals a = new Cat();
    a.voice();
}

猫继承自动物这个类，Animals a = new Cat()是向上转型（父类引用指向子类对象），实际的运行时类型还是Cat，也就是说a instanceof Cat 表达式为真，因此调用a的voice()方法是猫叫。结合C的指针和内存分析来理解多态。

2.泛型

1. 类型通配符

• <? extends T>表示该通配符所代表的类型是T类型的子类。
• <? super T>表示该通配符所代表的类型是T类型的父类

public static <T extends Closable> void close(T... a){
    for(T temp:a){
        try{
            if(temp!=null){
                temp.close();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

1. 泛型不能用在静态属性上
2. 指定的类型不能为基本类型

3.反射

1. 获取目标类型的Class对象

1. Class<?> a = Object.getClass();
2. Class<?> b = T.class;
3. Class<?> c = Class.forName(...);

通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

不带 "Declared"的方法支持取出包括继承、公有（Public） & 不包括有（Private）的构造函数

带 "Declared"的方法是支持取出包括公共（Public）、保护（Protected）、默认（包）访问和私有（Private）的构造方法，但不包括继承的构造函数

• Constructor

//a.获取指定的构造函数（公共/继承）
Constructor<T> getConstructor(Class<?>... parameterTypes);
//b.获取所有的构造函数（公共/继承） 
Constructor<?>[] getConstructors(); 
//c.获取指定的构造函数（不包括继承）
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
//d.获取所有的构造函（不包括继承）
Constructor<?>[] getDeclaredConstructors(); 

• Field

//a.获取指定的属性（公共/继承）
Field getField(String name);
//b.获取所有的属性（公共/继承）
Field[] getFields();
//c.获取指定的所有属性（不包括继承）
Field getDeclaredField(String name);
//d.获取所有的所有属性（不包括继承）
Field[] getDeclaredFields();

• Method

//a.获取指定的方法（公共/继承）
Method getMethod(String name, Class<?>... parameterTypes);
//b.获取所有的方法（公共/继承）
Method[] getMethods();
//c.获取指定的方法 （不包括继承）
Method getDeclaredMethod(String name, Class<?>... parameterTypes);
//d.获取所有的方法（不包括继承）
Method[] getDeclaredMethods();

4. 集合

1. 迭代器遍历ArrayList

Iterator<String> iterator = list.iterator();
while(ite.hasNext()){
    Log.d("TAG",ite.next());
}

1. 遍历Map

//第一种：map.keySet()
for (String key : map.keySet()) {
    System.out.println("key= "+ key + " value= " + map.get(key));
}
//第二种：map.entrySet().iterator()
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry<String, String> entry = it.next();
    System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
}
//第三种：map.entrySet()
for (Map.Entry<String, String> entry : map.entrySet()){
    System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
}
//第四种：map.values()
for (String v : map.values()) {
    System.out.println("value= " + v);
}

遍历 hashMap() 时 entrySet() 方法是将 key 和 value 全部取出来,所以性能开销是可以预计的, 而 keySet() 方法进行遍历的时候是根据取出的 key 值去查询对应的 value 值, 所以如果 key 值是比较简单的结构(如 1,2,3…)的话性能消耗上是比 entrySet() 方法低, 但随着 key 值得复杂度提高 entrySet() 的优势就会显露出来。

在只遍历 key 的时候使用 keySet(), 在只遍历 value 的时候使用 values(), 在遍历 key-value 的时候使用 entrySet()。

5.正则

RegexBuddy

1. 转义字符

1. \n  \t  \\  \^  \$  \(  \)  \{  
2. \}  \?  \+  \*  \|  \[  \]

1. 标准字符集合（大写取反）

6.引用分类

强引用:StrongReference:引用指向对象，gc运行时不回收

软引用:SoftReference:gc运行时回收，（jvm内存不够）

弱引用:WeakReference:gc运行时立即回收

虚引用:PhantomReference:跟踪对象被回收的状态，必须与ReferenceQueue一起使用