第2章（Java 的基本程序设计结构）_java采用女层结构设计类,实现某系统的某个功能-CSDN博客

本文链接：https://blog.csdn.net/qq_52166656/article/details/125632307

第2章（Java 的基本程序设计结构）

文章目录

第2章（Java 的基本程序设计结构）
第3章（Java面向对象）

2.1一个简单的 Java 应用程序

public class Demo1 {
    public static void main(String[] args) {

        System.out.println("hello java !");
    }
}

在这里插入图片描述

它只发送一条消息到控制台窗口中输出:hello java !

首先， Java区分大小写 。如果出现了大小写拼写错误（例如，将 main 拼写成 Main ) ,程序将无法运行。关键字 public 称为访问修饰符（ access modifier ) ,这些修饰符用于控制程序的其他部分对这段代码的访问级別。
关键字 class 表明Java 程序中的全部内容都包含在类中。
关键字 class 后面紧跟类名 。 Java 中定义类名的规则很宽松。 名字必须以字母开头 ，后面可以跟字母和数字的任意组合。长度基本上没有限制。但是不能使用Java 保留字 , 如果名字由多个单词组成，每个单词的第一个字母都应该大写（这种在一个单词中间使用大写字母的方式称为驼峰命名法。以其自身为例，应该写成CamelCase ) 。
一对大括号表示方法体的开始与结束 ，在这个方法中只包含一条语句。与大多数程序设计语言一样，可以将 Java 语句看成是这种语言的句子。在 Java 中，每个句子必须用分号结束。特别需要说明，回车不是语句的结束标志，因此，如果需要可以将一条语句写在多行上。
在这里，使用了 System . out 对象并调用了它的 println 方法。
在这个示例中，调用了 println 方法并传递给它一个字符串参数 。这个方法将传递给它的字符串参数显示在控制台上。然后，终止这个输出行， 使得每次调用 println 都会在新的一行上显示输出。

2.2注释

在 Java 中，有 3 种标记注释的方式。最常用的方式是使用 / / ，其注释内容从/ / 开始到本行结尾。
当需要长篇的注释时，既可以在每行的注释前面标记 //，也可以使用 / *和 * / 将一段比较长的注释括起来。
自动地生成文档，这种注释以 / * *开始，以 * / 结束。

在这里插入图片描述

2.3数据类型

Java 是一种强类型语言 。这就意味着必须为每一个变量声明一种类型 : 在 Java 中，一共有 8种基本类型 （ primitive type ) , 其中有 4 种整型、 2 种浮点类型、 1 种用于表示 Unicode 编码的字符单元的字符类型 char ( 请参见论述 char 类型的章节）和 1 种用于表示真值的 boolean 类型。

2.3.1整型

在这里插入图片描述
整型用于表示没有小数部分的数值，它允许是负数。 Java 提供了 4 种整型，具体内容如表 3 - 1 所示。

在通常情况下， int类型最常用。但如果表示星球上的居住人数，就需要使用 long 类型了。 byte和 short 类型主要用于特定的应用场合，例如，底层的文件处理或者需要控制占用存储空间量的大数组。

注意：在 Java 中，整型的范围与运行 Java 代码的机器无关。这就解决了软件从一个平台移植到另一个平台，或者在同一个平台中的不同操作系统之间进行移植给程序员带来的诸多问题。

2.3.2浮点型

浮点类型用于表示有小数部分的数值。在 Java 中有两种浮点类型，具体内容如表 3 - 2 所示。
在这里插入图片描述

double 表示这种类型的数值精度是 float 类型的两倍（有人称之为双精度数值 ) 。 绝大部分应用程序都采用 double 类型。在很多情况下， float 类型的精度很难满足需求。实际上，只有很少的情况适合使用 float 类型，例如，需要单精度数据的库，或者需要存储大量数据。float 类型的数值有一个后缀 F 或 f ( 例如， 3.14 F ) 。没有后缀 F的浮点数值（如 3.14 ) 默认为 double 类型。 当然，也可以在浮点数值后面添加后缀D 或 d ( 例如， 3.14 D ) 。

2.3.3字符型

char 类型用于表示单个字符。

char 类型的字面量值要用单引号括起来。例如： W 是编码值为65 所对应的字符常量。它与 " A " 不同， " A " 是包含一个字符 A的字符串。
在这里插入图片描述

2.2.4boolean 类型

boolean ( 布尔）类型有两个值： false 和 true , 用来判定逻辑条件整型值和布尔值之间不能进行相互转换。

在这里插入图片描述

2.4变量

在 Java 中，每个变量都有一个类型（ type ) 。在声明变量时，变量的类型位于变量名之前。这里列举一些声明变量的示例：

double salary ;
int vacationDays ;
long earthPopulation ;
boolean done

可以看到，每个声明以分号结束。由于声明是一条完整的 Java 语句，所以必须以分号结束。变量名必须是一个以字母开头并由字母或数字构成的序列。

2.4.1变量的初始化

声明一个变量之后， 必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量。 例如， Java 编译器认为下面的语句序列是错误的：

int vacationDays ;
System.out.println(vacationDays);//错误

2.4.2常量

在 Java 中，利用关键字 final 指示常量。例如：

final double FLAG = 1;

关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。 习惯上 ,常量名使用全大写。

在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final设置一个类常量。下面是使用类常量的示例：

static final FLAG = 1;

2.5运算符

在 Java 中，使用算术运算符+、 - 、 / 表示加、减、乘、除运算。当参与 / 运算的两个操作数都是整数时，表示整数除法；否则，表示浮点除法。整数的求余操作（有时称为取模 )用％表示。例如， 15 / 2 等于7， 15 % 2 等于1 , 15.0 / 2 等于 7.50需要注意，整数被 0 除将会产生一个异常，而浮点数被0 除将会得到无穷大或 NaN 结果。

/*
算数运算符用例
*/
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(10/4); //结果是2.5 在java中取整数2
        System.out.println(1/3);//结果是0.333 在java中取整数0
        System.out.println(10.0/4);//在java中结果为2.5
        
       ————————————————————————————————————————————————————————————————————————
        // % 取模 ,取余
        // 在 % 的本质 看一个公式!!!! a % b = a - a / b * b
        // -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
        // 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
}
}

2.5.1数学函数与常量

2.5.1.1平方根函数

在 Math 类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函数也不同。要想计算一个数值的平方根，可以使用 sqrt 方法：

public class Demo1 {
    public static void main(String[] args) {
        double x = 4;
        double y = Math.sqrt(x);
        System.out.println(y); //结果为2.0
    }
}

2.5.1.2幂函数

在 Java 中，没有幂运算，因此需要借助于 Math 类的 pow 方法。语句：

public class Demo1 {
    public static void main(String[] args) {
        double x = 4;
        double y = Math.pow(x, 2);
        System.out.println(y);
    }
}

2.5.2数值类型之间的转换

经常需要将一种数值类型转换为另一种数值类型。 图 3 - 1 给出了数值类型之间的合法转换。

在这里插入图片描述

在图 3 - 1 中有 6 个实心箭头， 表示无信息丢失的转换 ；有 3 个虚箭头， 表示可能有精度损失的转换。例如， 123456 789 是一个大整数，它所包含的位数比 float 类型所能够表达的位数多。当将这个整型数值转换为 float 类型时，将会得到同样大小的结果，但却失去了一定的精度。

int n = 123456789 ;
float f = n ; // f is 1.23456792 E 8

当使用上面两个数值进行二元操作时（例如 n + f， n 是整数， f是浮点数 )，先要将两个第操作数转换为同一种类型，然后再进行计算。

如果两个操作数中有一个是 double类型，另一个操作数就会转换为 double 类型。
否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。
否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。
否则，两个操作数都将被转换为 int 类型。

转换关系如下：

在这里插入图片描述

2.5.3强制类型转换

在必要的时候， int 类型的值将会自动地转换为 double 类型。但另一方面，有时也需要将 double 转换成 int 。在 Java 中，允许进行这种数值之间的类型转换。当然，有可能会丢失一些信息。在这种情况下，需要通过强制类型转换（ cast )实现这个操作。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：

double x  = 9.997 ;
int nx = ( int ) x ;

这样，变量 nx 的值为 9。强制类型转换通过截断小数部分将浮点值转换为整型。

如果想对浮点数进行舍人运算，以便得到最接近的整数（在很多情况下，这种操作更有用 )，那就需要使用 Math. round方法(四舍五入) ：
```
double x z 9.997 ;
int nx = ( int ) Math . round ( x ) ;
```
现在，变量 nx 的值为 10。当调用 round 的时候，仍然需要使用强制类型转换（ int ) 。其原因是 round 方法返回的结果为 long 类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将 long 类型转换成 int 类型。现在，变量 nx 的值为 10。当调用 round 的时候，仍然需要使用强制类型转换（ int ) 。其原因是 round 方法返回的结果为 long 类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将 long 类型转换成 int 类型。

2.5.4结合赋值和运算符

可以在赋值中使用二元运算符，这是一种很方便的简写形式。例如 :

X + = 4 ;//等价于 ：x = x + 4 ;( 一般地， 要把运算符放在 = 号左边 ， 如 * = 或 ％ = ) 。

2.5.5自增与自减运算符

当然，程序员都知道加 1 、减 1 是数值变量最常见的操作。在 Java 中，借鉴了 C 和 C + +的做法，也提供了自增、自减运算符： n ++ 将变量n 的当前值加 1 , n - - 则将 n 的值减 1。例如，以下代码：int n = 12 ;n ++ ;将 n 的值改为 13。由于这些运算符会改变变量的值，所以它们的操作数不能是数值。例如，4 + + 就不是一个合法的语句。

2.5.6括号与运算符的优先级

表 3 - 4 给出了运算符的优先级。如果不使用圆括号，就按照给出的运算符优先级次序进行计算。同一个级别的运算符按照从左到右的次序进行计算（除了表中给出的右结合运算符外。

在这里插入图片描述

2.5.7枚举类型

有时候，变量的取值只在一个有限的集合内。例如：销售的服装或比萨饼只有小、中、大和超大这四种尺寸。当然，可以将这些尺寸分别编码为 1、 2 、 3 、 4 或S、 M 、L 、 X。但这样存在着一定的隐患。在变量中很可能保存的是一个错误的值（如 0 或 m ) 。针对这种情况，可以自定义枚举类型。枚举类型包括有限个命名的值。例如：

e _ Size { SMALL , MEDIUM , LARGE , EXTRA . LARCE } ;
Size s = Size . MEDIUM ;

Size 类型的变量只能存储这个类型声明中给定的某个枚举值，或者 null 值， null 表示这个变量没有设置任何值。

2.6字符串

每个用双引号括起来的字符串都是String 类的一个实例：

String e = "" ; / / an empty string
String greeting = " Hello " ;

2.6.1子串

2.6.1.1字符串截取

String 类的 substring 方法可以从一个较大的字符串提取出一个子串。例如：

public class Demo1 {
    public static void main(String[] args) {
        String greeting = " Hello123455 " ;
        String s = greeting.substring(1,4); //从第一个位置截取到第四个位置
        System.out.println(s); //结果为Hel
    }
}

2.6.1.2字符串拼接

与绝大多数的程序设计语言一样， Java 语言允许使用 + 号连接（拼接）两个字符串。

String expletive = " Expletive " ;
String PC 13 = " deleted " ;
String message = expletive + PC 13 ;

上述代码将 “ Expletivedeleted ” 赋给变量 message ( 注意，单词之间没有空格， + 号按照给定的次序将两个字符串拼接起来 )。上述代码将 “ Expletivedeleted ” 赋给变量 message ( 注意，单词之间没有空格， + 号按照给定的次序将两个字符串拼接起来 )。

2.6.1.3不可变字符串

String 类没有提供用于修改字符串的方法 6 如果希望将 greeting 的内容修改为 “ Help ! ” ，不能直接地将 greeting 的最后两个位置的字符修改为‘p ’ 和‘！、
这对于 C 程序员来说，将会感到无从下手。如何修改这个字符串呢？在 Java 中实现这项操作非常容易。首先提取需要的字符，然后再拼接上替换的字符串：

greeting = greeting . substring ( 0 , 3 ) + " p ! " ;
上面这条语句将 greeting 当前值修改为 “ Help ! ” 。

由于不能修改 Java 字符串中的字符，所以在 Java 文档中将 String 类对象称为不可变字符串，如同数字 3 永远是数字 3 — 样，字符串 “ Hello ” 永远包含字符 H 、 e、 1 、 1 和o 的代码单元序列，而不能修改其中的任何一个字符。当然，可以修改字符串变量 greeting，让它引用另外一个字符串，这就如同可以将存放 3 的数值变量改成存放 4 一样。

2.6.1.4判断字符串是否相等

可以使用 equals 方法检测两个字符串是否相等。对于表达式：s . equal s ( t )如果字符串 s 与字符串 t 相等，则返回 true ; 否则，返回 false。需要注意， s 与 t可以是字符串变量，也可以是字符串字面量。例如，下列表达式是合法的：

" Hello " . equals ( greeting )

要想检测两个字符串是否相等，而不区分大小写，可以使用 equalsIgnoreCase方法。

" Hello " . equalsIgnoreCase ( " hel1o " )

public class Demo1 {
    public static void main(String[] args) {
        String greeting = "Hello123455" ;
        String greeting2 = "hello123455";
        System.out.println(greeting.equals(greeting2));
        System.out.println(greeting.equalsIgnoreCase(greeting2));
    }
}

在这里插入图片描述

一定不要使用 == 运算符检测两个字符串是否相等！

2.6.1.5空串与 Null 串

空串 " " 是长度为 0 的字符串。可以调用以下代码检查一个字符串是否为空：空串是一个 Java 对象，有自己的串长度（ 0 ) 和内容（空）。

不过， String变量还可以存放一个特殊的值，名为 null , 这表示目前没有任何对象与该变量关联（要检查一个字符串是否为 null , 要使用以下条件：
if ( str = = null )
有时要检查一个字符串既不是 null 也不为空串，这种情况下就需要使用以下条件：
```
if ( str ! = null & & str . lengthO ! = 0 )
```

2.7输入输出

2.7.1读取输入

打印输出到 “标准输出流 ” （即控制台窗口）是一件非常容易的事情，只要调用 System . out . println 即可。

然而，读取 “标准输人流 ” System . in 就没有那么简单了。要想通过控制台进行输人，首先需要构造一个Scanner 对象，并与 “标准输人流 ” System . in 关联。

public class Demo1 {
    public static void main(String[] args) {
        System.out.println("请输入：");
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        System.out.println(s); //输出 输入的全部内容
        System.out.println("请输入2：");
        String next = in.next();
        System.out.println(next); //以空格前面的内容输出
    }
}

在这里，使用 nextLine 方法是因为在输人行中有可能包含空格。

要想读取一个单词（以空白符作为分隔符 )，就调用：

  String next = in.next();

在这里插入图片描述

2.7.2格式化输出

可以使用 SyStem .out . print ( x ) 将数值 x 输出到控制台上。这条命令将以x 对应的数据类型所允许的最大非 0 数字位数打印输出 X 。例如：Java SE 5.0 沿用了

double x = 10000.0 / 3.0 ;
System . out . print ( x ) ;

C语言库函数中的 printf 方法。例如，调用System . out . pri ntfC I . If , x ) ;可以用 8 个字符的宽度和小数点后两个字符的精度打印 x。也就是说，打印输出一个空格和7 个字符，如下所示：

System . out . printf ( " Hello , % s . Next year , you ' ll be SSd " , name , age ) ;

每一个以％字符开始的格式说明符都用相应的参数替换。格式说明符尾部的转换符将指示被格式化的数值类型： f 表示浮点数， s 表示字符串， d 表示十进制整数。表 3 - 5 列出了所有转换符。

在这里插入图片描述

现在，已经了解了 printf 方法的所有特性。图 3 - 6 给出了格式说明符的语法图。

在这里插入图片描述

2.8控制流程

2.8.1块作用域

块（即复合语句）是指由一对大括号括起来的若干条简单的 Java 语句。块确定了变量的作用域。一个块可以嵌套在另一个块中。下面就是在main 方法块中嵌套另一个语句块的示例。

public static void main ( String 口 args )
{
int n ;
...
{
int k ;
...
} / / k is only defined up to here
}

但是， 不能在嵌套的两个块中声明同名的变量 。例如，下面的代码就有错误，而无法通过编译：

public static void main ( String 口 args )
{
int n ;
...
int k ;
int n ; // Error can ' t redefine n in inner block
...
}
}

2.8.2条件语句

在 Java 中，更一般的条件语句格式如下所示（请参看图 3 - 8 ) :

在这里插入图片描述

例如：

if ( yourSales > = target )
{
performance = " Satisfactory " ;
bonus = 100 ;
}
_______________________________________
例如 ：
if ( yourSales > = target )
{
performance = " Satisfactory " ;
bonus = 100 + 0.01 * ( yourSales - target ) ;
}
else
{
performance = " Unsatisfactory " ;
bonus = 0 ;
}
_______________________________________
if ( yourSales> = 2 * target )
{
performance = " Excellent " ;
bonus = 1000 ;
else if ( yourSales > = 1.5 * target )
{
performance = " Fine " ;
bonus = 500 ;
}
else if ( yourSales > = target )
{
performance = " Satisfactory " ;
bonus = 100 ;
}
else
{
System . out . println ( " You ' re fired " ) ;
}

其中 else 部分是可选的。 else子句与最邻近的 if 构成一组。

2.9循环

2.9.1while循环

当条件为 true 时， while 循环执行一条语句（也可以是一个语句块）。一般格式为:while { condition ) statement

在这里插入图片描述

while ( balance < goal )
{
balance + = payment ;
double interest = balance * interestRate / 100 ;
balance + = interest ;
years + + ;
}
System . out . println ( years + " years . " ) ;

2.9.2do while循环

while 循环语句首先检测循环条件。因此，循环体中的代码有可能不被执行 t 如果希望循环体至少执行一次，则应该将检测条件放在最后。使用 do / while 循环语句可以实现这种操作方式。它的语法格式为:do statement while { condition ) ;

do
{
balance + = payment ;
double interest = balance * interestRate / 100 ;
balance + = interest ;
year - H - ;
/ / print current balance
//
ask if ready to retire and get input
}
while ( input . equals ( " N " )) ；

2.9.3for循环

for 循环语句是支持迭代的一种通用结构，利用每次迭代之后更新的计数器或类似的变量来控制迭代次数。如图 3 - 12 所示，下面的程序将数字 1 ~ 10 输出到屏幕上。

for ( int i = 1 ; i < = 10 ; i + + )
System . out . println ( i ) ;

在这里插入图片描述

3.0switch 语句

在处理多个选项时，使用 if / else 结构显得有些笨拙。 Java 有一个与 C / C ++ 完全一样的switch 语句。

switch ( choice )
{
case 1 :
break ;
case 2 :
break ;
case 3 :
break ;
case 4 :
break ;
default :
/ / bad input
break ;
}

switch 语句将从与选项值相匹配的 case 标签处开始执行直到遇到 break 语句，或者执行到switch语句的结束处为止。如果没有相匹配的case 标签，而有 default 子句，就执行这个子句。
在这里插入图片描述

case 标签可以是 ：

类型为 char 、 byte、 short或 int 的常量表达式。
枚举常量。
从 Java SE 7 开始， case 标签还可以是字符串字面量。

3.1数组

数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。例如，如果 a 是一个整型数组， a [ i ] 就是数组中下标为 i 的整数。在声明数组变量时，需要指出数组类型（数据元素类型紧跟 [ ] ) 和数组变量的名字。下面声明了整型数组 a :

int [ ] a ;

不过，这条语句只声明了变量 a ，并没有将 a 初始化为一个真正的数组。应该使用 new 运算符创建数组。

int [ ] a = new int [ 100 ];

可以使用下面两种形式声明数组int [] a ; 或 int a [] ；

int[] a = new int [ 100 ] ;
for ( int i = 0 ; i < 100 ; i + + )
a [ i ] = i ; // fills the array with numbers 0 to 99

这个数组的下标从 0 ~ 99 ( 不是 1 ~ 100 )。一旦创建了数组，就可以给数组元素赋值。

要想获得数组中的元素个数，可以使用 array . length 。例如，

for ( int i = 0 ; i < a . length ; i + + )
System . out . println ( a [ i ] ) ;

一旦创建了数组，就不能再改变它的大小（尽管可以改变每一个数组元素）

3.1.1for each 循环(增强循环)

Java 有一种功能很强的循环结构，可以用来依次处理数组中的每个元素（其他类型的元素集合亦可）而不必为指定下标值而分心。

这种增强的 for 循环的语句格式为：
for ( variable : collection ) statement

定义一个变量用于暂存集合中的每一个元素，并执行相应的语句（当然，也可以是语句块 ) 。collection 这一集合表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象（例如ArrayList ) 。

for ( int element : a )
System . out . println ( element ) :

打印数组 a 的每一个元素，一个元素占一行。
这个循环应该读作 “ 循环 a 中的每一个元素 ” （ for each element in a ) 。

注意：

foreach 循环语句的循环变量将会遍历数组中的每个元素，而不需要使用下标值。
如果需要处理一个集合中的所有元素， for each 循环语句对传统循环语句所进行的改进更是叫人称赞不已。然而，在很多场合下，还是需要使用传统的for 循环 for例如， 如果不希望遍历集合中的每个元素，或者在循环内部需要使用下标值等。

3.1.2数组初始化以及匿名数组

在 Java 中，提供了一种创建数组对象并同时赋予初始值的简化书写形式。下面是一例子：

int [ ] small Primes = { 2 , 3 , 5 , 7 , 11 , 13 } ;

请注意，在使用这种语句时， 不需要调用 new 。

甚至还可以初始化一个匿名的数组：

new intD { 17 , 19 , 23 , 29 , 31 , 37 }

这种表示法将创建一个新数组并利用括号中提供的值进行初始化，数组的大小就是初始值的个数。使用这种语法形式可以在不创建新变量的情况下重新初始化一个数组。例如：

small Primes = new int [ ] { 17 , 19 , 23 , 29 , 31 , 37 } ;

3.1.3数组拷贝

在 Java 中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组 ：

在这里插入图片描述

intQ luckyNumbers = small Primes ;
1 uckyNumbers [ S ] = 12 ; // now small Primes [ 5 ] is also 12

3.1.4命令行参数

前面已经看到多个使用 Java 数组的示例。每一个 Java 应用程序都有一个带 String arg []参数的 main 方法。这个参数表明main 方法将接收一个字符串数组，也就是命令行参数例如，看一看下面这个程序：

public class Message
{
public static void main ( String [ ] args )
{
if ( args . length = 0 11 args [ 0 ] . equals ( " _ h " ) )
System . out . printCHello , " ) ；
else if ( args [ 0 ] . equa 1 s ( " - gM ))
System . out . print ( " Goodbye , " ) ；
/ / print the other command - line arguments
for ( int i = 1 ; i < args . length ; i + + )
System . out . print ( " " + args [ i ] ) ;
System • out . println ( " ! " ) ;
}
}

3.1.5数组排序

要想对数值型数组进行排序，可以使用 Arrays 类中的 sort 方法：

int [] a = new int [ 10000 ] ;
Arrays . sort ( a)

这个方法使用了优化的快速排序算法。快速排序算法对于大多数数据集合来说都是效率比较高的。

在这里插入图片描述

3.1.5数组排序

要想对数值型数组进行排序，可以使用 Arrays 类中的 sort 方法：

int [] a = new int [ 10000 ] ;
Arrays . sort ( a)

这个方法使用了优化的快速排序算法。快速排序算法对于大多数数据集合来说都是效率比较高的。
在这里插入图片描述

3.1.6多维数组

多维数组将使用多个下标访问数组元素，它适用于表示表格或更加复杂的排列形式。这一节的内容可以先跳过，等到需要使用这种存储机制时再返回来学习。

在 Java 中，声明一个二维数组相当简单。例如：

double [ ] [] balances ;

另外，如果知道数组元素，就可以不调用 new，而直接使用简化的书写形式对多维数组进行初始化。例如：

int [ ] [ ] magicSquare =
{
{ 16 , 3 , 2 , 13 } ，
{ 5 , 10 , 11 , 8 } ,
( 9 , 6 , 7 , 12 } ,
{ 4 , 15 , 14 , 1 }
} ；

第2章（Java 的基本程序设计结构）

第2章（Java 的基本程序设计结构）

文章目录

2.1一个简单的 Java 应用程序

2.2注 释

2.3数据类型

2.3.1整型

2.3.2浮点型

2.3.3字符型

2.2.4boolean 类型

2.4变量

2.4.1变量的初始化

2.4.2常量

2.5运算符

2.5.1数学函数与常量

2.5.1.1平方根函数

2.5.1.2幂函数

2.5.2数值类型之间的转换

2.5.3强制类型转换

2.5.4结合赋值和运算符

2.5.5自增与自减运算符

2.5.6括号与运算符的优先级

2.5.7枚举类型

2.6字符串

2.6.1子串

2.6.1.1字符串截取

2.6.1.2字符串拼接

2.6.1.3不可变字符串

2.6.1.4判断字符串是否相等

2.6.1.5空串与 Null 串

2.7输入输出

2.7.1读取输入

2.7.2格式化输出

2.8控制流程

2.8.1块作用域

2.8.2条件语句

2.9循环

2.9.1while循环

2.9.2do while循环

2.9.3for循环

3.0switch 语句

3.1数 组

3.1.1for each 循环(增强循环)

3.1.2数组初始化以及匿名数组

3.1.3数组拷贝

3.1.4命令行参数

3.1.5数组排序

3.1.5数组排序

3.1.6多维数组

第3章（Java面向对象）

2.2注释

3.1数组