关键字

（50个，包含2个保留字）和特殊值(3个)
一、基本数据类型相关关键字(8个)
　　1、关键字介绍（1）byte：单字节类型（2）short：短整型（3）int：整型（4）long：长整型（5）char：单字符类型（6）float：单精度浮点型（7）double：双精度浮点型（8）boolean：布尔类型
　　2、基本数据类型之间的转换规则（顺带整理）
二、声明引用数据类型相关(3个)
　　（9）class：声明类（10）interface：声明接口（11）enum：声明枚举
三、特殊空类型（1个）
　　（12）void：无返回值类型
四、流程控制语句相关（10个）
　　（13）if：条件判断分支结构（14）else：条件判断分支结构（15）switch：选择结构（16）case：选择结构（17）for：循环（18）while：循环（19）do（20）break（21）continue （22）return
五、default（1个）
　　（23）default：默认的
六、关系（5个）
　　（24）extends：继承关系（25）implements：实现关系（26）instanceof：所属关系判断（27）this：引用当前对象的（28）super：引用父类的
七、创建对象（1个）
　　（29）new：创建
八、和包相关（2个）
　　（30）package：声明包（31）import：导包
九、修饰符
　　1、权限修饰符（3个）（32）private：私有的（33）protected：受保护的（34）public：公共的
　　2、其他修饰符（8个）（35）static：静态的（36）native：原生的（37）final：最终的（38）abstract：抽象的（39）synchronized：同步的（40）volatile：易变的（41）strictfp：严格遵循FP模式（42）transient：瞬时的
十、和异常处理相关的（5个）
　　（43）try：尝试执行（44）catch：尝试捕获异常对象（45）finally：最终块（46）throw：抛出（47）throws：抛出异常列表
十一、assert（1个）
　　（48）assert：断言
十二、保留字（2个）
　　（49）const：常数，不变的（50）goto：跳转
十三、特殊值（3个）
　　（51）true：真（52）false：假（53）null：空，如果null调用属性和方法会报空指针异常

关键字一共50个，其中const和goto是保留字。

true,false,null看起来像关键字，但从技术角度，它们是特殊的布尔值和空值。

一、基本数据类型相关关键字(8个)

1、关键字介绍

（1）byte：单字节类型

1个字节（8位），数据范围：[-128,127]

注意：byte类型与byte类型做算术运算结果升级为int

（2）short：短整型

2个字节（16位），数据范围：[-32768,32767]

注意：short类型与short类型做算术运算结果升级为int

（3）int：整型

4个字节（32位），数据范围：[-2的31次方 , 2的31次方 -1]

（4）long：长整型

8个字节（64位），数据范围：[-2的63次方 , 2的63次方 -1]

注意：long类型的数字后面需要加L或小写l

（5）char：单字符类型

2个字节（16位），无符号整数范围：[0,65535]，使用Unicode字符集

其中标准ASCII字符集：[0,127]，数字字符['0','9']的编码值是[48,57]，大写字母字符['A','Z']的编码值是[65,90]，小写字母字符['a','z']的编码值是[97,122]。

char类型的字符常量有三种表示方式：

（1）'a'、'尚'

（2）转义字符：

（3）使用Unicode编码值十六进制形式表示

例如：'\u5c1a' 表示 '尚'

注意：char类型与char类型做算术运算结果是int类型

（6）float：单精度浮点型

4个字节，表示最大精度范围：科学记数法表示数字后的小数点后6~7位

注意：float类型的数字后面需要加F或f

（7）double：双精度浮点型

8个字节，表示最大精度范围：科学记数法表示数字后的小数点后15~16位

（8）boolean：布尔类型

它只能有两个值：true和false

2、基本数据类型之间的转换规则

1、自动类型转换

①当存储范围小的数据(变量/表达式/常量)，赋值给存储范围大的变量时，自动升级为该存储范围大的类型

char

byte->short->int->long->float->double

②当byte与byte,short与short，char与char，byte,short,char之间一起运算了，都会自动升级为int

③当多种基本数据类型的数据一起混合运算，会自动升级为它们中最大的类型

④当基本数据类型的数据 与 String类型进行“+”拼接时，结果自动转为String类型。

⑤boolean类型不和其他基本数据类型发生转换

2、强制类型转换

①当存储范围大的数据（变量、表达式、常量）赋值给存储范围小的变量时，都是需要强制类型转换

double->float->long->int->short->byte

　　　　　　char

注意：可能会溢出，或者损失精度

②当某个数据（变量、表达式、常量）想要让它按照某个大的类型进行计算时，也可以使用强制类型转换

③boolean和String都是无法通过强制类型转换为基本数据类型的值。

二、声明引用数据类型相关(3个)

（9）class：声明类

语法格式：

【修饰符】 class 类名{
    ...
}
【修饰符】 class 类名 【extends 父类】  【implements 父接口们】{
    ...
}

类中可以有5个成员：

（1）成员变量：属性

（2）成员方法

（3）构造器

（4）代码块

（5）成员内部类

（10）interface：声明接口

语法格式：

【修饰符】 interface 接口名{
    ...
}
【修饰符】 interface 接口名 【extends 父接口们】{
    ...
}

接口的特点：

（1）接口对成员有严格的要求：

在JDK1.8之前，接口只能有全局的静态的常量(public static final)和公共的抽象方法(public abstract)；

在JDK1.8之后，接口中可以有公共的静态方法（public static）和公共的默认方法（public default）；

接口没有构造器、代码块能、其他成员，但是接口中可以声明成员内部类、成员内部接口。

（2）接口不能直接实例化，但是接口类型的变量可以与其实现类的对象之间构成多态引用

（3）接口可以继承多个父接口

（4）Java类可以同时实现多个父接口，实现类实现接口时，如果实现类不是抽象类，必须实现接口的所有抽象方法。

（11）enum：声明枚举

语法格式：

【修饰符】 enum 枚举类型名{
    ...
}
【修饰符】 enum 枚举类型名 【implements 父接口们】{
    ...
}

枚举类型的特点：

（1）枚举类型有已知的几个常量对象，必须在枚举类型的首行声明；

（2）枚举类型不能显式声明父类，因为它默认继承java.lang.Enum类型

三、特殊空类型（1个）

（12）void：无返回值类型

语法格式：

 //抽象方法
【修饰符】 void 方法名（【形参列表】）【throws 异常列表】;
​
 //非抽象方法
【修饰符】 void 方法名（【形参列表】）【throws 异常列表】{
    
}

注意：如果在返回值类型是void的方法，想要提前结束方法运行，可以使用return;

四、流程控制语句相关（10个）

（13）if：条件判断分支结构

（14）else：条件判断分支结构

语法格式：

#单分支条件判断
if(条件表达式){
    语句块;
}
​
#双分支条件判断
if(条件表达式){
    语句块1;
}else{
    语句块2;
}
​
#多分支条件判断
if(条件表达式1){
    语句块1;
}else if(条件表达式2){
    语句块2;
}else if(条件表达式3){
    语句块3;
}
...
else{
    语句块n+1;
}

（15）switch：选择结构

（16）case：选择结构

语法格式：

switch(表达式){
    case 常量值1:
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】
    ...
    【default:
        语句块n+1;
        【break;】
        】
}

执行过程：

（1）入口

①当switch(表达式)中表达式的值与case后面的某个常量值匹配了，就从这个case进入；

②当switch(表达式)中表达式的值与所有case后面的常量值都不匹配，就从default进入，不管default部分在哪里。

（2）一旦找到入口，就会顺序往下执行，直到遇到出口

（3）出口

①自然出口：switch的结束}

②中断出口：break;

注意：

①switch(表达式)中表达式的结果的类型有要求：四种基本数据类型(byte,short,int,char)和两种引用数据类型(JDK1.7后支持String，JDK1.5后支持枚举)

②case后面必须是常量值或常量表达式，绝对不能是变量

③case后面的常量值不能重复

（17）for：循环

1、普通for循环

语法格式：

for(【初始化表达式】; 【循环条件】; 【迭代表达式】){
    循环体语句块；
}

执行过程：

（1）先执行【初始化表达式】

（2）判断【循环条件】

（3）如果【循环条件】成立，就执行{循环体语句块；}，之后执行【迭代表达式】，然后回到（2）

如果【循环条件】不成立，就直接结束for循环

注意：

（1）for(;;)两个分号不能省略，但也不能多了

（2）如果for(;;)中间的循环条件没写，就是表示条件永远成立，如果{}中没有break，return等就会死循环

2、增强for循环

语法格式：

for(元素数据类型  元素名 : 数组或集合等容器名){
    循环体语句块;
}

说明：

（1）常用于遍历数组和集合等容器，其实只要是实现了java.lang.Iterable接口的容器对象都可以使用foreach来进行遍历，其实调用的是java.util.Iterator迭代器的hasNext()和next()方法

（2）在使用foreach遍历集合时，不要同时调用集合涉及到修改元素个数的方法

错误示例：

ArrayList list = new ArrayList();
for(Object obj : list){
    list.add(xx);//错误
    list.remove(xx);//错误
}

（18）while：循环

语法格式：

while(循环条件){
    循环体语句块;
}

执行过程：

（1）先判断循环条件

（2）如果条件成立，执行{循环体语句块;}，然后回到（1）

如果条件不成立，直接结束while循环。

（19）do

语法格式：

do{
    循环体语句块;
}while(循环条件);

执行过程：

（1）先上来就执行一次{循环体语句块;} 说明do...while系列的循环，至少执行一次循环体语句块;

（2）判断循环条件

（3）如果条件成立，再次执行{循环体语句块;} ，然后回到（2）

如果条件不成立，那么直接结束do..while

注意：

（1）do...while系列的循环，至少执行一次循环体语句块;

（2）while(循环条件); 后面的;不能省略

（3）如果是在{循环体语句块;}中声明的局部变量，是不能在while()中使用的，如果要在while()中使用这个变量，那么需要提取到do{}上面声明；

（20）break

用法：

（1）switch：结束当前switch

（2）循环：结束当前（层）循环

如果break在内循环中，只能结束内循环；

如果break在外循环中内循环外，可以结束外循环;

如果break结合标签，那么可以直接结束标签对应的循环;

（21）continue

用法：

只能用在循环中：提前结束本次循环，跳过了本次循环剩下的循环体语句

（22）return

形式：

（1）return ;

用于提前结束返回值类型是void的方法。

可选：返回值类型为void方法中，可能有return;，也可能没有;

（2）return 返回值;

用于提前结束返回值类型不是void的方法，并且会返回结果。

必选：返回值类型不是void的方法中，必须有return 返回值;语句

五、default（1个）

（23）default：默认的

用法：

1、switch...case流程控制语句结构中

2、JDK1.8之后接口中用于声明默认方法

3、在注解中用于声明某个配置参数的默认值

六、关系（5个）

（24）extends：继承关系

语法格式：

【修饰符】 class 子类  extends 父类{
    
}
【修饰符】 interface 子接口  extends 父接口{
    
}

（25）implements：实现关系

语法格式：

【修饰符】 class 子类  【extends 父类】 implements 接口们{
    
}

（26）instanceof：所属关系判断

语法格式：

if(对象  instanceof 类型名){
}
只有这个对象属于这个类型，就返回true

提示：一般用于在向下转型之前，加这个判断可以避免ClassCastException异常

（27）this：引用当前对象

this关键字：当前对象（1）在构造器或非静态代码块中，表示正在创建的对象（2）在成员方法中，表示正在调用当前方法的对象

this的用法：（1）this.属性 或 this.成员变量当局部变量与成员变量重名时，那么可以在成员变量的前面加this.进行区分

this.属性，如果在本类中没有找到，也可能表示引用从父类继承到子类中可见的属性

（2）this.成员方法()可以省略this.，表示访问当前对象的其他成员方法

this.方法，如果在本类中没有找到，也可能表示引用从父类继承到子类中可见的方法

（3）this()或this(实参列表)当需要调用本类的其他构造器，可以在当前构造器的首行用this()或this(实参列表)进行调用

this()和this(实参列表)只会在本类中查找

（28）super：引用父类

super关键字：引用父类的，找父类的xx

super的用法：

1、super.属性

如果子类声明了一个属性，它和从父类继承的属性同名了，这个时候从父类继承的属性会被hidng(隐藏)，如果此时在子类中想要使用它，那么就要用super.属性。

super.属性也是访问不了父类的私有的属性，如果跨包，super.属性也访问不了父类权限修饰符缺省的属性

super.属性，如果在直接父类中没有找到，还会向上往间接父类继续查找

2、super.方法

如果子类重写了从父类继承的某个方法后，在子类中又想要调用父类被重写的方法时，那么就可以使用super.方法

父类私有的方法是不能被重写的，父类私有的方法通过super.方法也是无法访问的

如果跨包，父类权限修饰符缺省的方法也不能被重写和通过super.方法访问到

super.方法，如果在直接父类中没有找到，还会向上往间接父类继续查找

3、super()或super(实参列表)

在子类的构造器的首行，

通过super()调用父类的无参构造器，super()这个可以省略。

通过super(实参列表)调用父类的有参构造，super(实参列表)不能省略。

注意：super()和super(实参列表)只能从直接父类找，不能跨过直接父类去引用间接父类的

七、创建对象（1个）

（29）new：创建

用于创建数组对象、类的对象

创建的对象会存储在堆中。

八、和包相关的（2个）

（30）package：声明包

1、包的作用：（1）避免类的重名（2）控制某些类、成员的可见范围（3）分包进行组织管理众多的类

2、声明包的语法格式：

package 包名;

注意：package语句必须在.java源文件的首行

3、包的命名规范和习惯：（1）所有单词都小写，每个单词之间使用.分割（2）习惯用公司域名倒置 + 模块名

（31）import：导包

4、使用其他包的类：（1）使用全名称：包.类名（2）使用import语句 + 简名称

5、import语句

import 包.类名;
import 包.*;
import static 包.类名.静态成员名;
import static 包.类名.*;

注意：当使用两个不同包的同名类时，例如：java.util.Date和java.sql.Date，只能一个使用全名称，一个使用导包。

九、修饰符

1、权限修饰符（3个）

（32）private：私有的

（33）protected：受保护的

（34）public：公共的

权限修饰符	本类	本包中其他类	其他包的子类	其他包的非子类（任意位置）	可以修饰
private	√	×	×	×	属性、方法、构造器、成员内部类
缺省	√	√	×	×	属性、方法、构造器、成员内部类、外部类
protected	√	√	√	×	属性、方法、构造器、成员内部类
public	√	√	√	√	属性、方法、构造器、成员内部类、外部类

2、其他修饰符（8个）

（35）static：静态的

static：静态的，可以修饰成员变量、成员方法、代码块、成员内部类

static只能修饰内部类，不能修饰顶级类

static是一个修饰符，可以修饰：

• 成员变量，我们称为类变量，或静态变量，表示某个类的所有对象共享的数据

• 成员方法，我们称为类方法，或静态方法，表示不需要实例对象就可以调用的方法。类名.

• 代码块，我们称为静态代码块，或静态初始化块，用于为静态变量初始化，每一个类的静态代码块只会执行一次，在类第一次初始化时执行

• 成员内部类，我们称为静态成员内部类，简称静态内部类，不需要外部类实例对象就可以使用的内部类，在静态内部类中只能使用外部类的静态成员

（1）成员变量，属性：static修饰的成员变量称为“类变量，或静态变量”，

它的值是该类所有对象的共享的，存储在方法区，

它的get/set方法也是静态的，如果在静态方法中，类变量与局部变量重名时，使用“类名.”进行区别。

（2）成员方法：static修饰的成员方法称为“类方法，或静态方法”，它不能被重写，可以被继承，

调用它可以用“类名.”进行调用，

在静态方法中，不能出现this,super,不能直接使用本类的非静态的属性、非静态的方法、非静态的成员内部类。

（3）代码块：static修饰的代码块称为“静态代码块”，它是在类初始化时执行，因为它的代码会被编译器合并到<clinit>()类初始化方法中，它只执行一次，子类的初始化时，如果发现父类没有初始化，会先初始化父类。

（4）成员内部类

static修饰的成员内部类称为“静态内部类”，

静态内部类中可以包含静态成员；

静态内部类在外部类外面使用时，使用“外部类名.静态内部类"即可。

语法格式：

【修饰符】 class 类{
 【修饰符】 static 数据类型 静态变量;
    
    static{
        静态代码块;
    }
    
    【修饰符】 static 返回值类型 方法名(【形参列表】)【throws 异常列表】{
        
    }    
    
    【修饰符】 static class 静态内部类{
        
    }
}    

（36）native：原生的

native：本地的，原生的只能修饰方法，表示这个方法的方法体不是用Java语言实现的，但是可以和普通的Java方法一样去调用和重写它。

（37）final：最终的

final：最终的，可以修饰类、方法、变量（1）类（包括外部类、内部类）：表示不能被继承

（2）方法：不能被子类重写，可以被继承

（3）变量（包括成员变量和局部变量）：值不能修改，即为常量建议常量名大写，每个单词之间使用_分割，形式：XXX_YYY_ZZZ
　　如果变量是引用类型，变量地址值不可改变但指向的值可以改变，例如数组变量arr地址值不可变，但arr[0]元素值可以改变

（38）abstract：抽象的

abstract：抽象的，只能修饰类、方法

（1）方法：

abstract修饰的方法称为“抽象方法”

【权限修饰符】 abstract class 抽象类{
    【修饰符】 abstract 返回值类型  方法名(【形参列表】)【throws 异常列表】;
}
​
【权限修饰符】 interface 接口名{
    public abstract 返回值类型  方法名(【形参列表】)【throws 异常列表】;
}

特点：

抽象方法没有方法体，

包含抽象方法的类必须是抽象类，

子类继承抽象类或实现类实现接口时，如果该子类或实现类不是抽象类，那么必须实现抽象父类和接口的所有抽象方法。

（2）类：

abstract修饰的类称为“抽象类”。

语法格式：

【权限修饰符】 abstract class 抽象类{
    
}
【权限修饰符】 abstract class 抽象类 【extends 父类】 【implements 父接口们】{
    
}

特点：

（1）拥有一个或者多个抽象方法的类“必须”是抽象类

（2）抽象类不能直接创建对象，即不能实例化，但是抽象类的变量可以与子类的对象构成多态引用。

（3）有时抽象类中没有抽象方法，（目的只有一个：不让你创建对象）

（4）抽象类就是用来被继承的，子类继承抽象类时，必须对父类的抽象方法进行实现，否则子类也得是抽象类

（5）抽象类也是类，因此原来类中可以有的5大成员，抽象类都可以有

（39）synchronized：同步的

synchronized：同步的，可以修饰方法和同步代码块

（1）同步方法

【修饰符】 synchronized 返回值类型 方法名(【形参列表】)【throws 异常列表】{
...
}

同步方法的锁对象：

静态方法：当前类.class

非静态方法：this

（2）同步代码块

synchronized(锁对象){
    
}

（40）volatile：易变的

volatile：易变的，不定性的，可以修饰成员变量

表示该成员变量的值是易变的，每一次获取它的值都要从主存中重新读取，以保证在多线程中，不同线程读取到的该值都是最新的。

因为Java中多线程读取某个成员变量时，发现一段时间内它的值都未发生变化，Java执行引擎就会把这个值放在缓存中，以后的线程读取，就会读取这个缓存值，即使这个时候某个线程修改了该变量主存中的值，Java执行引擎仍然会去读取缓存的值，而如果希望线程总是读取最新的该变量的值，那么可以在变量前面加volatile，使得Java执行引擎都从主存中读取，而不缓存。

（41）strictfp：严格遵循FP模式

strictfp：表示要求严格遵循FP模式，可以修饰类、接口、方法

使用 strictfp 关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。

当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示。如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp。

（42）transient：瞬时的

transient：表示瞬时的，临时的，短暂的，转瞬即逝的;

用于修饰成员变量；

transient修饰的成员变量的值，如果该类实现的是java.io.Serializable接口，那么在序列化过程中该成员变量不会参与序列化。

修饰符一起使用问题

修饰符	外部类	成员变量	代码块	构造器	方法	局部变量
public	√	√	×	√	√	×
protected	×	√	×	√	√	×
private	×	√	×	√	√	×
static	×	√	√	×	√	×
final	√	√	×	×	√	√
abstract	√	×	×	×	√	×
native	×	×	×	×	√	×

不能和abstract一起使用的修饰符？

（1）abstract和final不能一起修饰方法和类

（2）abstract和static不能一起修饰方法

（3）abstract和native不能一起修饰方法

（4）abstract和private不能一起修饰方法

static和final一起使用：

（1）修饰方法：可以，因为都不能被重写

（2）修饰成员变量：可以，表示静态常量

（3）修饰局部变量：不可以，static不能修饰局部变量

（4）修饰代码块：不可以，final不能修饰代码块

（5）修饰内部类：可以一起修饰成员内部类，不能一起修饰局部内部类

---

十、和异常处理相关的（5个）

（43）try：尝试执行

（44）catch：尝试捕获异常对象

（45）finally：最终块

//形式1：
try{
    语句块;
}catch(异常类型1 异常对象名1){
    处理异常代码块1;
}catch(异常类型1 异常对象名1){
    处理异常代码块1;
}
...
​
//形式2：
try{
    语句块;
}catch(异常类型1 异常对象名1){
    处理异常代码块1;
}catch(异常类型1 异常对象名1){
    处理异常代码块1;
}
...
finally{
    最终语句块;
}
​
//形式3：
try{
    语句块;
}finally{
    最终语句块;
}
​

try：尝试执行某些代码，如果发生异常，将会抛出异常对象，让catch去捕获；

catch：尝试捕获try中抛出的异常对象，如果类型匹配，就可以捕获，当前方法不会结束；如果所有catch都无法捕获，将会结束当前方法。

finally：无论try中是否有异常抛出，也无论是否catch捕获了该异常，也无论try和catch中是否有return语句都会执行。

JDK1.7之后引入新try..catch

语法格式：

try(需要关闭的资源对象的声明){
    业务逻辑代码
}catch(异常类型 e){
    处理异常代码
}catch(异常类型 e){
    处理异常代码
}
....

它没有finally，也不需要程序员去关闭资源对象，无论是否发生异常，都会关闭资源对象

（46）throw：抛出

用于手动抛出异常

throw 异常对象;

throw可以用于抛出异常对象，如果它抛出的异常，没有被catch的话，可以代替return语句结束当前方法，并将把异常对象带回调用处。

用户自定义异常只能使用throw语句手动抛出。

（47）throws：抛出异常列表

用于在方法签名中，声明该方法将抛出哪些类型的异常。

【修饰符】 返回值类型 方法名(【形参列表】) throws 异常类型列表{
    
}

表示这些异常在当前方法中没有处理，交给调用者进行处理。

十一、assert（1个）

（48）assert：断言

如果它断言的表达式为false，将会抛出java.lang.AssertionError对象。

语法格式：

assert 布尔表达式;
或
assert 布尔表达式 : "错误信息";

注意：要开启断言功能，在eclipse中需要加JVM参数 -ea

十二、保留字（2个）

（49）const：常数，不变的

在C语言等其他很多编程语言中用于声明常量。在Java中没有使用它。

（50）goto：跳转

在C语言等其他很多编程语言中用于跳转到指定位置。在Java中没有使用它。

十三、特殊值（3个）

（51）true：真

（52）false：假

boolean值，通常用来作为条件。

boolean类型的变量，比较表达式（>,<,>=,<=,==,!=），逻辑表达式（&&,&,||,|,^,!），instanceof，这些都是boolean值。

（53）null：空，如果null调用属性和方法会报空指针异常

这三个看似关键字，但是从技术角度来说，不能算是关键字，是特殊值。

最新文章

1. php文件上传参考配置与大文件上传
2. react.js table组件【可以直接使用】
3. java-获取随机字符串
4. Python中，添加写入数据到已经存在的Excel的xls文件，即打开excel文件，写入新数据
5. 《QQ欢乐斗地主》山寨版
6. html5之datalist标签
7. Global Financial Applications uses the following Public tables
8. jQuery手机触屏拖动滑块验证跳转插件
9. Django和Flask框架学习目录
10. 二、java三大特性--继承
11. Jenkins 安装简记录
12. cp -rf 提示覆盖解决办法
13. 在python pydev中使用todo标注任务
14. Windows下CVSNT安装配置
15. 推荐系统之矩阵分解及其Python代码实现
16. LINUX使用DVD光盘或者ISO作为本地YUM源
17. QT编译发布程序后报错如缺少dll、“应用程序无法正常启动(0xc000007b)”的可能解决方法
18. (14) go 结构体
19. 带你走进ajax(2)
20. hdu4309

热门文章

1. Cygwin安装教程
2. 【论文阅读】Learning Dual Convolutional Neural Networks for Low-Level Vision
3. 《手把手教你》系列练习篇之2-python+ selenium自动化测试（详细教程）
4. Java基础面试题及答案（五）
5. CentOS 7上利用systemctl添加自定义系统服务
6. 错误 找不到Xcode No such file or directory
7. unity3D 游戏物体同时绑定单击、双击事件
8. docker镜像、docker容器导入导出命令
9. MRC ARC 混编
10. 第八章 使用jQuery操作DOM