2-Java 基础语法

2.1 注释

为了方便程序的阅读,Java 语言允许程序员在程序中写上一些说明性的文字,用来提高程序的可读性,这些文字性的说明就称为注释。

注释不会出现在字节码文件中,即 Java 编译器编译时会跳过注释语句。

在 Java 中根据注释的功能不同,主要分为单行注释、多行注释和文档注释。

  • 单行注释:使用//开头,//后面的单行内容均为注释。

    // 这是单行注释文字
    
  • 多行注释:以/*开头以*/结尾,在/**/之间的内容为注释,我们也可以使用多行注释作为行内注释。但是在使用时要注意,多行注释不能嵌套使用

    /*
    这是多行注释文字
    这是多行注释文字
    这是多行注释文字
    */
    
    
  • 文档注释:以/**开头以*/结尾,注释中包含一些说明性的文字及一些 JavaDoc 标签(后期写项目时,可以生成项目的 API)。

    /**
     * Welcome类(我是文档注释)
     * @author IZJ
     * @version 1.0
     */
    

注释在实际开发中的应用:

/**
 * TestComment类,用来测试注释的用法
 * @author IZJ
 */
public class TestComment {
  /**
   * 程序入口
   * @param args 参数
   */
  public static void main(String[] args /* args 参数,可以更改其名称 */) {
    System.out.println("测试注释"); //这是打印语句
  }
  
  /*
     我是多行注释
     我是多行注释
     我是多行注释
     我是多行注释
   */
}

2.2 标识符

标识符是用来给变量、类、方法以及包进行命名的,如 Welcome、main、System、age、name、gender 等。标识符需要遵守一定的规则:

  • 由字母、数字、下划线“_”、美元符号“$”组成,第一个字符不能是数字。
  • 不能使用 Java 中的关键字作为标识符。
  • 标识符对大小写敏感(区分大小写),且长度无限制。

Java 中标识符的命名约定:

  • 表示类名的标识符:每个单词的首字母大写,如 Man, GoodMan
  • 表示方法和变量的标识符:第一个单词小写,从第二个单词开始首字母大写,我们称之为“驼峰原则”,如 eat(), eatFood()

另外,标识符的命名最好可以做到见名知意。例如:username、studentNumber 等。

Java 不采用通常语言使用的 ASCII 字符集,而是采用 Unicode 这样标准的国际字符集。因此,这里字母的含义不仅仅是英文,还包括汉字等等。但是不建议大家使用汉字来定义标识符

  • 合法的标识符

    int a = 3;
    int _123 = 3;
    int $12aa = 3;
    int 变量1 = 55;  //合法,但是不建议使用中文命名的标识符
    
  • 不合法的标识符

    int 1a = 3;   //不能用数字开头
    int a# = 3;   //不能包含#这样的特殊字符
    int int = 3;  //不能使用关键字
    

标识符的基本应用:

/**
 * 测试标识符
 * @author IZJ
 *
 */
public class TestIdentifier {
  public static void main(String[] args) {
    int a123 = 1;
//    int 123a = 2; // 数字不能开头
    int $a = 3;
    int _abc = 4;
//    int #abc = 5; // 标识符可用字符不包括#
//    int int = 6; // 关键字不能作为标识符
  }
}

2.3 Java 关键字/保留字

Java 关键字是 Java 语言保留供内部使用的,如 class 用于定义类。关键字也可以称为保留字,它们的意思是一样的,我们不能使用关键字作为变量名或方法名。

关键字的特点:

  • 关键字的字母全部小写。

  • 常用的代码编辑器对关键字都有高亮显示,比如现在我们能看到的 public、class、static 等。

abstractassertbooleanbreakbytecase
catchcharclassconstcontinuedefault
dodoubleelseextendsfinalfinally
floatforgotoifimplementsimport
instanceofintinterfacelongnativenew
nullpackageprivateprotectedpublicreturn
shortstaticstrictfpsuperswitchsynchronized
thisthrowthrowstransienttryvoid
volatilewhile

出于应试教育的惯性思维,很多人很可能去背上面的单词,从实战思维出发,我们不需要刻意去记!随着学习的深入,自然就非常熟悉了。

2.4 变量

2.4.1 变量的本质

变量(variable):在程序运行过程中,其值可以发生改变的量。

变量本质上就是代表一个“可操作的存储空间”,空间位置是确定的,但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”,从而操纵这个“存储空间”存储的值。

Java 是一种强类型语言,每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。 比如,int a = 3; 表示 a 变量的空间大小为 4 个字节。

变量作为程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后,才能为其分配相应长度的存储空间。

2.4.2 变量的定义格式

type varName [=value][,varName[=value]...]; 
// []中的内容为可选项,即可有可无
数据类型  变量名  [=初始值] [,变量名  [=初始值]…];
  • 格式一:

    数据类型 变量名 = 初始化值; // 声明变量并赋值
    int age = 18;
    
  • 格式二

    // 先声明,后赋值(使用前赋值即可)
    数据类型 变量名;
    变量名 = 初始化值;
    double money;
    money = 55.5;
    
  • 格式三,不提倡这种“一行声明多个变量”风格,逐一声明每一个变量可以提高程序可读性。

    int a = 10, b = 20; // 定义 int 类型的变量 a 和 b,中间使用逗号隔开
    int c, d; // 声明int类型的变量 c 和 d,中间使用逗号隔开
    c = 30;
    d = 40; 
    

不同数据类型的常量会在内存中分配不同的空间,如图所示。

double salary;
long earthPopulation;
int age;

2.4.3 注意事项

  • 每个变量都有类型,类型可以是基本类型,也可以是引用类型。

  • 变量名必须是合法的标识符

  • 变量声明是一条完整的语句,因此每一个声明都必须以分号结束

  • 变量在使用之前,必须初始化(赋值)。

  • <定义 long 类型的变量时,需要在整数的后面加 L(大小写均可,建议大写)。因为整数默认是 int 类型,整数太大可能超出 int 范围。

  • 定义 float 类型的变量时,需要在小数的后面加 F(大小写均可,建议大写)。因为浮点数的默认类型是 double, double 的取值范围是大于 float 的,类型不兼容。

  • 在同一对花括号中,变量名不能重复。

2.4.4 变量的分类

从整体上可将变量划分为局部变量、成员变量(也称为实例变量)和静态变量。

类型声明位置从属于生命周期
局部变量方法或语句块内部方法/语句块从声明位置开始,直到方法或语句块执行完毕,局部变量消失;
成员变量(实例变量)类内部,方法外部对象对象创建,成员变量也跟着创建。对象消失,成员变量也跟着消失;
静态变量(类变量)类内部,static 修饰类被加载,静态变量就有效;类被卸载,静态变量消失。

成员变量和静态变量不是目前重点,不要过多纠结理解与否。当学习到面向对象时,会深入理解成员变量和静态变量

  • 局部变量(local variable)

    方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。

    public void test() {
       int i;
       int j = i + 5 ; // 编译出错,变量i还未被初始化 
    } 
    
    public void test() {
       int i;
       i = 10;
       int j = i + 5 ; // 编译正确
    }
    
  • 成员变量(实例变量 member variable)

    方法外部、类的内部定义的变量。从属于对象,生命周期伴随对象始终。如果不自行初始化,它会自动初始化成该类型的默认初始值。

    数据类型实始值
    int0
    double0.0
    char'\u0000'
    booleanfalse
    public class Test {
        int i;
    }
    
  • 静态变量(类变量 static variable)

    使用 static 定义。 从属于类,生命周期伴随类始终,从类加载到卸载。如果不自行初始化,与成员变量相同会自动初始化成该类型的默认初始值。

2.5 常量

常量(constant):通常指的是一个固定的值,例如:1、2、3、'a'、'b'、true、false、"helloWorld"等。

在 Java 语言中,主要是利用关键字 final 来定义一个常量。 常量一旦被初始化后不能再更改其值。

格式final type varName = value;

常量的声明及使用:

public class TestConstants {
    public static void main(String[] args) {
        final double PI = 3.14;
        // PI = 3.15; // 编译错误,不能再被赋值! 
        double r = 4;
        double area = PI * r * r;
        double circle = 2 * PI * r;
        System.out.println("area = " + area);
        System.out.println("circle = " + circle);
    }
}

为了更好的区分和表述,一般将1、2、3、'a'、'b'、true、false、"helloWorld" 等称为字面常量,而使用 final 修饰的 PI 等称为符号常量

2.6 命名规范

变量和常量命名规范(规范是程序员的基本准则,不规范会直接损害你的个人形象):

  1. 所有变量、方法、类名:见名知意
  2. 类成员变量:首字母小写和驼峰原则: monthSalary
  3. 局部变量:首字母小写和驼峰原则
  4. 常量:大写字母和下划线:MAX_VALUE
  5. 类名:首字母大写和驼峰原则: Man,GoodMan
  6. 方法名:首字母小写和驼峰原则: run(),runRun()

2.7 数据类型 —— 基本数据类型

Java是一种强类型语言,每个变量都必须声明其数据类型。 Java的数据类型可分为两大类:基本数据类型(primitive data type)和引用数据类型(reference data type)。

下面只讲解基本数据类型,关于引用数据类型,到面向对象会详细说明。

Java 中定义了 3 类 8 种基本数据类型

  • 数值型 —— byte、 short、int、 long、float、 double
  • 字符型 —— char
  • 布尔型 —— boolean
数据类型关键字内存占用取值范围
整数类型byte1 byte$-128$ ~ $127$
short2 byte$-32768$ ~ $32767$
int(默认)4 byte$-2{31}$ ~ $2{31}-1$
long8 byte$-2{63}$ ~ $2{63}-1$
浮点类型float4 byte负数:$-3.402823E+38$ ~ $-1.401298E-45$
正数: $1.401298E-45$ ~ $3.402823E+38$
double(默认)8 byte负数:$-1.797693E+308$ ~ $-4.9000000E-324$
正数:$4.9000000E-324$ ~ $1.797693E+308$
字符类型char2 byte$0$ ~ $65535$
布尔类型boolean1 bittrue,false

注意事项

  • 引用数据类型的大小统一为 4 byte,记录的是其引用对象的地址!

2.7.1 整型变量/常量

整型用于表示没有小数部分的数值,它允许是负数。整型的范围与运行 Java 代码的机器无关,这正是 Java 程序具有很强移植能力的原因之一。与此相反,C 和 C++ 程序需要针对不同的处理器选择最有效的整型。

类型占用存储空间表数范围
byte1 字节$-27$ ~ $27-1$($-128$ ~ $127$)
short2 字节$-2{15}$ ~ $2{15} - 1$($-32768$ ~ $32767$)
int4 字节$-2{31}$ ~ $2{31}-1$ ($-2147483648$ ~ $2147483647$)约 21 亿
long8 字节$-2{63}$ ~ $2{63}-1$

Java 语言整型常量的四种表示形式

  • 十进制整数,如:99,-500,0
  • 八进制整数,要求以 0 开头,如:015
  • 十六进制数,要求 0x 或 0X 开头,如:0x15
  • 二进制数,要求 0b 或 0B 开头,如:0b01110011

Java 语言的整型常数默认为 int 型,声明 long 型常量可以后加 'l' 或 'L' 。

long a = 55555555;  // 编译成功,在int表示的范围内(21亿内)。
long b = 55555555555; // 不加 L 编译错误,已经超过 int 表示的范围。
// 应该修改为
long b = 55555555555L; 

说明:e+38 表示是 10 的 38 次方,同样,e-45 表示 10 的负 45 次方。

/**
 * 测试基本数据类型
 * @author IZJ
 *
 */
public class TestPrimitiveDataType {
    public static void main(String[] args) {
        // 测试整型变量
        int a = 15;
        int b = 015;  // 八进制
        int c = 0x15;  // 十六进制
        int d = 0b1000;  // 二进制
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

2.7.2 浮点型变量/常量

带小数的数据在 Java 中称为浮点型。浮点型可分为 float 类型和 double 类型。

类型占用存储空间表数范围
float4 字节$-3.403E38$ ~ $3.403E38$
double8 字节$-1.798E308$ ~ $1.798E308$

float 类型又被称作单精度类型,尾数可以精确到 7 位有效数字,在很多情况下,float 类型的精度很难满足需求。而 double 表示这种类型的数值精度约是float 类型的两倍,又被称作双精度类型,绝大部分应用程序都采用 double 类型。浮点型常量默认类型也是 double。

Java浮点类型常量有两种表示形式

  • 十进制数形式,例如:3.14,314.0,0.314
  • 科学记数法形式,如314e2,314E2,314E-2

1. 科学计数法

double f = 314e2;  // 314*10^2 --> 31400.0
double f2 = 314e-2; // 314*10^(-2) --> 3.14

float 类型的数值有一个后缀 F 或者 f ,没有后缀 F/f 的浮点数值默认为 double 类型。也可以在浮点数值后添加后缀 D 或者 d, 以明确其为 double 类型。

2. float 类型赋值时需要添加后缀 F/f

float f = 3.14F;
double d1  = 3.14;
double d2 = 3.14D;

浮点类型 float,double 的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算,需要使用 BigDecimal 类。

3. 浮点数的比较

float f = 0.1f;
double d = 1.0/10;
System.out.println(f == d); // 结果为 false

float d1 = 423432423f;
float d2 = d1+1;
if (d1 == d2) { // 输出结果为 d1==d2
    System.out.println("d1==d2");
} else {
    System.out.println("d1!=d2");
}

第一个结果为 false 是因为由于字长有限,浮点数能够精确表示的数是有限的,因而也是离散的。 浮点数一般都存在舍入误差,很多数字无法精确表示(例如 0.1),其结果只能是接近, 但不等于。二进制浮点数不能精确的表示诸如 0.1、0.01、0.001 这样 10 的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。

java.math 包下面的两个有用的类:BigInteger 和 BigDecimal,这两个类可以处理任意长度的数值。BigInteger 实现了任意精度的整数运算。BigDecimal 实现了任意精度的浮点运算。

不要使用浮点数进行比较!很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误!需要比较请使用 BigDecimal 类

4. 使用 BigDecimal 进行浮点数的比较

import java.math.BigDecimal;
public class Main {
    public static void main(String[] args) {
        // 使用精确的浮点运算,推荐 BigDecimal
        BigDecimal bd = BigDecimal.valueOf(1.0);
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        bd = bd.subtract(BigDecimal.valueOf(0.1));
        System.out.println(bd); // 0.5
        System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1); // 0.5000000000000001
    }
}

5. 浮点数使用总结

  • 默认是 double 类型;
  • 浮点数存在舍入误差,数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算,需要使用 BigDecimal 类
  • 避免比较中使用浮点数,需要比较请使用 BigDecimal 类。

2.7.3 字符型常量/变量

字符型在内存中占 2 个字节,在 Java 中使用单引号来表示字符常量。例如 'A' 是一个字符,它与 "A" 是不同的,"A" 表示含有一个字符的字符串。

char 类型用来表示在 Unicode 编码表中的字符。Unicode 编码被设计用来处理各种语言的文字,它占 2 个字节,可允许有 65536 个字符。

  • 字符型举例

    char eChar = 'a'; 
    char cChar = '中';
    
  • 字符型的十六进制值表示方法

    Unicode 具有从 0 到 65535 之间的编码,他们通常用从 '\u0000''\uFFFF' 之间的十六进制值来表示(前缀为 u 表示 Unicode)。

    char c = '\u0061';
    
  • 转义字符

    Java 语言中还允许使用转义字符 \ 来将其后的字符转变为其它的含义。

    char c2 = '\n';  // 代表换行符
    

    常用的转义字符及其含义如表所示。

转义符含义Unicode 值
\b退格(backspace)\u0008
\n换行\u000a
\r回车\u000d
\t制表符(tab)\u0009
"双引号\u0022
'单引号\u0027
\反斜杠\u005c

以后常用的 String 类,其实是字符序列(char sequence)。

/**
 * 测试字符类型
 *
 * @author IZJ
 */
public class TestPrimitiveDataType3 {
    public static void main(String[] args) {
        char  a = 'T';
        char  b = '杰';
        char c = '\u0061';
        System.out.println(c);

        // 转义字符
        System.out.println("" + 'a' + '\n' + 'b'); 
        System.out.println("" + 'a' + '\t' + 'b'); 
        System.out.println("" + 'a' + '\'' + 'b'); //a'b

        // String 就是字符序列
        String  d = "abc";
    }
}

2.7.4 boolean 类型变量/常量

boolean 类型有两个常量值,true 和 false,在内存中占一位(1 bit,不是一字节(1 byte)),不可以使用 0 或非 0 的整数替代 true 和 false ,这点和 C 语言不同。 boolean 类型用来判断逻辑条件,一般用于程序流程控制 。

// 测试布尔类型
boolean man = true;
if (man) {
    System.out.println("男");
} else {
    System.out.println("女");
}

Less is More!!!请不要这样写:if (flag == true)。很容易写错成if (flag = true),这样就变成赋值 flag 为 true 而不是判断! 通常的写法应该是if (flag) 或者if (!flag)