1. DOS常用命令

1.1.什么是DOS？

DOS，是磁盘操作系统（Disk Operating System）的缩写，是个人计算机上的一类操作系统。
DOS下的可执行文件有三种，分别是EXE、COM和BAT(当前也支持CMD扩展名)。其中，EXE和COM文件都是二进制形式的，只有BAT文件是文本形式的，可以直接阅读。因此，BAT文件和以上二进制可执行文件相比，内容要简单的多。这些文件内包含着DOS命令的集合，通常叫做批处理文件。
DOS中是通过输入英文命令加回车键这种方式来执行程序的，凡后缀为exe、com或bat的文件都是可以直接执行的。这些以exe为后缀的文件叫可执行文件；以com为后缀的文件叫命令文件；以bat为后缀的文件叫批处理文件。如果我们要执行这些文件，只需在提示符下敲入文件基本名然后回车即可，不需输入文件后缀。
DOS（磁盘操作系统）命令，是DOS操作系统的命令，是一种面向磁盘的操作命令，主要包括目录操作类命令、磁盘操作类命令、文件操作命令和其它命令。

1.2.常用的命令

2. JVM、JRE、JDK之间的关系

2.1.概念

JDK（java development kit）
JDK是Java开发工具包,是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。
JRE（java runtime environment）
JRE是Java的运行环境，包括JVM标准实现及Java核心类库。
JVM（java virtual machine）
JVM是java虚拟机，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。

2.2.概念图

2.3.关系图

2.4.结构

JDK=JRE+JAVA的开发工具（javac.exe,java.exe,javadoc.exe等）
JRE=JVM+JAVA核心类库

3. Java开发环境的搭建

安装JDK，配置环境变量，百度搜索一大堆，这家就不详细说明。大致步骤：
1、安装JDK；
2、系统变量->新建 JAVA_HOME 变量 ，其中变量值填写jdk的安装目录；
3、系统变量->编辑Path变量，在变量值最后输入
%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
4、系统变量->新建 CLASSPATH 变量，变量值填写
.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar;

4. Java入门程序

一般来说，很多开发者的第一个程序都是通过记事本实现，大概步骤是：新建一个记事本，写入以下代码，然后保存关闭并且把扩展名修改为java，通过CMD javac编译生成.class的文件，最后CMD java运行程序（即运行java命令运行.class文件）。

5. 命名规范

参考阿里巴巴Java开发手册（华山版）链接：https://maxteng.lanzoui.com/iaxLnp9e2kf

6. Java基本数据类型

JAVA是强类型语言，指的是一旦一个常量或变量声明出来，它的类型就确定了，以后都不会变成其它类型，声明的时候是整型，以后都是整型。简单来讲变量是申请内存来存储值，当创建变量时，需要在内存中申请空间。内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。JAVA语言提供了八种基本数据类型：六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

6.1.byte类型

byte也可以说是一个字节，一个字节等于二进制的八位，有负号的以补码的形式展示，取值范围是-218 ~ 127，并且byte变量所占用的空间只有 int 类型的四分之一。在计算机中，任何数据都是以二进制存储的，对于整型来说，正数存的是它的二进制原码，负数存储的是它的绝对值的二进制补码（公式：负数的补码 = 先绝对值，再取反，再加1）。

6.2.short类型

短整型，数据类型有16位，有符号的以二进制补码表示的整数。默认值是0，short数据类型也可以像byte数据类型一样节省空间，一个short数据类型变量是int类型变量所占空间的四分之一。
范围：0111 1111 1111 1111（-32768或者-2（15））~ 1000 0000 0000 0000（32767或者2（15）-1）

6.3.char类型

char 类型是一个单一的 16 位 Unicode 字符，char也可以当作短整型看，但是char是无符号整型，所以能表示范围是0~65535，即最小值是 \u0000（十进制等效值为 0），最大值是 \uffff（即为 65535），char 数据类型可以储存任何字符。也就是说我们的字符最多能表示65536个字符，其中中文占了大概40000多个 0-127 是早期计算机能够键入的128个字符，称作ascii码。内存中只能存二进制的数，所以任何的数据都要转成二进制，字符也不例外。我们没办法在内存中直接存一个’中’，所以会将’中’对应一个整型数值，然后再把这个数值的二进制存进内存。’中’到底对应什么数值？这由各国或者标准组织制定的编码决定。假设中国的国标码gb2312把'中' ==》23432，然后国际上的utf-8把'中'==》20013，如果存进内存存的是gb2312,从内存中读出来使用utf-8,这就会导致乱码。

char在代码是如何表示
char c = 'A'; //最基本的表示法
char c = 65;//用整型数值表示
char c = '\u0041';//采用16进制的unicode码

在计算里，很多字符是当中程序的特殊用途，或者有一些字符通过键盘是输入不了的，此时就需要用一些普通字母加上\，结合在一起表示一种特殊的字符，例如回车\r ,换行用\n, 制表符\t。

6.4.int类型

平常见到整型常量，它默认都是int类型。int 数据类型是32位、有符号的以二进制补码表示的整数。
范围：-2（31） ~ 2（31）-1 （或者 -2,147,483,648~2,147,483,647）。

整型在代码中的表示方式：
int i = 97;
int i = 097;//打头的0表示这个数是一个八进制数
int i = 0xC4F;//0x 表示这个数是一个十六进制数
int i = 101011101;//是十进制，非二进制

6.5.long类型

long 数据类型是 64 位、有符号的以二进制补码表示的整数，这种类型主要使用在需要比较大整数的系统上，例如：时间的毫秒数经常long表示。如果要表示一个长整型，需要在数值的后面加上L，”L”理论上不分大小写，但是若写成”l”容易与数字”1”混淆，不容易分辩，所以最好大写，默认值是 0L。
范围：-2（63） ~ 2（63）-1。

6.6.float类型

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数，float 在储存大型浮点数组的时候可节省内存空间，但是浮点数不能用来表示精确的值，如货币。float 数据类型虽然是32位，但存储方式跟整型完全不同。如果要表示一个float 数据类型，必须在数值后面加F。

6.7.double类型

double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数，表示的范围要比long类型(也是64)要大，主要是跟它的存储的方式。浮点数的默认类型为 double 类型，double类型同样不能表示精确的值，如货币。如果要表示一个double 数据类型，必须在数值后面加D。

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的”E+数字”表示E之前的数字要乘以10的多少次方。实际上，JAVA中还存在另外一种基本类型 void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

public class PrimitiveTypeTest {  
    public static void main(String[] args) {  
        // byte  
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);  
        System.out.println("包装类：java.lang.Byte");  
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);  
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);  
        System.out.println();  
        // short  
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE);  
        System.out.println("包装类：java.lang.Short");  
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);  
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);  
        System.out.println();  
        // int  
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);  
        System.out.println("包装类：java.lang.Integer");  
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);  
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);  
        System.out.println();  
        // long  
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE);  
        System.out.println("包装类：java.lang.Long");  
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);  
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);  
        System.out.println();  
        // float  
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE);  
        System.out.println("包装类：java.lang.Float");  
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);  
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);  
        System.out.println();  
        // double  
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE);  
        System.out.println("包装类：java.lang.Double");  
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);  
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);  
        System.out.println();  
        // char  
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE);  
        System.out.println("包装类：java.lang.Character");  
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台  
        System.out.println("最小值：Character.MIN_VALUE=" + (int) Character.MIN_VALUE);  
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台  
        System.out.println("最大值：Character.MAX_VALUE=" + (int) Character.MAX_VALUE);  
    }  
}
/*
运行结果：
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
*/

下表列出了 Java 各个类型的默认值：

6.8.boolean类型

boolean数据类型表示一位的信息，只有两个取值：true 和 false，这种类型只作为一种标志来记录 true/false 情况。

6.9.引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。类（class）、接口（interface）、数组都是引用数据类型。所有引用类型的默认值都是null。一个引用变量可以用来引用任何与之兼容的类型。例子：Site site = new Site("Runoob")。

6.10.类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。

数据类型转换必须满足如下规则：
1、不能对boolean类型进行类型转换。
2、不能把对象类型转换成不相关类的对象。
3、在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4、转换过程中可能导致溢出或损失精度，例如：int i =128; byte b = (byte)i;因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
5、浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23; (int)-45.89f == -45；

6.10.1.自动类型转换

类型要兼容，小变大。也就是说必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

6.10.2.强类型转换

类型要兼容，大变小，注意精度可能会丢失。格式：(type)value type是要强制类型转换后的数据类型。

6.10.3.隐性强类型转换

1、 整数的默认类型是 int。
2、小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。

7. 变量和常量的定义及初始化

7.1.变量的定义

在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元被称为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。简单来说，变量是内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），Java中每个变量必须先声明，后使用， 该区域的数据可以在同一类型范围内不断变化。

7.2.变量的分类

7.2.1.按数据类型分类

对于不同的数据类型，在内存中分配了不同大小的内存空间。数据类型分为基本数据类型和引用数据类型（数据类型参考第6节内容）。

7.2.2.按声明的位置分类

在方法体外，类体内声明的变量称为成员变量；在方法体内部声明的变量称为局部变量。

局部变量：
局部变量声明在方法、构造方法或者语句块中。局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。访问修饰符不能用于局部变量。局部变量只在声明它的方法、构造方法或者语句块中可见。局部变量是在栈上分配的。局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

实例变量：
实例变量声明在一个类中，但在方法、构造方法和语句块之外。当一个对象被实例化之后，每个实例变量的值就跟着确定。实例变量在对象创建的时候创建，在对象被销毁的时候销毁。实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息。实例变量可以声明在使用前或者使用后。访问修饰符可以修饰实例变量。实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见。实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定。实例变量可以直接通过变量名访问。
但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

类变量（静态变量）：
类变量也称为静态变量，在类中以static关键字声明，但必须在方法之外。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static类型的变量。静态变量初始化后不可改变。静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static声明变量。静态变量在第一次被访问时创建，在程序结束时销毁。与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。静态变量可以通过：ClassName.VariableName的方式访问。类变量被声明为 public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

7.2.3.按声明格式分类

定义变量的格式：数据类型 变量名 = 初始化值。
变量在内存中的区域:

7.3.常量

常量是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变，一般用大写字符。
语法：final 常量名 = 值;如：final String LOVE = "java";
注意：必须要在常量声明的时候就对其进行初始化，否则会出现编译错误。常量一旦初始化后就无法再改动

字符型常量的三种表现形式：
1、字符常量是用单引号('')括起来的单个字符，涵盖世界上所有书面语的字符。
例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
2、Java中还允许使用转义字符'\'来将其后的字符转变为特殊字符型常量。
例如：char c3 = '\n'; // '\n'表示换行符
3、直接使用 Unicode 值来表示字符型常量：'\uXXXX'。其中，XXXX代表一个十六进制整数。如：\u000a表示\n；

8. Java的运算符

java的运算符可以分为算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、其他运算符这几类。

8.1.算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

比较特殊的算术运算符：自增（++）自减（—）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。前缀自增自减法(++a,—a): 先进行自增或者自减运算，再进行表达式运算。后缀自增自减法(a++,a—): 先进行表达式运算，再进行自增或者自减运算。

8.2.关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

8.3.位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

8.4.逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假。

8.5.赋值运算符

8.6.其他运算符

8.6.1.条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

8.6.2.instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

格式：( Object reference variable ) instanceof  (class/interface type)
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

9. 运算符的优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

10. Java分支语句之if…else

10.1. if…语句

一个 if 语句包含一个布尔表达式和一条或多条语句。如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

10.2.if…else 语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

10.3.if…else if…else语句

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：
1、if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
2、if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
3、一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

10.4.嵌套的 if…else 语句

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

if(布尔表达式 1){
   ////如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      ////如果布尔表达式 2的值为true执行代码
   }
}

11. 循环

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。
Java中有三种主要的循环结构：while 循环、do…while 循环、for 循环。

11.1.while 循环

只要布尔表达式为 true，循环就会一直执行下去。

while( 布尔表达式 ) {
  //循环内容
}

11.2.do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

do {
       //代码语句
}while(布尔表达式);

11.3.for 循环

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。for循环执行的次数是在执行前就确定的。 for 循环最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量。再次检测布尔表达式。循环执行上面的过程。

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

for(声明语句 : 表达式)
{
   //代码句子
}

11.4.break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
      for(int x : numbers ) {
         // x 等于 30 时跳出循环
         if( x == 30 ) {
            break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}
/*
运行结果：
10
20
*/

11.5.continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

public class Test {
   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};
      for(int x : numbers ) {
         if( x == 30 ) {
        continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}
/*
运行结果：
10
20
40
50
*/

12. 方法的定义

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。

13. 方法的形参和实参

13.1.形参

形参就是形式参数，用于定义方法的时候使用的参数，是用来接收调用者传递的参数的。 形参只有在方法被调用的时候，虚拟机才会分配内存单元，在方法调用结束之后便会释放所分配的内存单元。 因此,形参只在方法内部有效，所以针对引用对象的改动也无法影响到方法外。（参考章节12）

13.2.实参

实参就是实际参数，用于调用时传递给方法的参数。实参在传递给别的方法之前是要被预先赋值的。

14. 方法的递归调用

方法的递归就是方法自身调用自身。

a(){          
  a(){  
  }       
}

递归是很耗费栈内存的，递归算法可以不用的时候尽量不用。程序运行的时候容易发生了这样一个错误【不是异常，是错误Error】：java.lang.StackOverflowErroe ，栈内存溢出错误。错误放生无法挽回，只有一个结果，就是JVM停止工作 。所以递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误。递归即使有了结束条件，即使结束条件是正确的，也可能会发生栈内存溢出错误，因为递归的太深了，栈内存被占满。
注意：递归如果可以不使用，尽量不使用。但是有些情况下，该功能的实现必须一览递归实现，比如 目录拷贝。