【西行 - 官封弼马温】Java 基本程序设计结构

最新推荐文章于 2024-04-26 14:00:07 发布

J3code

最新推荐文章于 2024-04-26 14:00:07 发布

阅读量337

点赞数 4

分类专栏：【西行】一起学Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_40399646/article/details/122466235

版权

【西行】一起学Java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

J3 - 白起
Java（Java基础 # 程序设计结构 # 笔记）

1、Hello World

下面是一个简单的 Java 应用程序，它会在程序控制台中打印一句话 “Hello World”：

public class HelloWorld {
    
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
    
}

这代码看起来非常简单，但对于初学者来说，还是非常值得花一些时间研究的。

首先，Java 是区分大小写的，如果出现大小写拼写错误（如：main 写成 Main）程序将无法运行。

下面，我们就逐行分析一下每行代码的意思。

1.1 类

public class HelloWorld {

在 Java 中这种是形式的写法叫做一个类，class 后面的 HelloWorld 就是类的名字。而开头的 public class 两个词一个是修饰符、一个是关键字（这两个后面介绍）。

那什么是类？在 Java 中它代表一类物体。

哦！还是太抽象，没关系后面在面向对象的时候还会详细说明，在这里只要知道这种形式的写法就是一个类，它的名字叫做 HelloWorld 就行。

就像下面这个类，它的名字就叫做 J3，并且这个类的文件名是必须保存为 J3.java。

public class J3 {
}

类名后面是紧跟着一对大括号，大括号里面就是类的内容，那内容中可以放些什么呢！

变量
方法

1.2 方法

public static void main(String[] args) {

像这种写法，Java 中就叫做方法，public 是方法的访问修饰符，static 是关键字，void 表示方法的返回值是个空（没有返回值），而 main 则表示这个方法的名字，括号里面就是这个方法的参数。

那什么是方法？一种功能，描述类的功能，一段程序的载体。

Java 中的方法必须放在类中，也就是一个方法必须属于某个类，它不能独立存在。

1.3 main 方法

在 Java 应用中，所有的程序都会在主类中找到一个统一入口 main 方法，找到就运行反之则报错（报错信息就是找不到 main 方法）。

main 方法是所有 Java 程序执行的起点，如果我们执行下面代码则会出现如下报错：

public class HelloWorld {

    public static void j3(String[] args) {
        System.out.println("Hello World");
    }

}

在这里插入图片描述

上面简单的分析了一个可以执行的 Java 程序应该包括什么，对于很多名词都没有去分析，这个我是打算留在后面的，通过 HelloWorld 程序我们应该具备如下要点：

Java 区分大消息
认识 Java 类大致形式及方法
方法要写在类中
Java 程序入口是 main 方法

2、Java 中的注释

注释可以理解一种说明，可类比操作手册，它的作用可以有利于人们理解程序的意思。也和大多数程序语言一样，Java 中的注释不会出现在可执行程序中。

Java 中，常用的注释方法有三种：

单行注释： // 备注释的文字
多行注释： /* 要注释的文字 */
文档注释： /** 要注释的文字 */

看如下代码，便于理解：

/**
 * @author J3-西行
 * @package cn.baiqi.myjava.helloworld
 * @createTime 2022/1/11 - 11:49
 * @description 一路西行、与君共勉
 */
public class HelloWorld {

    // 这是单行注释
    public static void main(String[] args) {
        /*
        这是多行注释
        关注 J3 、带你精通各种语言的 Hello World
         */
        System.out.println("Hello World");
    }

}

3、标识符和关键字

Java 语言和其他编程语言一样，使用标识符作为变量、对象的名字，也提供了系列的关键字用以实现特别的功能。

3.1 分隔符

在了解标识符和关键字之前，先了解一下分隔符。

Java 语言中分号（;）、花括号（{}）、方括号（[]）、圆括号（()）、空格、圆点（.）都具有特殊的分隔作用，因此被统称为分隔符。

1、分号

Java 中每个语句的结尾都必须使用分号作为结尾。

Java 允许一行书写多个语句，每个语句之间以分号隔开即可；一行语句也可以跨多行，只要在最后结束的地方使用功能分号结束即可。

下面语句都是合法 Java 语句。

String blog = "J3-西行";
String motto = "不必遗憾。若是美好，" +
        "叫做精彩。若是糟糕，叫做经历。";
int age = 18; int height = 180;

虽然 Java 语法允许一行书写多个语句，但从程序可读性角度来看，应该避免在一行书写多个语句。

2、花括号

花括号的作用是定义一个代码块，一个代码块指的是 “{” 和 “}” 所包含的一段代码，代码块在逻辑上是一个整体。

在 Java 中类、方法的定义部分都必须放在一个代码块中。除此之外，条件语句中的条件执行体和循环语句中的循环体通常也放在代码块中。

花括号一般都是成对出现的，有一个 “{” 则必然后一个 “}”，反之也是一样。

3、方括号

这个主要用于数组访问元素，它通常紧跟变量名，而方括号里指定希望访问的数组元素的索引。

例如：

String[] names = new String[5];
names[0] = "J3-西行";

4、圆括号

圆括号是一个功能非常丰富的分隔符：定义方法是必须使用圆括号来包含所有的形参声明，调用方法时也必须使用圆括号来传入实参；不仅如此，圆括号还可以将表达式中某个部分扩成一个整体，保证这个部分优先计算；除此之外，圆括号还可以作为强制类型转换运算符。

5、空格

Java 中使用空格分隔一条语句的不同部分。

Java 语言是一门格式非常自由的语言，只要语句不符合你期望的格式，可以用空格进行任意的调整，但不要使用空格吧一个变量隔开，这将会导致程序报错。

Java 语言中的空格包含空格符（Space）、制表符（Tab）、和回车（Enter）等。

6、圆点

圆点（.）通常用作类 / 对象和它的成员（包括 Field、方法和内部类）之间的分隔符，表面调用某个类或某个实例的制定成员。

3.2 标识符

标识符：用于给程序中变量、类、方法命名的符号。

Java 语言的标识符必须是以字母、下划线（_）、美元符（$）开头，后面可以跟任何数目的字母、数字、下划线和美元符。

标识符中的字母不局限26个英文字母，还可以包含中文字符、日文字符等。

标识符中不可以包含空格，不能使用 Java 关键字和保留字，长度没有限制。

在使用标识符时，要注意如下规则：

标识符可以由字母、数字、下划线和美元符组成，其中数字不能开头。
标识符不能是 Java 关键字和保留字，但可以包含关键字和保留字。
标识符不能包含空格。
标识符智能包含美元符，不能包含 @ 、# 等其他特殊字符。

3.3 关键字

Java 中有一些具有特殊用途的单词被称为关键字（keyword），当定义标识符时，不要让标识符和关键字相同，否则将引起错误。

如下程序，会报错：

// Integer 类型的标识符 int 和 Java 中的关键字同名，报错
Integer int = 1;

Java 的所有关键字都是小写，TRUE、FALSE 和 NULL 都不是关键字。

Java 一共包含 48 个关键字，如表。

在这里插入图片描述

enum 是从 Java5 新增的关键字，用于定义一个枚举。

其中，保留字（goto、const）的意思是，Java 现在还未使用这两个单词作为关键字，但可能未来的 Java 版本中使用两个单词作为关键字。

Java 还提供了 3 个特殊的直接量：true、false 和 null。

在定义标识符的时候同样不能使用两个保留字和三个直接量。

4、数据类型

经过前面的了解，应该知道 Java 是一种强类型语言，所有声明的变量都必须指明其类型。

Java 中数据类型分为：基本数据类型和引用数据类型两种。

基本数据类型包括数值型（byte、short、int、long、float、double）、字符型（char）、boolean。

引用数据类型包括类、接口和数组类型，还有一些特殊的 null 类型。其实引用类型就是对一个对象的引用，对象包括实例和数组两种，不过，引用类型变量也可以理解为指针，只是 Java 语言不再使用指针这个说法。

4.1 基本数据类型

Java 的基本数据类型分为两大类：boolean 类型和数值类型。

而数值类型又可以分为整数类型和浮点类型，整数类型中的字符类型也是可以被单独分为一类，所以通常把 Java 里的基本数据类型分为 4 类，如图。

在这里插入图片描述

字符串不是基本数据类型，字符串类型是一个类，也就是一个引用数据类型。

1、整数类型

通常所说的整型，指的是如下 4 种类型。

byte：一个 byte 在内存里占 1 个字节（1字节 = 8位），表示的的数值范围：-128（-2 ^ 7）~ 127（2 ^ 7 - 1）
short：一个 short 类型整数在内存中占 2 个字节，表示的数值范围：-32768（-2 ^ 15）~ 32767（2 ^ 15 - 1）
int：一个 int 类型整数在内存里占 4 个字节，表示的数值范围：-2147483648（-2 ^ 31）~ 2147483647（2 ^ 31 - 1）
long：一个 long 类型整数在内存中占 8 个字节，表示的数值范围：-9223372036854775808（-2 ^ 63）~ -9223372036854775807（2 ^ 63 - 1）

int 是最常用的整数类型，因此在通常情况下，一个 Java 整数常量默认就是 int 类型。另外，在如下情况是必须指出整数类型。

如果直接将一个较小的整数常量（在 byte 或 short 类型的表数范围内）赋给一个 byte 或 short 变量，系统会自动把这个整数常量当成 byte 或者 short 类型来处理。
如果使用一个巨大的整数常量（超出了 int 类型的数值范围）时，Java 不会自动把这个整数常量当成 long 类型来处理。如果希望系统把一个整数常量当成 long 类型来处理，应该在整数常量后面增加 l 或者 L 作为后缀（推荐 L 因为 l 容易和 1 搞混）。

下面代码验证上面两者情况。

// 这是正确的，在类型数值范围内，系统会自动把 10 当成 byte 类型处理
byte i = 10;

/*
这是错误的，系统不会把 99999999999 当成 long，因为整数常量，系统默认类型是 int
而 99999999999 又超过 int 类型数值范围，所以报错
 */
long bigValue1 = 99999999999;

// 这是对的，在整数常量后面表明 L 表示是 long 类型数据
long bigValue2 = 99999999999L;

2、字符类型

字符类型通常用于表示单个的字符，字符常量必须使用单引号（’）括起来。

Java 语言使用 16 位的 Unicode 字符集作为编码方式，而 Unicode 是支持世界上所有书面语言的字符，包括中文字符，因此 Java 程序支持各种语言的字符。

字符类型常量有如下 3 中表示形式。

直接通过单个字符来指定字符型常量，例如：‘A’、‘9’ 和 ‘0’ 等。
通过转义字符表示特殊字符型常量，例如：’\n’、’\t’ 等。
直接使用 Unicode 值来表示字符型常量，格式是 ‘\uXXXX’，其中 XXXX 代表一个十六进制的整数。

Java 语言中常用的转义字符如表 3.2 所示、

转义字符	说明	Unicode 表示方式
\b	退格符	\u0008
\n	换行符	\u000a
\r	回车符	\u000d
\t	制表符	\u0009
\’’	双引号	\u0022
\’	单引号	\u0027
\\	反斜杠	\u005c

字符类型常量也可以采用十六进制编码方式表示，范围是 ‘\u0000’ ~ ‘\uFFFF’ ，一共可以表示 65535 个字符，其中前 256 个（’\u0000’ ~ ‘\u00FF’ ）字符和 ASCII 马中的字符完全重合。

不仅如此，char 类型的值也可以直接作为整数类型的值来使用，但他是一个 16 位的无符号整数，即全部是正数，表示范围是 0 ~ 65535。如果把该范围内的一个 int 正数赋值给 char 类型变量，系统会自动把这个 int 类型当成 char 类型来处理。

下面简单示范字符类型变量用法。

public class CharTest {

    public static void main(String[] args) {

        // 直接指定单个字符作为字符类型常量
        char jChar = 'j';
        //    使用转义字符作为字符类型常量
        char enterChar = '\r';
        //    使用 Unicode 编码值来制定字符类型常量
        char ch = '\u6666';
        System.out.println(ch);
        //    定义中文字符类型常量
        char name = '西';
        //    将 char 类型变为 int 类型使用
        int nameInt = name;
        System.out.println(nameInt);
        // 直接把 0 ~ 65535 范围内的一个 int 类型赋给 char 变量
        char c = 60034;
        System.out.println(c);
    }

}

3、浮点类型

Java 中浮点类型有两种：float 和 double。

double 类型代表双精度浮点数，float 类型代表单精度浮点数。一个 double 类型的数值占 8 个字节、64位，一个 float 类型的数值占 4 个字节、32 位。

Java 中浮点类型默认是 double 类型，如果希望 Java 吧一个浮点类型值当成 float 类型处理，应该在这个浮点类型后紧跟着 f 或者 F。例如，5.12 代表一个 double 类型的常量，占 64 位的内存空间；5.12f 或者 5.12F 才表示一个 float 类型的常量，占 32 位的内存空间。

下面简单示范浮点类型变量用法。

public class FloatTest {

    public static void main(String[] args) {

        // 超过 float 的精度会丢失
        float f = 5.121111111111f;
        // 输出：5.121111
        System.out.println(f);
        // 双精度不会，输出：5.121111111111
        double d = 5.121111111111;
        System.out.println(d);
        
    }
}

4、布尔类型

布尔型只有一个 boolean 类型，用于表示逻辑上的 “真” 或 “假”。

boolean 类型的数值只能是 true 或 false，不能用 0 或非 0 来代表。其他基本数据类型的值也不能转换成 boolean 类型。

// 定义 true
boolean a = true;
if (a) {
    System.out.println("广东最靓的仔 J3");
}
// 定义 false
boolean b = false;
if (b) {
    System.out.println(" J3 不帅");
}

5、类型转换

Java 程序中，不同的基本类型值经常需要进行相互转换。Java 语言所提供的 7 种数值类型之间可以相互转换，转换方式有两种：自动类型转换和强制类型转换。

5.1 自动类型转换

如果系统支持吧某种基本类型的值直接赋给另一种基本类型的变量，这种方式被称为自动类型转换。

当吧一个数值范围小的数值或变量直接赋给另一个数值范围大的变量时，系统可以进行自动类型转换。

自动转换关系如图。

在这里插入图片描述

图中，箭头左边的类型可以自动转换为右边类型，下面看案例。

public class AutoConversion {

    public static void main(String[] args) {

        // 定义最小数值类型
        byte b = 1;
        System.out.println(b);
        // 依次赋值给大数值类型，进行自动转换
        short s = b;
        System.out.println(s);
        int i = s;
        System.out.println(i);
        char c = 'A';
        System.out.println(c);
        int ic = c;
        System.out.println(ic);
        long l = i;
        System.out.println(l);
        float f = l;
        System.out.println(f);
        double d = f;
        System.out.println(d);
    }

}

5.2 强制类型转换

如果希望吧，上图中箭头右边的类型转换为左边的类型，则必须进行强制类型转换，转换语法格式是：（targetType）value，强制类型转换的运算符是括号（()）。

在将大数值范围类型数据强制转换为小数值范围类型时，则会导致数据丢失。

下面看看强制类型转换代码。

public class ForciblyConversion {

    public static void main(String[] args) {
        int i = 520;
        // 强制转换，数据溢出
        byte b = (byte) i;
        System.out.println(b);

        double d = 1.314;
        // 强制转换，丢失数据
        int dInt = (int) d;
        System.out.println(dInt);

    }
}

在上面代码中，把一个大数据赋值给小数据类型则会直接导致数据溢出；把一个浮点型数据赋给一直整型数据则会直接截断小数部分。

6、Java 运算符

运算符是一种特殊的符号，用于表示数据的运算、赋值和比较等。

Java 语言使用功能运算符讲一个或多个操作数链接成直线性语句，用于实现特定功能。

Java 语言中运算符分为如下几种：

算术运算符
赋值运算符
比较运算符
位运算符
类型相关运算符（比较、逻辑、三目）

6.1 算术运算符

Java 支持所有的基本算术运算符，这些算术运算符用于执行基本的数学运算：加、减、乘、除和求余等。

下面来看看 7 个基本算术运算符。

+：加法运算符。

double a = 5.0;
double b = 3.8;

double sum = a + b;
// sum = 8.8
System.out.println(sum);

除此之外，+ 还可以作为字符串的连接运算符。

-：减法运算符。

double a = 5.0;
double b = 3.8;

double sub = a - b;
// sub = 1.2
System.out.println(sub);

*：乘法运算符。

double a = 5.0;
double b = 4.0;

double m = a * b;
// m = 20.0
System.out.println(m);

/：除法运算符。

当运算符操作的两个数都是整数类型，计算结果为整数（截取整数部分）；如果运算符操作的两个数中有一个或者两个都是浮点数，计算结果则就是自然运算出来的结果，不会截取掉小数部分。

public class OperatorTest {

    public static void main(String[] args) {

        int a = 3;
        int b = 2;
        // 1
        System.out.println(a / b);

        double d = 9.5;
        int c = 3;
        // 3.1666666666666665
        System.out.println(d / c);

        // 正无穷大
        System.out.println(5 / 0.0);
        // 负无穷大
        System.out.println(-5 / 0.0);
        // 错误：/ byte zero
        System.out.println(5 / 0);
    }
}

%：求余运算符。

求余运算符的计算结果是第一个操作数除以第二个操作数，得到一个整除的结果后剩下的值就是余数，它的结果也不总是整数。

public class OperatorTest {

    public static void main(String[] args) {

        int a = 5;
        int b = 2;
        // 整数 1（余数）
        System.out.println(a % b);

        double c = 2.0;
        // 浮点数 1.0
        System.out.println(a % c);

        // 输出非数：NaN
        System.out.println(5.0 % 0);
        System.out.println(5 % 0.0);
        System.out.println(0 % 0.0);
        // 0.0
        System.out.println(0 % 5.0);
        // 报错：/ by zero
        System.out.println(5 % 0);

    }
}

++：自加。

这是单目运算符，运算符既可以出现在操作数的左边，也可以出现在操作数的右边。

左边相当于，先给数字 + 1 然后再运算；右边相当于，先运算，然后再 + 1。

int a = 3;
int b = 5;

int c = a++ + b;
// c = 8，a++ + b 相当于 c = a + b ; a = a + 1
System.out.println(c);
// a = 4
System.out.println(a);

a = 3;
int d = ++a + b;
// d = 9, ++a + b 相当于 a = a + 1 ; c = a + b;
System.out.println(d);
// a = 4
System.out.println(a);

–：自减。

和 ++ 一样也是单目运算符，是不是不是 + 1 而是 -1。

6.2 赋值运算符

赋值运算符用于为变量制定变量值，上面的所有代码都是用 = 进行赋值。

除了上面的赋值操作外，Java 赋值运算符还支持如下操作。

int f = a = b = c = d;

虽然 Java 支持这种一次为多个变量赋值的写法，但可读性不好，不建议这样做。

6.3 位运算符

Java 支持的位运算符有如下 7 个。

（&）：按位与。
（|）：按位或。
（~）：按位非。
（^）：按位异或。
（<<）：左移运算符。
（>>）：右移运算符。
（>>>）：无符号右移运算符。

按位与、按位或、按位异或运算法则如下：

第一个运算符	第而个运算符	按位与	按位或	按位异或
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0

按位非只需要一个操作数，这个运算符将把操作数在计算机底层的二进制码按位取反。

看如下代码。

// 16
System.out.println( 88 & 21);
// 7
System.out.println( 4 | 3);

88 的二进制码是 000000000000000000000001011000 而 21 的二进制码是 000000000000000000000000000010101 运算方式如图。

在这里插入图片描述

左移运算符是将运算符的二进制码整体左移指定位数，左移后右边空出来的位以 0 填充，示例如下。

// 352
System.out.println( 88 << 2);

运算图。

在这里插入图片描述

计算左移右移还可以使用如下方式：

左乘、右移

意思是左移几位就操作数乘于 2 的几次方、反之就除于 2 的几次方。例如，88 << 2 = 88 * 2 ^ 2 = 88 * 4 = 352、8 >> 2 = 8 / 2 ^ 2 = 8 / 4 = 2。

位移运算符并不适合所有的数值类型，他们只适合对 byte 、short 、char 、int 和 long 等整数类型进行运算。除此之外，进行位移运算时还需要遵循如下规则。

对于低于 int 类型（byte、short 和 char ）的操作数总是先自动类型转换为 int 类型后再移位。
对于 int 类型的整数移位 a >> b，当 b >> 32 时，系统先用 b 对 32 求余（因为 int 类型只有 32 位），得到的结果才是真正移位的位数。例如，a >> 33 和 a >> 1 的结果完全一样，而 a >> 32 的结果和 a 相同。
对于 long 类型的整数移位 a >> b，当 b > 64 时，总是先用 b 对 64 求余（因为 long 类型是 64 位），得到的结果才是真正移位的位数。

6.4 比较运算符

比较运算符用于判断两个变量或常量的大小，比较的结果是一个布尔值（true 或 false）。

Java 支持的比较运算符如下：

大于（ > ）：只支持左右两边操作数是数字类型，如果前面变量的值大于后面，返回 true。
大于等于（ >= ）：只支持左右两边操作数是数字类型，如果前面变量的值大于等于后面，返回 true。
小于（ < ）：只支持左右两边操作数是数字类型，如果前面变量的值小于后面，返回 true。
小于等于（ <= ）：只支持左右两边操作数是数字类型，如果前面变量的值小于等于后面，返回 true。
等于（ == ）：如果比较的两个操作数都是数值类型，即使它们的数据类型不相同，只要它们的值相等，也都返回 true 。例如 97 == ‘a’ 返回 true，5.0 == 5 也返回 true。如果两个操作数比较的是引用类型，那么只有当两个引用变量引用相同的实例时才可以比较，而且这两个引用必须指向同一个对象才会返回 true。
不等于（ != ）：如果比较的两个操作数都是数值类型，无论他们的数据类型是否相同，只要他们的值不相等，也都返回 true。如果两个操作数都是引用类型，只有当两个引用变量引用相同的类型实例时才可以比较，只要两个引用指向的不是同一个对象就会返回 true。

public class CompareTest {

    public static void main(String[] args) {

        // true
        System.out.println("5.0 是否大于 4.5：" + (5.0 > 4.5));
        // true
        System.out.println("5.0 是否等于 5：" + (5.0 == 5));
        // true
        System.out.println("97 是否等于 A：" + (97 == 'a'));
        // false
        System.out.println("true 是否等于 false：" + (true == false));

        CompareTest c1 = new CompareTest();
        CompareTest c2 = new CompareTest();

        // false
        System.out.println("c1 是否等于 c2：" + (c1 == c2));

        CompareTest c3 = c1;
        // true
        System.out.println("c3 是否等于 c1：" + (c1 == c3));

    }
}

6.5 逻辑运算符

逻辑运算符用于操作两个布尔类型的变量或者常量，逻辑运算符主要有如下 6 个。

与（ $$ ）：前后两个操作数必须都是 true 才返回 true，否则返回 false。
不短路与（ & ）：和 && 作用相同，但不会发生短路。
或（ || ）：只要两个数中有一个是 true，就可以返回 true，否则返回 false。
不短路或（ | ）：和 || 作用相同，但不会发生短路。
非（ ! ）：只需要一个操作数，如果操作数为 true ，则返回 false；如果操作数为 false，则返回 true。
异或（ ^ ）：当两个操作数不同是才返回 true，如果两个操作数相同则返回 false。

public class LogicTest {

    public static void main(String[] args) {

        int a = 5;
        int b = 11;
        // false
        System.out.println((a == b && a == 4));
        // false，发生短路
        System.out.println((a == b && a-- == 4));
        // a = 5
        System.out.println(a);
        // false，没有发生短路
        System.out.println((b == 11 && a-- == 6));
        // a = 4
        System.out.println(a);

        a = 5;
        b = 11;
        // false 不发生短路
        System.out.println((a == b & a-- == 4));
        // 4
        System.out.println(a);

        // false
        System.out.println(!true);
    }
}

短路分两种情况。

&& 短路，当运算符左边的操作数是 false 时，发生短路，不会执行右边的判断逻辑。
|| 短路，当运算符左边操作数是 true 是，发生短路，不会执行右边的判断逻辑。

6.6 三目运算符

三目运算符只有一个：？，格式如下

表达式？结果1 ：结果2

如果表达式为 true 则结果就是结果1，反之就是结果2，代码如下。

int a = 4;
// a 不等于 5
System.out.println(a == 5 ? "a 等于 5" : "a 不等于 5");

6.7 运算符的结合性和优先级

Java 语言中大部分运算符只从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。

乘法和加法是两个可结合的运算，也就是说，这两个运算符左右两边的操作数可以互换位置而不会影响结果。

运算符有不同的优先级，即在表达式中的运算顺序。

运算符优先级如下表，优先级由上到下递减。

运算符说明	Java运算符
分隔符	. [] () {} , ;
单目运算符	++ – ~ !
强制类型转换运算符	(type)
乘法、除法、求余运算符	* / %
加法、减法运算符	+ -
位移运算符	<< >> >>>
关系运算符	< <= >= > instanceof
等价运算符	== !=
按位与运算符	&
按位异或运算符	^
按位或运算符	\|
条件与运算符	&&
条件或运算符	\|\|
三目运算符	?:
赋值运算符	=

根据表中的优先级，我们分析一段代码。

int a = 4;
int b = a + 2 * a;

程序先执行 2 * a 的到 6，在执行 a + 6 得到 9。

当然上面的程序是非常简单的，但是有些面试题难度可不止这点，例如：

int a = 5;
int b = 4;
int c = a++ - --b * ++a / b-- >> 2 % a--;
// -1
System.out.println(c);

c 的值是多少？

看到这样的语句幸好是只出现在面试题中，要是谁代码中这样写，那我就要抓毛了。

因此，编写表达式时：

不要把一个表达式写的过于复杂，如果表达式过于发杂，那先分成几步来完成
不要过多的依赖运算符的优先级来控制表达式的执行顺序，可读性非常差，尽量使用（）来控制执行顺序。

好了，今天的内容到这里就结束了，关注我，我们下期见

查阅或参考资料：

《疯狂 Java 讲义》

联系方式：

QQ：1491989462，做个好友，来个点赞之交。

由于博主才疏学浅，难免会有纰漏，假如你发现了错误或偏见的地方，还望留言给我指出来，我会对其加以修正。
如果你觉得文章还不错，你的转发、分享、点赞、留言就是对我最大的鼓励。
感谢您的阅读，十分欢迎并感谢您的关注。

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

个人站点：J3

CSDN：J3 - 白起

掘金：J3-白起

知乎：J3-白起

这是一个技术一般，但热衷于分享；经验尚浅，但脸皮够厚；明明年轻有颜值，但非要靠才华吃饭的程序员。

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

J3code

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
【西行 - 官封弼马温】Java 基本程序设计结构

J3 - 白起Java（Java基础 # 程序设计结构 # 笔记）1、Hello World下面是一个简单的 Java 应用程序，它会在程序控制台中打印一句话 “Hello World”：public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World"); } }这代码看起来非常简单，但对于初学者来说，还..
复制链接

扫一扫