java学习笔记

转自：http://www.javathinker.org/bbs/topic.jsp?db=11&topic=4301

1、标识符

Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符

记：约定俗成，Java表示符选取因注意“见名思意”且不能与Java语言的关键字重名。
标识符命名规则：
    标识符由字母、下划线“_”、美元“$”或数字组成。
    标识符应以字母、下划线、美元符开头
    Java标识符大小写敏感，长度无限制。
合法的标识符    不合法的标识符
$bS5_c7    class
DateClass    DateClass#
_983    98.3
HellWorld    Hell World


2、关键字
    Java中一些赋以特定的含义，用做专门用途的字符串成为关键字（Keywrod）
！大多数编辑器会将关键字用特殊方式标出
    所有Java关键字都是小写英文
    goto和const虽然从未使用，但也被作为Java关键字保留。

3、Java常量

Java的常量值使用字符串表示，区分为不同的数据类型。
    如整型常量123
    实型常量3.14
    字符常量‘a’
    逻辑常量 true、false
    字符串常量“helloworld”
注意：区分字符常量和字符串常量
注意：“常量”这个名词还会用在另外其他语境中表示值不可变得变量
      参见 final 关键字


4、Java变量

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
Java程序中每一个变量都是属于特定的数据类型，在使用前必须对其声明，声明格式为：
type varName [ = value ] [ {，varName [ = value ] } ]
例如：

int i = 100;
float f = 12.3f;
double d1, d2, d3 = 0.123;
String s = “hello” ;

从本质上讲，变量其实是内存中的一块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才可使用

程序执行的过程（内存原理）

                                                       3、执行过程中的内存管理



5、Java变量的分类

1、    按被声明的位置划分：
◆ 局部变量：方法或语句块内部定义的变量
◆ 成员变量：方法外部、类的内部定义的变量 (没有全局变量的概念)
◆ 注意：类外面（与类对应的大括号外面）不能有变量的声明
2、    按所属的数据类型划分：
◆ 基本数据类型变量
◆ 引用数据类型变量

变量的作用域：凡是在{}内声明的变量，出了{}就没有人认识它了

6、Java局部变量与成员变量

◆ 方法体内部声明的变量（包括形参）称为局部变量：
◇ 方法体内部是指与方法对应的大括号内部
◆ 在方法体外，类体内声明的变量称为成员变量，如：
public void method(){
    int i;
    int j = i + 5;//编译出错，变量i还未被初始化
    double d = 3.14;
    Dog dog;
    dog = new Dog(22,7,1964);
}

7、Java数据类型：
7.1、Java数据类型的划分



★基础数据类型在内存中占一块区域，引用数据类型占两块区域


7.2、Java的基本数据类型：

Java有4类8种基本数据类型，六种数字类型（四个整数型，两个浮点型），一种字符类型，一种布尔型
    一、整数型：包括int, short, byte, long
二、浮点数型：float，double
三、文字型（字符）：char
四、逻辑型（布尔）：boolean

1、    byte（字节类型）：有符号的整数，1个字节（8位），取值范围 -127~-128
注意：定义时的错误方式：

public class TestByte
{
    public static void main(String[] args){
       
        byte b;
        b = 3;
        b = b * 3;
        System.out.println(b);
    }
}
如果按上面这样的方式输出，会出现损失精度问题（Possible loss of precision）

原因：字节类型参与运算的时候，JAVA做了一个自动类型的提升，为了保证运算的精度，将这个运算转换成了一个Int类型了，所以会出现错误，因为Int类型的取值范围与Byte类型的取值范围不一样。

处理方法如下：这里我们需要用Byte 来做一个强制类型的转换, 在前面加上(byte),把后面的运算内容括起来，把运算的结果用来转化就不会有问题了
public class TestByte
{
    public static void main(String[] args){
       
        byte b;
        b = 3;
        b = (byte) (b * 3);
        System.out.println(b);
    }
}


2、    short: 有符号的整数，2个字节（也就是16位）取值范围：-32768(-215 )~32767(215-1)
       注意：byte类型可以直接赋值给short类型，short类型不能直接赋值给byte类
             型。如果要把byte类型赋值给short类型同样要做强制的类型转换。
3、    int:  四个字节的整数，也是一个有符号的整数， 取值范围：2 147 483 647(-231)~-2 147 483 648(231-1)
4、    long: 在JAVA中是八个字节的有符号的整数9 223 372 036 854 775 807(-263) ~ -9 223 372 036 854 775 808(263-1)


注意：以上4种整数类型：
◆Java 各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证JAVA程序的可移植性。
◆Java语言整数常量的三种表示形式：
◇ 十进制整数， 如：12，-314，0。
◇ 八进制整数，要求以0开头，如：012
◇ 十六进制数，要求0x或0X开头，如：0x12。
◆Java语言的整型常量默认为int型，声明long型常量可以后加小写L‘l’或大写‘L’，如：
◇ int  i1 = 600；//正确 long l1 = 888888888L;//必须加l 否则会出错

类型    占用存储空间    表数范围
byte    1字节    -128（-27）~127（27-1）
short    2字节    -215~215-1
int     4字节    -231~231-1
long    8字节    -263~263-1
   

5、    char字符类型: 用来存储字符，Java中的字符采用Unicode编码，其中前128个字符编码与ASCII编码兼容，在java中每个字符数据类型占2个字节，是个无符号的字符类型，取值范围：\u0000到uFFFF（也就是0~65535），由于采用Unicode编码，一个中文字与一个英文字母在Java中同样都是一个字符来表示。
public class TestChar
{
    public static void main(String[] args){
       
        char ch;
        ch = 'a';//使用单引号 也可以用ch=97这样的整数来进行赋值，输出也为a
        System.out.println(ch);
    }
}
字符的表示在内存中都是用整数来表示的
◆char型数据用来便是通常意义上“字符”
◆字符常量为用单引号括起来的单个字符，如：
◇ char eChar = ‘a’; char cChar = ‘中’;
◆Java字符采用Unicode编码，Utf-16每个字符占两字字节，因而可用十六进制编码形式表示，如：
  ◇ char c1 = ‘\u0061’;// \u 代表Unicode的16进制编码
  ◇注：Unicode是全球语言统一编码
◆Java语言中还允许使用转义字符‘\’来将其后的字符转变为其他的含义，如：
   ◇ char c2 = ‘\n’; // ’\n’代表换行符
◆补充：2进制、10进制、16进制之间的转换
   ◇ 1101 － 1×1 + 0×2 + 1×4 +1×8
   ◇ 13 －1 + 4 + 8
   ◇ 1101 －D

二进制、八进制、十进制、十六进制数的转换方法

一)、数制
计算机中采用的是二进制，因为二进制具有运算简单，易实现且可靠，为逻辑设计提供了有利的途径、节省设备等优点，为了便于描述，又常用八、十六进制作为二进制的缩写。

一般计数都采用进位计数，其特点是：
(1)逢N进一，N是每种进位计数制表示一位数所需要的符号数目为基数。
(2)采用位置表示法，处在不同位置的数字所代表的值不同，而在固定位置上单位数字表示的值是确定的，这个固定位上的值称为权。
在计算机中：D7 D6 D5 D4 D3 D2 D1 D0 只有两种0和1
8 4 2 1

二)、数制转换
不同进位计数制之间的转换原则：不同进位计数制之间的转换是根据两个有理数如相等，则两数的整数和分数部分一定分别相等的原则进行的。也就是说，若转换前两数相等，转换后仍必须相等。
有四进制
十进制：有10个基数：0 ~~ 9 ，逢十进一
二进制：有2 个基数：0 ~~ 1 ，逢二进一
八进制：有8个基数：0 ~~ 7 ，逢八进一
十六进制：有16个基数：0 ~~ 9，A，B，C，D，E，F (A=10,B=11,C=12,D=13,E=14,F=15) ，逢十六进一

1、数的进位记数法
N=a n-1*p n-1+a n-2*p n-2+…+a2*p2+a1*p1+a0*p0
2、十进制数与P进制数之间的转换
①十进制转换成二进制：十进制整数转换成二进制整数通常采用除2取余法，小数部分乘2取整法。例如，将(30)10转换成二进制数。
将(30)10转换成二进制数
2| 30 ….0 ----最右位
2 15 ….1
2 7 ….1
2 3 ….1
1 ….1 ----最左位
∴ (30)10=（11110)2
将(30)10转换成八、十六进制数
8| 30 ……6 ------最右位
3 ------最左位
∴ (30)10 =(36)8

16| 30 …14(E)----最右位
1 ----最左位
∴ （30)10 =（1E)16
3、将P进制数转换为十进制数
把一个二进制转换成十进制采用方法：把这个二进制的最后一位乘上20，倒数第二位乘上21，……,一直到最高位乘上2n,然后将各项乘积相加的结果就它的十进制表达式。
把二进制11110转换为十进制
（11110）2=1*24+1*23+1*22+1*21+0*20=
=16+8+4+2+0
=（30）10

把一个八进制转换成十进制采用方法：把这个八进制的最后一位乘上80，倒数第二位乘上81，……,一直到最高位乘上8n,然后将各项乘积相加的结果就它的十进制表达式。
把八进制36转换为十进制
（36）8=3*81+6*80=24+6=（30）10
把一个十六进制转换成十进制采用方法：把这个十六进制的最后一位乘上160，倒数第二位乘上161，……,一直到最高位乘上16n,然后将各项乘积相加的结果就它的十进制表达式。
把十六制1E转换为十进制
（1E）16=1*161+14*160=16+14=（30）10
3、二进制转换成八进制数
(1)二进制数转换成八进制数：对于整数，从低位到高位将二进制数的每三位分为一组，若不够三位时，在高位左面添0，补足三位，然后将每三位二进制数用一位八进制数替换，小数部分从小数点开始，自左向右每三位一组进行转换即可完成。例如：
将二进制数1101001转换成八进制数，则
(001 101 001)2
| | |
( 1 5 1)8
( 1101001)2=(151)8

(2)八进制数转换成二进制数：只要将每位八进制数用三位二进制数替换，即可完成转换，例如，把八进制数(643.503)8，转换成二进制数，则
(6 4 3 . 5 0 3)8
| | | | | |
(110 100 011 . 101 000 011)2
(643.503)8=(110100011.101000011)2
4、二进制与十六进制之间的转换
(1)二进制数转换成十六进制数：由于2的4次方=16，所以依照二进制与八进制的转换方法，将二进制数的每四位用一个十六进制数码来表示，整数部分以小数点为界点从右往左每四位一组转换，小数部分从小数点开始自左向右每四位一组进行转换。
(2)十六进制转换成二进制数
如将十六进制数转换成二进制数，只要将每一位十六进制数用四位相应的二进制数表示，即可完成转换。
例如：将(163.5B)16转换成二进制数，则
( 1 6 3 . 5 B )16
| | | | |
(0001 0110 0011. 0101 1011 )2
(163.5B)16=(101100011.01011011)2

6、    float浮点型:  4个字节，取值范围3.402 823e +38 ~ 1.401 298e -45
注意：在Java里面，小数常量，java会认为是一个double类型，所以像下面那样写就是错误的，可以把f = 1.3 改写成 f = 1.3f ，表明1.3是一个浮点数。
?? Float 是有一点误差的，一般精度在7位左右 
public class TestFloat
{
    public static void main(String[] args){
       
        float f;
        f = 1.3;
        System.out.println(f);
    }
}

7、    double: 8个字节，精度比float更高，取值范围：1.797 693e +308 ~ 4.900 000e -324

以上6、7浮点类型：

◆与整数类型类似，java浮点类型有固定的表数范围和字段长度，不受平台影响。
Java浮点类型常量有两种表示形式。
  ◇ 十进制数形式，  如：3.14     314.0    .314
  ◇ 科学记数法形式，如：3.14e2   3.14E2   100E-2
◆Java 浮点型常量默认为double型，如要声明一个常量用float型，则需在数字后面加f或F，如：
◇ double d = 12345.6 ；//正确  float f = 12.3f; //必须加f否则会出错

◆下面列出java的各浮点类型

类  型    占用存储空间    表数范围
float    4字节    -3.403E38~3.403E38
double    8字节    -1.798E308~1.798E308
 

8、    boolean布尔型: 占内存2个字节，可存储True与False两个数值，分别表示逻辑的真与假。没有其他的标识类型。
◆boolean类型适合逻辑运算，一般用于程序流程控制。
◆boolean类型数据之允许取值true或false，不可以以0或非0的整数代替true和false，这点和C语言不同。
◆用法举例：

boolean flag;
flag = true;
if(flag){
    //do something
}

例子程序：

public class TestVar2
{
    public static void main(String[] args){
        boolean b = true;
        int x, y = 9;
        double d = 3.1415;
        char c1, c2;
        c1 = '\u534e'; c2 = 'c';
        x = 12;
        System.out.println("b=" + b);
        System.out.println("x=" + x + ",y=" + y);
        System.out.println("d=" + d);
        System.out.println("c1=" + c1);
        System.out.println("c2=" + c2);
    }
}

8、基本数据类型转换

◆boolean类型不可以转换为其他的数据类型。
◆整形，字符型，浮点型的数据在混合运算中相互转换，转换时遵循以下原则：
◆容量小的类型自动转换为容量大的数据类型，数据类型按容量大小排序为：
◇ byte，short, char -> int -> long -> float -> double
◇ byte, short, char之间不会互相转换，他们三者在计算时首先会转换为int类型
◆容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出；使用时要格外注意。
◆有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。
◆实数常量（如：1.2）默认为double
◆整数常量（如：123）默认为int
public class TestConvert{
    public static void main(String[] args){
        int i1 = 123；
        int i2 =456;
        double d1 = (i1 + i2) * 1.2;//系统将转换为double型运算
        float f1 = (float)((i1 + i2) * 1.2);//需要加强制转换符
        byte b1 = 1;
        byte b2 = 2;
        byte b3 = (byte)(b1 + b2);//系统将转换为int型运算，需要强制转换符
        double d2 = 1e200;
        float f2 = (float)d2;//会产生溢出
        System.out.println(f2);

        float f3 = 1.23f;//必须加f
        long l1 =123;
        long l2 = 30000000000L;//必须加l
        float f = l1 + l2 + f3;//系统将转换为float型计算
        long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）
    }
}


9、程序格式：（比算法还重要！！！）
格式应该注意的问题：
1.    大括号对齐
2.    遇到 { 缩进，Tab / Shift + Tab
3.    程序块之间加空行
4.    并排语句之间加空格
5.    运算符两则加空格
1、有特定条件
6.    { 前面有空格
7.    成对编成

例子说明：
public class HelloWrold { //1.大括号对齐
    // 3.程序块之间加空行
    static int j = 9; //2.遇到 { 缩进，Tab / Shift + Tab

    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
    //3.程序块之间加空行
    public static void m() {
        int i = 9;空格int j = 4; //4.并排语句之间加空格，[ ]处
        int i = 123; //5.运算符两则加空格,=号两边加了空格
    }
}

public class HelloWorld {
} //7.成对编成,写完 { 后立即写上 } 括号

程序格式的原则：
◆要让别人看地清楚
◆要让别人看得舒服

10、运算符

Java语言支持如下运算符：
    算术运算符：+，-，*，/，%，++，--
注意：
    ☆ ++（--）
    ☆ 在前面时先运算再取值。
    ☆ 在后面时先取值再运算
public class Test {
    public static void main(String[] args){
        int i1 =10, i2 = 20;
        int i = (i2++);
        System.out.print("i=" + i);
        System.out.println(" i2=" + i2);
        i = (++i2);
        System.out.print("i=" + i);
        System.out.println(" i2=" + i2);
        i = (--i1);
        System.out.print("i=" + i);
        System.out.println(" i1=" + i1);
        i = (i1--);
        System.out.print("i=" + i);
        System.out.println(" i1=" + i1);
    }
}

结果: i=20 i2=21
     i=22 i2=22
     i=9 i1=9
     i=9 i1=8

&#61548;    关系运算符：>，<，>=，<=，==，!=
&#61548;    逻辑运算符：!，&，|，^，&&，||

变量a    变量b    逻辑非    逻辑与    逻辑或    逻辑异或    短路与    短路或
a    b    !a    a & b    a | b     a ^ b    a && b    a || b
true    true    false    true    true    false    true    true
true    false    false    false    true    true    false    true
false    true    true    true    true    true    false    true
false    false    true    false    false    false    false    false

&#61548;    位运算符：&，|，^，~，>>，<<，>>>
&#61548;    赋值运算符：=
&#61550;    赋值运算符与扩展赋值运算符
&#61557;    赋值运算符（=）
&#61548;    当“=”两侧数据类型不一致时，可以适用默认类型转换或使用强制类型转换原则进行处理
&#61550;    Long l = 100;  int I = (int)1;
&#61548;    注意：可以将整形常量直接赋值给byte, short, char等类型变量，两不需要进行强制类型转换，只要不超出其表数范围
&#61550;    byte b = 12; char c = 100;
&#61550;    × byte bb =256;      × short s = -32769;
运算符    用法举例    等效的表达式
+=    a += b    a = a+b
-=    a -= b    a = a-b
*=    a *= b    a = a*b
/=    a /= b    a = a/b
%=    a %= b    a = a%b

&#61548;    字符串连接运算符：+
◆“+”除用于算术加法运算外，还可用于对字符串进行连接操作
     int id = 800 + 90;
    String s = “hello” + “world”;
◆“+”运算符两侧的操作数中只要有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串后再进行连接。
    int c = 12；
    System.out.println(“c=” + c);
◆    当进行打印时，无论任何类型，都自通转为字符串进行打印 。
     System.out.println c);

11、表达式
◆表达式是符合一定语法规则的运算符和操作数的序列
◆a
◆5.0 + a
◆(a-b)*c-4
◆i < 30 && i %10 != 0
◆ 表达式的类型和值
    ◆ 对表达式中操作数进行运算得到的结果称为表达式的值。
    ◆ 表达式值得数据类型即位表达式的类型。
◆ 表达式的运算顺序
    ◆ 应按照运算符的优先级从高到低的顺序进行。
    ◆ 优先级相同的运算符按照事先约定的结合方向进行。


12、三目条件运算符：
◆    三目条件运算符，语法格式：
x ？y : z
◆    其中x为boolean类型表达式，先计算x的值，若为true，则整个三目运算的结果为表达式y的值，否则整个结果为表达式z的值。
◆    举例：
public class Test {
    public static void main(String[] args){
        int score = 80;
        int x = -100;
        String type = score < 60 ? "不及格" : "及格";
        int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
        System.out.println("type= " + type);
        System.out.println("flag= " + flag);
    }
}

13、语句
◆    条件语句-根据不同条件，执行不同语句。
&#61557;    if
&#61557;    if..else
&#61557;    if..else if
&#61557;    if..else if..else if..else
&#61557;    switch
◆    循环语句-重复执行某些动作。
&#61557;    for (JDK1.5语法)
&#61557;    while
&#61557;    do..while;

13.1、if语句：
注意：如果在条件中只有一行代码，可以省略{}，如果有多行，必须要有{}

13.2、for循环语句
&#61548;    for语句为如下形式：
for（表达式1；表达式2；表达式3）{语句；…;}
&#61548;    执行过程：
首先计算表达式1，接着执行表达式2，若表达式2的值=ture则执行语句，接着计算表达式3，再判断表达式2的值；依次重复下去，直到表达式2的值=false

For语句中三个表达式都可以省略
JDK1.5新补充的for语句（后面介绍，数组）
public class Test {
    public static void main(String[] args){
        long result = 0;
        long f = 1;
        for (int i = 1; i <=10; i++ ){
            f = f * i;
            result += f;
        }
        System.out.println("result=" + result);
    }
}

用for计算1加到99的运算，要求按奇数进行相加，1+3+5……99，并输出结果：代码如下：
public class OddSum {
    public static void main(String[] args) {
        long result = 0;
        for (int i=1; i<=99 ; i+=2 ){
            System.out.println(result + "+" + i + "=" + (result += i));//打印每次输出
            //result += i;           
        }

        System.out.println(result);
    }
}

13.3 while& do while语句
◆while语句格式如下：
    while （逻辑表达式）{语句;…;}
◆执行过程
    先判断逻辑表达式的值。若=true。则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立为止。


◆do-while语句格式如下：(用的比较少)
    do{语句；…；}while（逻辑表达式）；//后面有个分号，不能忘记
◆执行过程
    先执行语句，再判断逻辑表达式的值，若为true，再执行语句，否则结束循环。


while & do while 例子：
public class TestWhile{
    public static void main(String[] args) {
        int i = 0;
        while(i < 10) {
            System.out.println(i);
            i++;
        }

        i = 0;
        do {
            System.out.println(i);//注意，如果把i++放这上面结果是10
            i++;
        }
        while (i > 10);   
    }
}

13.4 break & Continue 语句
◆break语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环；如：
public class TestBreak {
    public static void main(String[] args){
        int stop = 4;
        for (int i = 1; i<=10 ; i++ ){
            //当i等于stop时,退出循环
            if (i == stop) break;  //特别注意，在if (i == stop)不要加“；”号，
            System.out.println("i= " + i);           
        }
    }
}
结果：i=1、i=2、i=3

◆Continue语句用在循环语句体中，用于终止某次循环过程，跳出循环体中continue语句下面未执行的循环，开始下一次循环过程；如：
public class TestContinue {
    public static void main(String[] args){
        int skip = 4;
        for (int i = 1; i<=5 ; i++ ){
            //当i等于skip时,跳出当次循环
            if (i == skip) continue; {
                System.out.println("i= " + i);
            }
        }
    }
}
结果：i=1、i=2、i=3、i=5


13.5循环语句综合举例：
1、请输出1~100内前5个可以被3整除的数
public class TestForA {
    public static void main(String[] args){
        int num = 0;
        int i = 1;
        while(i <= 100){
            if (i % 3 == 0){
                System.out.println(i);
                num++;
            }
           
            if(num == 5){
                break;
            }
            i++;
        }

    }
}


2.请输出101~200内的质数（prime number 质数的意思：只能被其本身或1整除而没有余数的整数）
public class TestPrimeNumber {
    public static void main(String[] args){
        for (int i = 101; i<=200 ; i+=2){
            boolean f = true;
                for(int j = 2 ; j<i ; j++) {
                    if (i % j ==0){
                        f = false;
                        break;
                    }
                }
                if (!f) {
                    continue;
                }

                System.out.println("i= " + i);
        }

    }
}

13.6 switch条件语句
◆switch语句格式：
switch(){
    case xx :
        …
    case xx :
        …
    default:
        …
}
◆ 小心case穿透，推荐使用break语句
◆ 多个case可以合并到一起
◆ deault可以省略，但不推荐省略
◆ java中switch语句只能探测int类型值

public class TestSwitch {
    public static void main(String[] args){
        int i =18;
        switch(i){//里面可以放byte、short、char类型，因为它们会自动转换成int类型
            case 1 :
                //System.out.print("1"); //如果1这里面什么都不写，表示1和2合并，意思是1or2，打印的结果都是2
            case 2 :
                System.out.print("2");
                break;//注意使用break小心case穿透，有时候执行完这句后会连下句也执行
            case 3 :
                System.out.print("3");
                break;
            case 8 :
                System.out.print("8");
                break;
            default:
                System.out.print("18");
        }

    }
}

13.7 方法（Method）
◆方法的本质其实是提高我们程序的复用性
◆Java的方法类似于其他语句的函数，使一段用来完成特定功能的代码片断，声明格式：
[修饰符1  修饰符2  ……]返回值类型 方法名（形式参数列表）{
    Java语句；……
}
如：
public static void main(String[] args){
}
◆形式参数：在方法被调用时用于接受外界输入的数据。
◆实参：调用方法时实际传给方法的数据。
◆返回值：方法在执行完毕后返还给调用它的环境的数据。
◆返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型 void。
    void 表示不返回任何值
◆Java语言中使用下述形式调用方法：对象名.方法名（实参类标）
◆实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配，
◆return 语句终止方法的运行并指定要返回的数据。
◆Java中进行函数调用中传递参数时，遵循值传递的原则：
    ◇基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。
例子程序：
public class TestMethod {
    public static void main(String[] args){
        m();
        m2(5);
        m3('3',4);//注意,'3'传过去的是一格ASCll码,它会自动转换成int类型,但不一定是3+4=7
        m4(4,6);//m4的方法调用有两种方法，这是第一种方法，调用了但是没有使用，返回的值保存到了一个临时的空间中；就是说这个方法有返回值，但是你可以不用它。
        int i = m4(4,6);//这是第二种方法，调用了m4，同时取得了它的返回值
        System.out.println(i);
    }

    public static void m(){
     //return;//表示方法执行到这里,无论下面是什么,都不再执行,程序结束并返回
     System.out.println("ok");
     System.out.println("hello");
    }

    public static void m2(int i) {//传来的值必须是int类型,不能使其他的
        if(i > 3)
            return;
        System.out.println(i);
    }

    public static void m3(int i, int j) {
        System.out.println(i + j);
    }

    public static int m4(int i, int j) {//注意:没有用viod，用的int，意思是：当调用完以后会返回一个int类型的值回去
        return i > j ? i : j;//要想返回一个值，直接在retrun后面跟上想要返回的值就可以了，但要注意的是返回的值必须是事先约定好的类型
    }
}

14 递归(recursion)调用
    在一个方法里面，对自身进行调用

以上程序在内存中执行的过程：算5的阶层



◆ 递归调用指在方法执行过程中出现该方法本身的调用。如：
◇ 求Fibonacci（斐波纳契数列：一种整数数列，其中每数等于前面两数之和）数列：1，1，2，3，5，8，……第40个数的值。数列满足递推公式：
◇ F1=1，F2=1   Fn=Fn-1 + Fn-2 (n>2)
public class TestFibonacci {
    public static void main(String[] args){
        System.out.println(f(5));
    }

    public static int f(int n){
        if(n == 1 || n == 2){
            return 1;
        }else{
            return f(n - 1) + f(n - 2);
        }
    }
}
结果：102334155
以上程序在内存中执行的过程



◆    练习：使用非递归的方法解决上面的问题
public class Fab {
    public static void main(String[] args){
        System.out.println(f(40));
    }

    public static long f(int index){
        if(index < 1){
            System.out.println("invalid parameter!");
            return -1;
           
        }

        if (index == 1 || index == 2){
            return 1;
        }
        long f1 = 1L;
        long f2 = 1L;
        long f = 0;

        for (int i=0; i<index-2; i++){
            f = f1 + f2;
            f1 = f2;
            f2 = f;
        }

        return f;
    }
}
结果：102234155