02-Java语言基础

2 Java语言基础

2.1 注释

2.1.1 分类

2.1.2 特点

• 被注释的内容：JVM 不会解释执行

2.1.3 代码示例

/**
 * 常用文档注释，用在类上面
 * @author lyl            // 作者
 * @version 1.0           // 版本号（当前程序）
 * @see java.lang.Object  // 指定到另一个类的链接
 * @see #test(String)     // 指定到某个方法的连接
 * @see Object#toString() // 指定到某个类的某个方法上的连接
 * @since                 // 当有特定的变化时标记，通常后面跟JDK版本
 *（还有很多不常用的自行查询，此处不再一一列举）
 */
public class NotesTest {
    public static void main(String[] args) {
        // 单行注释
        /*
           多行注释
           多行注释
         */
        /*
         * 多行注释
         * 多行注释
         */
    }
    /**
     * 常用文档注释，用在方法上面
     * @param str     // 方法的参数
     * @return String // 返回值类型
     * @exception     // 标记抛出的异常信息
     * @throws        // 同 @exception
     */
    public String test(String str) {
        return str;
    }
}

2.2 标识符

2.2.1 概念

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

2.2.2 命名规则

1. 标识符由字母、下划线”_”、美元符号”$”和数字组成
2. 标识符不能以数字开头
3. 大小写敏感，长度无限制

注意：

• 标识符取名字是要“见名知意”
• 不能与Java“关键字”重名
• 命名规范 | 合法标识符 | 非法标识符 | 原因 | | —- | —- | —- | | HelloWorld | class | 使用了Java关键字 | | ABClass | ABClass*# | 使用了非法字符 | | _123 | 1_23 | 使用数字开头 | | $123_456 | hello world | 使用了空格 |

2.3 关键字（keyword）

2.3.1 概念

Java中一些赋以特定含义，用作专门用途的字符串

2.3.2 分类

2.3.3 特点

• Java中所有关键字都是小写

• 命名规范

2.4 常量

2.4.1 概念

常量是指在程序的整个运行过程中值保持不变的量

2.4.2 分类

2.4.3 特点

• 不可改变
• 命名规范

注意：通常我们使用final关键字修饰的变量也可称为常量，final表示不可改变

2.4.4 代码示例

/**
 * 常量
 */
public class Constant {
    public static void main(String[] args) {
        System.out.println(123);
        System.out.println(1.2);
        System.out.println('$');
        System.out.println("你好");
        System.out.println(true);
        String a = null;
        System.out.println(a);
    }
}

2.5 变量

2.5.1 概念

Java变量是程序中最基本的存储单元，要素包括变量名、变量类型、和作用域

2.5.2 特点

• 值在某个范围区间内可以改变

• 格式

  • type name [ = value] [ {, name [ = value ] } ];
  • 数据类型 变量名 = 初始化值；（必须先声明，再赋值）
• 命名规范

2.5.3 代码示例

/**
 * 变量
 */
public class Variable {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        a = 1;
        System.out.println(a);
        double d1 = 2.0, d2 = 2.1;
        System.out.println(d1);
        System.out.println(d2);
    }
}

2.5.4 分类

1. 按声明位置分类：

   • 局部变量
   • 成员变量

注：类外面不能有对变量的声明

1. 按数据类型分类：

   • 基本数据类型变量
   • 引用数据类型变量 | 分类 | 定义 | | —- | —- | | 局部变量 | 在方法体内部（包括形参）或语句块内部定义的变量 | | 成员变量 | 在方法体外部，类体内部定义的变量 |

2.5.5 特点

值可以改变

本质：变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量必须先声明（申请内存空间），再赋值（填充内容）

2.5.6 代码示例

/**
 * 成员变量和局部变量
 */
public class Variable_02 {
    int i;          // 成员变量，可以不用赋值，程序加载时会自动赋默认值
    int j = 1;      // 成员变量
    public static void main(String[] args) {
        int i = 2;  // 局部变量，使用前必须进行赋值
    }
}

2.6 数据类型

2.6.1 分类

2.6.2 基本数据类型

4类8种

• 布尔型（boolean）

  • 用法：用于逻辑运算，通常用于流程控制 | 类型 | 取值范围 | 默认值 | | —- | —- | —- | | boolean（布尔型） | true/false | false |

代码示例：

/**
 * 布尔类型
 */
public class BooleanType {
    public static void main(String[] args) {
        boolean bn = true;
        boolean bn1 = false;
        System.out.println(bn);
    }
}

• 字符型（char）

  • 用法： 用于表示字符
  • 取值：使用单引号引起来的单个字符，例如：’a‘，’你’，’$’，’1’

  • 注意：

    • Java采用Unicode编码（默认Utf16），每个字符占用2个字节，因此可以使用16进制来表示，例如：’\u0061’ 表示小写的a，’\u’表示Unicode字符
    • Java中可以采用转义字符来将位于其后的字符表示其他含义，如’\n’表示换行符 | 类型 | 存储空间 | 取值范围 | 默认值 | | —- | —- | —- | —- | | char（字符型） | 2字节 | 0 ~ 65535 ( \u0000 ~ \uffff ) | \u0000 |

代码示例：

/**
 * 字符类型
 */
public class CharacterType {
    public static void main(String[] args) {
        char c1 = 'a';
        char c2 = '$';
        char c3 = '1';
        char c4 = '你';
        char c5 = '\u0061';
        System.out.println(c1);
        // char  字符型  取值范围0~65535
        System.out.println('我');  // 字符常量
        char ch = 29233;           // 十进制
        System.out.println(ch);
        char ch1 = 0x4E2D;         // 十六进制
        System.out.println(ch1);
        char ch2 = '\u534e';       // Unicode编码
        System.out.println(ch2);
    }
}

• 整数类型

  • 用法：进行数学运算等
  • 特点：Java整数类型有固定的字段长度和数的表示范围，不受操作系统影响，保证程序可移植性

  • 表示方式：

    • 八进制整数：以0开头，例如：012
    • 十进制整数：例如：12、-23、0
    • 十六进制整数：以0x或0X开头，例如：0x123

  • 注意：

    • Java整型常量默认为int型，例如：int i = 999;
    • long类型需要在数字后面加“l”或“L”，例如：long l = 9999999999L; 建议用大写L | 类型 | 占用存储空间 | 表数范围 | 默认值 | | —- | —- | —- | —- | | byte（字节型） | 1字节 | -2 ~ 2-1 (-128 ~ 127) | 0 | | short（短整型） | 2字节 | -2 ~ 2-1 (-32768 ~ 32767) | 0 | | int（整型） | 4字节 | -2 ~ 2-1 (-2147483648 ~ 2147483647) | 0 | | long（长整型） | 8字节 | -2 ~ 2-1（-9223372036854775808～9223372036854775807） | 0L |

• 浮点类型

  • 特点：与整型相同

  • 表示方式：

    • 十进制形式：例如：3.14、3.0、.3
    • 科学计数法形式：例如：3.14e2、100E-2

  • 注意：

    • Java浮点型常量默认为double型
    • float类型需要在常量后面添加”f”或”F”
    • 浮点型会损失精度，不能作为精确计算使用，如果想要进行精确计算，可以使用BigDecimal类 | 类型 | 占用存储空间 | 表数范围 | 默认值 | | —- | —- | —- | —- | | float（单精度浮点型） | 4字节 | -3.403E38 ~ 3.403E38 | 0.0F | | double（双精度浮点型） | 8字节 | -1.798E308 ~ 1.798E308 | 0.0 |

2.6.3 代码示例

/**
 * 整数类型
 */
public class NumberType {
    public static void main(String[] args) {
        /*
         * 每种类型的取值不能超出应类型的范围，取值超出范围后会报错
         *
         * 整型: byte short int long
         * 
         * byte  字节型  取值范围为-128~127 ，
         */
        byte bt = 127;
        System.out.println(bt);
        //short 短整型
        short s = 32767;
        // int 整型 默认类型
        int i = 999999999;
        // long 长整型
        long lg = 9999999999L;
        System.out.println(lg);
        /*
         * 浮点型: float double
         * 
         * float 单精度 浮点型  f F
         */
        float fl = 1.234f;
        // double 双精度 浮点型  默认类型
        double db = 1.23;
    }
}

2.6.4 基本数据类型转换

• boolean类型不能转换为其他类型

• 整型、浮点型、字符型在混合运算中可互相转换，遵循以下规则

  • 容量小的类型自动转换为容量大的类型

    • byte,short,char -> int -> long -> float -> double
    • byte,short,char之间不会互相自动转换，他们在运算时会先转换成int类型
  • 容量大的类型转成容量小的类型时，需加强制转换符，有可能造成精度降低或溢出
  • 多种类型混合运算时，系统会自动将所有类型转成容量最大的那种类型进行运算
  • 整数常量（如：1）默认为int类型
  • 实数常量（如：1.2）默认为double类型

2.6.5 代码示例

/**
 * 基本数据类型转换
 */
public class BasicTypeConvert {
    public static void main(String[] args) {
        /*
         * 自动类型转换（隐式转换）
         * 容量小的  -> 容量大的
         */
        byte b = 123;
        int i = b;
        System.out.println(i);
        /*
         * 强制类型转换（显式类型转换）
         * 容量大的类型 -> 容量小的类型
         * 需要加 强制转换符
         * 缺点：可能造成精度降低或溢出
         */
        int in = 6666;
        byte bt = (byte)in; // 会产生溢出
        short sh = (short)in;
        System.out.println(bt);
        /*
         * 类型转换的原理：所有的byte,short char类型，都会被提升为int类型
         * long float double 转换的结果与自己类型一致
         */
        byte by = 123;
        byte byy = 1;
        int bb = by + byy;
        byte b2 = (byte)(by + byy);
        char ch = 'a';
        int aa = ch + by;  // 97 + 123
        System.out.println(ch);
        System.out.println(ch+1);  // 97 + 1
        System.out.println(aa);
        System.out.println('a' + 'a');  // 97 + 97
        short s1 = 1;
        int i1 = 2;
//        int i2 = i1 * 2.0; // 错误，有实数常量，计算时会自动转为double类型
        double d1 = (s1 + i1) * 2.0;  // 自动转换为double
        System.out.println(d1);
        float f1 = (float) ((s1 + i1) * 2.0);  // 如果不加强制转换符，会报错。
        float f2 = 1.23f;
        long l1 = 100000000000l;
//        long l2 = (f2 + l1);  // 错误，需要强制转换，系统会自动转换成float进行计算
        float f3 = f2 + l1; // 正确
        System.out.println(f3);
    }
}

2.6.6 引用数据类型

2.6.7 代码案例

/**
 * 引用数据类型
 */
public class Reftypes {
    public static void main(String[] args) {
        // 除了基本数据类型外，所有的都是引用数据类型
        String str = new String("abc");
        Reftypes rt = new Reftypes();
        System.out.println(rt);  // @1b6d3586
        System.out.println(str);
    }
}

2.6.8 数据类型使用参考原则

• 如果是描述数字，首选int（整数）、double（小数）
• 如果进行数据传输或进行文字编码转换，使用byte（字节）类型（二进制处理操作类型）
• 如果进行中文处理，使用char（字符）类型
• 表示文件大小、数据库表主键列（自动增长列）、内存等，使用long类型

2.7 运算符

2.7.1 运算符分类

“+”号：

• 两边的操作数中，只要有一个是字符串类型（String），则系统会自动将另一个值转换为字符串进行连接
• 进行打印输出时，如论任何类型，都会转为字符串进行打印 ，例如：System.out.print(123);

2.7.2 代码示例

/**
 * 算数运算符
 */
public class ArithmeticOperator {
    public static void main(String[] args) {
        /*
         * + - * / % ++ --
         *
         * 对负数取模  5%-2 = 1  ，负号可以忽略不计
         * 被取模的是负数 -5%2 = -1
         */
        System.out.println(5%2);
        System.out.println(5%-2);
        System.out.println(-5%2);
        // 字符串和任何数据类型相加，+可以作为连接符使用
        System.out.println("4+3="+4+3);
        // 除法  / 整数除法，只保留整数部分
        int a = 3456;
        a = a / 100;
        System.out.println(a);
        int aa = 105, bb = 20;
        double cc = aa / bb;
        double dd = aa % bb;
        System.out.println("cc: " + cc);
        System.out.println("dd: " + dd);
        /*
         * ++或-- 在前： 先运算，再赋值
         * ++或-- 在后： 先赋值，后运算
         * ++ ： 自身加1
         * -- ： 自身减1
         */
        int b = 20;
        b++;   // b = b + 1;
        System.out.println("b: " + b);
        int c = 10;
        ++c;
        System.out.println("c: " + c);
        // 快捷键： Ctrl+d：快速复制一行  Ctrl+x：删除一行
        int a1 = 10;
        int a2 = a1++;
        System.out.println("a1: " + a1);
        System.out.println("a2: " + a2);
        int b1 = 20;
        int b2 = ++b1;
        System.out.println("b1: " + b1);
        System.out.println("b2: " + b2);
    }
}

/**
 * 关系运算符
 */
public class RelationalOperator {
    public static void main(String[] args) {
        /*
         * ==  > < >= <= !=
         * 运算结果：布尔型  boolean
         *  a > b > c  错误写法
         */
        int a = 3;
        int b = 2;
        int c = 1;
        System.out.println(a > b && b > c);
    }
}

/**
 * 逻辑运算符
 */
public class LogicalOperator {
    public static void main(String[] args) {
        /*
         * &：与    |：或  ！：非  ^:异或
         * &&：短路与  ||：短路或
         */
        int a = 10, b = 20;
        boolean c = a<9 & b++>10;  // 左右两边都成立为true，否则为false
        System.out.println(c);      // 左右两边同时都会运算
        System.out.println("b: "+ b);
        boolean d = a<9 | b<10;  // 左右两边只要有一个条件成立，则为true，都不成立为false
        System.out.println(d);
        boolean c1 = a<9 && b++>10;  // 左右两边都成立为true，否则为false
        System.out.println(c1);       // 先运算左边，如果左边成立，再运算右边
        System.out.println("b: "+ b);
        boolean d1 = a<9 || b<10;  // 左右两边只要有一个条件成立，则为true，都不成立为false
        System.out.println(d1);      // 先运算左边，如果左边不成立，再运算右边
        // 异或：两边相同为假，不同为真。
        int a1 = 10, b1 = 20;
        boolean bn = a1 > 9 ^ b1 > 10;  // 两侧都为真，结果为假
        System.out.println("bn = " + bn); // false
        int a2 = 10, b2 = 20;
        boolean bn2 = a2 < 9 ^ b2 > 10;  // 两侧不同，结果为真
        System.out.println("bn2 = " + bn2); // true
        int a3 = 10, b3 = 20;
        boolean bn3 = a3 > 9 ^ b3 < 10;  // 两侧不同，结果为真
        System.out.println("bn3 = " + bn3); // true
        int a4 = 10, b4 = 20;
        boolean bn4 = a4 < 9 ^ b4 < 10;  // 两侧不同，结果为真
        System.out.println("bn4 = " + bn4); // false
    }
}

/**
 * 赋值运算符
 */
public class AssignmentOperator {
    public static void main(String[] args) {
        // = += -= *= /= %=
        int a = 3;
        a +=5;  // a = a + 5;
        System.out.println(a);
        /*
         * short s = 3;
         * s = s + 2;
         * s += 2;
         */
        short s = 3;
//        s = (short)(s + 2);   // 需要强转
        s += 2;  // 不用强转
        System.out.println(s);
    }
}

2.7.3 运算符优先级

• 单目运算符包括! ~ ++ —，优先级别高
• 优先级别最低的是赋值运算符
• 可以通过()控制表达式的运算顺序，()优先级最高
• 从右向左结合性的只有赋值运算符、三目运算符和单目运算符
• 算术运算符 > 关系运算符 > 逻辑运算符

2.8 表达式（expressions）

2.8.1 概念

符合一定语法规则的运算符和操作数的序列

a
1 + 2
a * 2 = 4
x < 1 && y > 0

2.8.2 表达式的类型和值

• 对表达式中操作数运算得出的结果就是表达式的值
• 表达式的值的数据类型就是表达式的类型

2.8.3 表达式的运算顺序

• 按照运算符的优先级从高到低的顺序进行
• 优先级相同的运算符按照事先约定的结合方向进行 | 优先级 | 运算符 | 结合性 | | —- | —- | —- | | 1 | ()、[]、{} | 从左向右 | | 2 | !、+、-、~、++、— | 从右向左 | | 3 | 、/、% | 从左向右 | | 4 | +、- | 从左向右 | | 5 | «、»、>>> | 从左向右 | | 6 | <、<=、>、>=、instanceof | 从左向右 | | 7 | ==、!= | 从左向右 | | 8 | & | 从左向右 | | 9 | ^ | 从左向右 | | 10 | | | 从左向右 | | 11 | && | 从左向右 | | 12 | || | 从左向右 | | 13 | ?: | 从右向左 | | 14 | =、+=、-=、=、/=、&=、|=、^=、~=、«=、»=、>>>= | 从右向左 |

3.8.4 三元表达式

• 格式：数据类型 变量名 = (条件表达式) ? 值1 : 值2;
• 含义：条件表达式为true，则结果为值1，否则，结果为值2

• 注意：

  • 数据类型要与“值1”或“值2”的类型一致
  • “值1”或“值2”也可以是其他的表达式

3.8.5 代码示例

/**
 * 三元表达式
 */
public class TernaryExp {
    public static void main(String[] args) {
        /*
         * 格式：数据类型  变量名 = （条件表达式）？值1：值2；
         * 数据类型 要与 值1 或 值2 的类型一致
         */
        int a = 3, b = 4;
        int c;
        c = (a > b) ? a : b;
        System.out.println(c);
        String d = (a > b) ? "ok" : "no";
        System.out.println(d);
    }
}

2.9 语句

2.9.1 分支语句（条件语句）

分支结构又称为选择结构。选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。

if分支语句

• 理解：

  • 首先判断条件表达式是否为true
  • 如果条件表达式为true，则进入代码块执行表达式
  • 如果条件表达式为false，则结束当前代码块，或者进入else if中进行判断，以此类推
  • 最后如果都不满足，则进入else代码块，然后程序结束

• 特点：

  • 条件表达式结果为boolean类型
  • 如果只有一条执行表达式，可以省略大括号，如果是多条执行语句，不能省略，这里建议都要加上
  • else if 代码块，可以有多个
  • else 代码块放在最后

if(条件表达式) {
    执行表达式;
    ...
}
if(条件表达式)
    执行表达式;
if(条件表达式) 执行表达式;

if(条件表达式){
    执行表达式1;
} else {
    执行表达式2;
}

if(条件表达式1){
    执行表达式1;
} else if(条件表达式2){
    执行表达式2;
} else if(...){
    ...
} else {
    执行表达式3;
}

switch分支语句

• 理解：

  • 首先计算出表达式的值
  • 其次和case依次比较， 一旦有对应的值， 就会执行相应的语句， 在执行的过程中，遇到break就会结束
  • 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束

• 特点：

  • 表达式的取值：byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String
  • case可以有多个，后面跟的是要和表达式进行比较的值
  • 执行表达式语句体部分可以是一条或多条语句
  • break关键字表示结束当前代码块，是中断，结束的意思
  • 如果不写break，则程序会一直往下子执行，直到遇到break或者程序结束
  • default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句中的else相似，可以省略

switch(表达式){
    case 值1:
    case 值2:
            执行表达式 2;
            break;
    case 值3:
            执行表达式 3;
            break;
    ...
    default:
            执行表达式 default;
            break; // 到这里程序结束，可以没有break，建议写上
 }

2.9.2 代码示例

/**
 * 分支语句/条件语句
 */
public class BranchStat {
    public static void main(String[] args) {
        /*
         * if选择结构
         * if（条件表达式）{执行表达式}
         * 条件表达式结果为boolean类型
         * 如果只有一条执行表达式，可以省略大括号，如果是多条执行语句，不能省略。这里建议都要加上
         */
        if(true)
            System.out.println(111);
        if(false){
            System.out.println(1);
        } else {
            System.out.println("进入else");
        }
        if(false){
            System.out.println(1);
        } else if(true){
            System.out.println("进入else if 1");
        } else if(true){
            System.out.println("进入else if 2");
        } else {
            System.out.println("else");
        }
        /*
         * switch 选择结构
         * switch(表达式){
         *     case 值1：
         *     case 值2：
         *             表达式 2；
         *             break；
         *     case 值3：
         *             表达式3；
         *             break；
         *     ...
         *     default:
         *             表达式 defult；
         *             break；
         * }
         * break: 表示停止当前选择结构
         */
        int a = 1;
        switch(a){
            case 1:
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
                break;
            default:
                System.out.println("default");
                break;
        }
    }
}

2.9.3 循环语句

• 理解：

  • 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执 行的代码被称为循环体语句。
  • 当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

for循环

• 特点：

  • 完整for循环，详见 格式 1
  • 初始化值表达式可以写在外部，详见 格式 2
  • 循环后的操作表达式，可以写在内部，或者省略（不做任何操作），详见 格式 3
  • 死循环，详见 格式 4
  • for循环小括号中的分号不能省略
  • 初始化值表达式只执行一次

// 格式 1
for(初始化值表达式; 条件表达式; 循环后的操作表达式){
    执行表达式;
}
// 格式 2
for(; 条件表达式; 循环后的操作表达式){
    执行表达式;
}
// 格式 3
for(; 条件表达式; ){
    执行表达式;
    循环后的操作表达式;
}
// 格式 4
for(; ; ){
    执行表达式;
}

while循环

• 特点：

  • 满足条件表达式，执行表达式将会一直执行，执行完一次后，会再次确认条件表达式，直到条件不满足
  • 如果不满足条件，while循环将一次也不会执行

// while循环格式
while (条件表达式){
    执行表达式;
}

do…while 循环

• 特点：

  • 注意：while最后要写一个分号结尾
  • 不管条件是否满足，do...while循环最少会执行一次

// do...while循环格式
do{
    执行表达式;
} while (条件表达式);

2.9.4 代码示例

/**
 * 循环语句
 */
public class LoopStat {
    public static void main(String[] args) {
        /*
         * for(初始化值表达式；条件表达式；循环后的操作表达式）{
         *        执行表达式；
         * }
         */
        for(int a = 0; a < 10; a++){
            System.out.println(a);
        }
        // while 循环结构
        int i =1;
        while (i<10){
            System.out.println("haha  " + i);
            i++;
        }
        // 最少执行一次
        do{
            System.out.println("heihei  " + i);
            i++;
        } while (i < 20);
    }
}

三种循环区别

• do...while循环至少执行一次循环
• for和while必须先判断条件是否是true，然后后才能决定是否执行循环体

循环使用的注意事项(死循环)

• 一定要注意修改控制条件,否则容易出现死循环

• 最简单的死循环格式

  • while(true){...}
  • for(;;){...}

2.9.5 跳转控制语句（break、continue、return）

• break：中断

  • 使用场景

    • 在选择结构switch语句中
    • 在循环语句中

  • 作用

    • 跳出当前（单层）循环

    • 跳出当前（多层）循环

      • 带标签的跳出
      • 格式：标签名: 循环语句
      • 标签名要符合Java的命名规则

• continue：继续

  • 使用场景

    • 在循环语句中

  • 作用

    • 退出本次循环，继续下次循环

• return：返回

  • 使用场景

    • return关键字不是为了跳转出循环体，更常用的功能是结束一个方法

  • 作用

    • 退出一个方法，跳转到上层调用的方法

注意：三个关键字后面都不可以紧跟其他语句

2.9.6 代码示例

/**
 * 跳转控制语句
 */
public class JumpControlStat {
    public static void main(String[] args) {
        test();
        test1();
        test2();
        test3();
    }
    public static void test(){
        int a = 0;
        while (a<20){
            a++;
            if(a==5){
                continue;
//                break;
//                return;
                // 三个关键字后面都不可以紧跟其他语句
            }
            System.out.println(a);
        }
    }
    public static void test1(){
        System.out.println("test1");
        return;
    }
    public static int test2(){
        System.out.println("test2");
        return 2;
    }
    public static String test3(){
        System.out.println("test3");
        return "abc";
    }
}

2.9.7 方法

类似于其他语言的函数，用来完成特定功能的代码片段

// 方法格式
[修饰符...] 返回值类型 方法名(形式参数列表){
    Java语句...
}

方法调用方式：对象名.方法名(实参列表)

注意：

• 实参的数目、数据类型、次序必须和所调用方法声明的形参列表一致
• return语句可以终止方法并返回对应数据

• Java在进行函数调用中传递参数遵循值传递原则

  • 基本数据类型传递值本身
  • 引用数据类型传递的是对象的引用，而不是对象本身
• 方法中不能嵌套方法

2.9.8 代码示例

/**
 * 方法/函数
 */
public class FuncStat {
    public static void main(String[] args) {
        testReturn();                         // testReturn
        int j = testReturnType(10);
        System.out.println(j);                // 10
        FuncStat funcStat = new FuncStat();   // 创建对象
        String str = funcStat.testMultiParam("jason", 18); // 通过对象名.方法名，调用非静态方法
        System.out.println(str);              // jason: 18岁
        testVarargs();                        // [I@1b6d3586
        testVarargs(1);                       // [I@4554617c
        testVarargs(2, 3, 4);                 // [I@74a14482
    }
    /**
     * return语句
     * 当返回值为void时，可以写，也可以省略
     */
    public static void testReturn(){
        System.out.println("testReturn");
        return;
    }
    /**
     * return后面的返回值必须和方法上声明的返回值类型一致
     * @param i
     * @return int类型
     */
    public static int testReturnType(int i){
        return i++;
    }
    /**
     * 形参可以是多个不同类型的参数，用“，”隔开
     * @param name
     * @param age
     * @return String类型
     */
    public String testMultiParam(String name, int age){
        String result = name + ": " + age + "岁";
        return result;
    }
    /**
     * 可变参数/不定长参数
     *  格式：方法名（数据类型... 变量名）
     *  例如：String... args， byte... agrs 等等
     *
     * 特点：
     *  1. 表示可以接收多个当前数据类型的变量
     *  2. 可看作是一个数组
     *  3. 一个方法中只能有一个不定长参数
     *      错误：(String... args, int... ints)
     *  4. 如果有其他类型参数一起，则不定长参数只能写在最后
     *      正确：(int in, String... args)
     *      错误：(String... args, int in)
     *  5. 调用时可以传入0个、1个或多个当前数据类型的实参，实参用逗号隔开
     *
     * 解析参数列表：
     *  请参阅{@link cn.com.liyanlong.java.javase._07_array.ArrayTest#testVarages(int...)}
     *  
     * @param args 参数列表
     */
    public static void testVarargs(int... args) {
        System.out.println(args);
    }
}

2.10 Java命名规范