在这里，我们将给大家分享关于第一章JAVA的基本程序设计结构的知识，让您更了解第一章java的基本程序设计结构是什么的本质，同时也会涉及到如何更有效地01_Java的基本程序结构设计1、2017710

在这里，我们将给大家分享关于第一章JAVA的基本程序设计结构的知识，让您更了解第一章java的基本程序设计结构是什么的本质，同时也会涉及到如何更有效地01_Java 的基本程序结构设计 1、201771010117马兴德 实验二 Java基本程序设计（1）、201771010142 张燕 Java的基本程序设计结构第二周学习总结、Chapter 3 Java的基本程序设计结构的内容。

• 第一章JAVA的基本程序设计结构（第一章java的基本程序设计结构是什么）
• 01_Java 的基本程序结构设计 1
• 201771010117马兴德 实验二 Java基本程序设计（1）
• 201771010142 张燕 Java的基本程序设计结构第二周学习总结
• Chapter 3 Java的基本程序设计结构

第一章JAVA的基本程序设计结构（第一章java的基本程序设计结构是什么）

1.1 一个简单的JAVA程序

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

1. Java大小写敏感。
2. 关键字class后面紧跟类名。定义类名字必须以字母开头，后面可以跟字母和数字的任意组合。
3. 不能使用java保留字作为类名。
4. 标准的命名规范: 类名是以大写字母开头的名词。如果名词由多个单词组成，采用驼峰命名法。

1.2 注释

在Java中有三种注释:

1. //，其注释内容从 // 开始到本行结束。
2. 需要长篇注释时，可以使用 /* 和 */ 将一段比较长的注释括起来。
3. 使用/** 和 */进行注释可以自动生成文档。

1.3 数据类型

在Java中一共有8种基本类型(primitive type),其中有4种整型、2种浮点类型、一种用于表示Unicode编码的字符单元类型char和一种用于表示真值的boolean类型。

1.3.1 整型

整型用于表示没有小数部分的数值，它允许负数。Java提供了四种整型: | 类型 | 存储需求 | 取值范围 | |:--:|:--:|:--:| | int | 4字节 | -2147483648~2147483647 | | short | 2字节 | -32768~32767 | | long | 8字节 | -9223372036854775808~9223372036854775807 | | byte | 1字节 | -128~127 |

• 长整型数值有一个后缀L或l(如40000000L)。
• 十六进制数值有一个前缀0X或者0x。
• 八进制有一个前缀0。
• 加上前缀0b或者0B就可以写二进制数。
• 可以给数字加下划线，如用1_000_000_000，方便阅读。

1.3.2 浮点类型

浮点类型用于表示有小数部分的数值。在Java中有两种浮点类型：
类型|存储需求|取值范围
:--:|:--:|:--: float|4字节|大约±3.40282347E+38F double|8字节|大约±1.79763913486231570E+308 float类型的数值有一个后缀F或者f。没有后缀F的浮点值默认为double类型，当然，也可以在浮点值后面添加后缀D或者d。

1.3.3 char类型

char类型用于表示字符。char类型的字面量要用单引号括起来。例如：''A''是编码值为65所对应的字符常量。"A"则表示一个包含字符A的字符串。
特殊的转义序列：
转义序列|名称|Unicode值
:--:|:--:|:--: \b|退格|\u0008 \t|制表|\u0009 \n|换行|\u000a
\r|回车|\u000d
"|双引号|\u0022 ''|单引号|\u0027
\\|反斜杠|\u005c 建议在程序中不要使用char类型，除非确实要处理UTF-16代码单元。最好将字符串作为抽象数据类型处理。

1.3.4 boolean类型

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

1.4 变量

在Java中，每个变量都有一个类型(type)。在申明变量时，变量的类型都位于变量名之前。例如：

• double salary;
• int vacationDays;
• long earthPopulation;

变量名必须是一个以字母开头并由字母或数字构成的序列。大小写敏感。不能用Java保留字作为变量名。可以在一行中声明多个变量：
int i,j; //都是数字

1.4.1 变量初始化

声明一个变量之后必须使用赋值语句对变量进行显式初始化。

int vacationDays;
vacationDays = 12;
System.out.println(vacationDays);

也可以将变量的声明和初始化放在同一行中。例如:

int vacationDays = 12;

在Java中可以将数组的声明放在代码中的任何地方。尽量将变量的声明靠近变量第一次使用的地方。例如：

double salary = 65000.0;
System.out.println(salary);
int vacationDays = 12;

1.4.2 常量

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

public clss Constant
{
    public static void main(String[] args)
    {
        final double CM_PER_INCH = 2.54;
        double paperWidth = 8.5;
        double paperHeight = 11;
        System.out.println("Paper size in centermeters:" + paperWidth * CM_PER_INCH + " by "+ paperHeight * CM_PER_INCH);
    }
}

关键字final表示这个变量只能被赋值一次，一旦被赋值，就不能再更改了。习惯上，常量名全部使用大写。
类常量：一个常量可以在一个类的多个方法中使用。可以用关键字static final设置。例如：

public class Constants2
{
    public static final double CM_PER_INCH=2.4;
    public static void main(String[] args)
    {
        double paperWidth = 8.5;
        double paperHeight = 11;
        System.out.println("Paper size in centermeters:" + paperWidth * CM_PER_INCH + " by "+ paperHeight * CM_PER_INCH);

    }
}

注意：类常量定义于main方法的外部，因此在同一个类的其他地方也可以使用这个常量。而且如果一个常量被声明为<u>public</u>，那么其他类的方法也可以使用这个常量。

1.5 运算符

在Java中使用运算符+、-、*、/、表示加、减、乘、除运算。当参与 / 运算的两个操作数都是整数时表示整数除法，否则，表示浮点数除法。整数的求余运算(取模)用%表示，例如15/2 = 7, 15.0/2 = 7.5, 15%2 = 1。

01_Java 的基本程序结构设计 1

3.1 一个简单的 Java 应用程序

public class FirstSimple
{
    public static void main(String[] args)；
    {
        System.out.println("hello world!")
    }
}

　　1.Java 区分大小写

　　2. 关键字 public 称为访问修饰符（access modifier）

　　3. 关键字 class 表明 Java 程序中的全部内容都包含在类中。java 应用程序中的全部内容必须放置在类中。其后面跟着类名。类名建议按照驼峰法来写。

　　4. 源代码的文件名必须和公共类的名字相同，并用.java 结尾。

　　5.System.out.println（）表示使用了 System.out 对象，并调用了他的方法 println。java 的通用语法是 obj.method (para)

　　6. 以 /** 开头，以 */ 结尾的注释可以自动地生成文档。具体方法见第 4 章

3.2 数据类型

public class Main
{
     public static void main(String[] args)  
    {
    double x1 = 0x1.0p-3;
    System.out.print(x);  //0.125 without /n
    System.out.println(2.0-1.1);  // 0.1250.89999999
    int 我=1; // ‘我’可以作为变量，我是Unicode字符，属于java中的“字母”
    if (Character.isJavaIdentifierPart(我)) System.out.println(我);  // 1
    char l = ''我'';
    if (Character.isJavaIdentifierStart(l)) System.out.println(l);  // 我
    }

}

　　1. 在 java 中，整型的范围与运行 java 代码的机器无关。

　　2. 长整型后面有 l 或者 L, 十六进制 0X 或者 0x，八进制前面是个 0，二进制表示 0b 或者 0B

　　3.java 中没有任何无符号形式的 int,long,short 或 byte 类型。

　　4.java 中默认的小数形式是 double，如果是 float 需要在后缀加上 F 或者 f，注因为是二进制表示法， 无法精确表达小数点后以 5 结尾以外的数字。如上例

　　5. 可以使用十六进制表示浮点数值。0.125==0x1.0p-3  , 其中 p 表示以 2 为底的指数

　　6.Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY Double.NaN 分别表示这三个特殊的值。其中 NaN 不是一个数值，所以不能使用 == 检测 Double.NaN，但可以使用 Double.isNaN (x) 方法。

　　7.java 中‘A’是编码值为 65 的字符常量（char），而 "A" 是一个字符串 (String)。

　　8.java 中 boolean 类型有两个值 false 和 true, 整数值和布尔值之间不能相互转换。

　　9. 与 python 不同，java 声明变量后必须显式初始化，另外与 C++ 不能，java 不区别定义和声明。

　　10. 如果想知道那些 Unicode 字符属于 java 中的 “字母”，可以使用 character 类的 isjavaIdentifierStart 和 isjavaIdentifierpart

　　11. 在 java 中使用 final 指示常量。 final double PER=1.2; 关键字 final 表示这个变量只能被赋值一次。在 java 中，经常希望某个变量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final 设置一个类常量。

　　　　注意：类常量的定义位于 main 方法的外部。因此，在同一个类的其他方法中也可以使用这个常量。而且这个常量被声明为 Public，那么其他类的方法也可以使用这个常量。

3.3 运算符

public static strictfp void main(String[] args) {
        double x = 4;
        double y = Math.sqrt(x); // public static double sqrt(double a)
        System.out.println(y);  // 2.0 public static final PrintStream out = null;
        System.out.println(-15%6);  // -3
        int a = Math.floorMod(-15,6);  // like % ,but a little different
        System.out.println("a is " + a);  // a is 3
        System.out.println("π is" + PI);  // here PI = Math.PI
        int b = 123465789;
        float c = b;
        System.out.println("b is " + b + ''\n'' + "c is " + c);  // b is 123456789 c is 1.234567892E8是 10的8次但是多了一个2？
        double d = b +c;
        System.out.println("d is "+ d);  // d is 2.46931584E8
        x = 9.997;
        int nx = (int) x;
        System.out.println("nx="+nx);
        nx+=3.5;
        nx++;
        System.out.println("nx ="+nx);  // 9+3.5 = 9+3=12 nx = (int)(nx +3.5),but nx = nx + 3.5 will error!

1. 对于浮点数的算术运算实现可移植性是十分困难的。默认情况下，虚拟机设计者允许对中间计算结果采用扩展的精度。但是，对于使用 strictfp 关键字标记的方法必须使用严格的浮点计算来生成可再生的结果。
比如 public static strictfp void main (String [] args)

2. 在 Math 类中，包含了各种各样的数学函数。在编写不同类别的程序时，可能需要的函数也不同。其中 Math.sqrt () 方法和 System.out.println () 方法不同。前者属于静态方法。后者处理 System.out 对象。另外 Math 类中还有 pow（x，a）求 x 的 a 次幂的方法，floorMod 对整数求余的方法，效果相当于 %，但对于负数的余数取绝对值了。

3.Java 中使用 Math.PI 和 Math.E 表示 π 和 e 的近似值。

4. 不要再 boolean 类型与任何数值类型之间进行强制类型转换，这样可以防止发生错误。(那么问题来了，如何对 int String boolean 之间转换呢？)

5. 如果运算符得到一个值，其类型与左侧操作数的类型不同，就会发生强制类型转换。例如 int x = 1;x+=3.5;// 1+3.5=4【这个和双目运算符不同！】

6. 自增和自减和 cpp 一样，也有前缀和后缀之分，前缀先加再使用变量；后缀先使用变量再加。Java 中的关系运算和 cpp 中也一样，按照 “短路” 的方式计算的，&& || 分别表示逻辑与和逻辑或，如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了。

   e.g. x != 0 && 1 /x>x+y //no division by 0。如果 x 等于 0，那么第二部分就不会计算。因此，如果 x 为 0，也就不会计算 1/x

7. 与 Cpp 不同，java 的 >>> 会用 0 填充，>> 用符号位填充。

8. 运算符优先级

201771010117马兴德 实验二 Java基本程序设计（1）

实验二 Java基本程序设计（1）

 第一部分    理论知识的学习。

   第三章Java基本程序设计结构

1  基本知识： 

    （1）标识符：标识符由字母、下划线、美元符号和数字组成，且第一个符号不能为数字。比如Hello,$1234都是合法的字符；同时标识符也可用作类名、变量名、方法名、文件名等。

       （2）关键字：关键字就是Java语言中被赋予特定意义的一些单词。比如 class、public、try等，但是关键字不能用作变量名。

       （3）注释：Java有三种注释方法，如：//、/*和*、（定义一个注释块）、/**开始，*/结束。

2   数据类型

       Java语言有8种数据类型：整数类型（int、short、byte）浮点类型（float、double）字符类型（char）布尔类型（Boolean）

3  变量的初始化

在Java中，每一个变量属于一种类型。在声明变量时，变量所属的类型位于变量名之前。 

在Java中，一行可以声明多个变量。逐一声明每一个变量可以提高程序的可读性。

（2）常量的定义

在Java中，使用关键字final来指示常量。习惯上常量名都用大写。

final double CM_PER_INCH=2.54；

l 关键字final表示只能对变量赋一次值，其值一旦设定，便不能改。在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final 声明一个类常量（ classconstants）。public static final double CM_PER_INCH=2.54；

4  运算符

运算符有各种运算符、运算符的优先级与结合性以及数学函数与常量

     各种运算符包括算数运算符、自增自减运算符、关系运算符、逻辑运算符与位运算符。而且各种运算符与面向对象运算相关。

5 类型转换

类型转换又分为隐函式类型转换与强制性类型转换，下面我将用一组图来说明类型转换

在隐函式类型转换下大多数的数值转换时遵循优先级的关系自动完成的，而在强制性类型转换则要强调在转换的过程当中防止数据丢失

6  字符串

(1)  Java字符串是Unicode字符的序列，它是组织字符的基本数据结构，用法类似于字符数组。

 有内置的字符串类型，而是在标准Java类库中提供了一个Java预定义类String。在Java中，字符串被当作对象来处理。

 程序中需要用到的字符串可以分为两大类：
 创建之后不会再做修改和变动的不可变字符串String类；
 创建之后允许再做更改和变化的构建字符串StringBuilder类。

 (2) 在字符串中最重要的一点就是String类，String类又被分为String类的基本操作、构造方法和API及文档

7  输入输出

  分为读取输入、格式化输出和文件输入与输出。

8   控制流程

 Java共有5种语句：Java语句（复合语句、控制语句和impothe packege语句）、条件语句（if、switch）、循环语句(while 、do-while、for)、中断控制流程语句(break、continue)、返回语句(return value)

9  大数值

如果基本的整型和浮点型数据无法达到要求的精度，那么可以使用 java.math 包中的两个类，BigInteger和BigDecimal。这两个类可以操作任意长的数字。

 BigInteger类实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点运算。

10  数组

         数组是一种数据结构，它是有序数据的集合，数组中的每个元素的数据类型都是相同的。

          对元素的确定是由数组名和它的下标实现的，如：

                                                                             a[0]代表数组a的第一个元素，a[1]代表数组a的第二个元素，依次类推

第二部分    实验部分

1、实验目的与要求

（1）进一步熟悉命令行和IDE两种方式下java程序开发的基本步骤；

（2）掌握Eclipse集成开发环境下导入Java源程序的过程；

（3）掌握Java语言构造基本程序的数据类型、变量、运算符、各类表达式、输入输出、流程控制的基本语法；

（4）掌握String类、StringBuilder类、数组类的用法。

2、实验内容和步骤

实验1：编写java 应用程序，输出以下4个表达式的值。

在Eclipse上编写下列程序的代码，输出结果如下图所示：

实验2：编写包含以下代码片段的java应用程序，输出字符串类对象s3的值。

输出的结果如下图所示：

实验3：更改实验2中s1、s2、s3为StringBuilder类对象，观察程序运行结果并与实验2结果进行对比，理解String类对象与StringBuilder类对象的区别。

 实验结果如下图所示：

实验4：在命令行方式下调试运行下列程序，理解java应用程序命令行参数的用法。

实验结果如下图所示

：

实验5：Eclipse环境下导入第3章示例程序InputTest.java步骤：

（1） 新建java project如下图：

（2） 选择File->import->File ystem->Next，打开文件导入窗口如下图，点击上方Browse选择导入源程序并选中，点击下方Browse选择源程序导入位置为新项目InputTest/src位置后，点击finish完成导入。

（3） 打开InputTest项目src文件夹的缺省包，双击InputTest.java在IDE源程序编辑区打开文件。

（4） 右键单击InputTest.java文件名打开快捷菜单，选择Run as->java application运行此程序，结合程序运行结果，理解代码中Scanner类对象用法，掌握java控制台输入方法。

 按照如上操作之后，输出的结果如下图所示：

实验6：按照实验5的操作步骤，导入WriteReadFileTest.java示例程序，结合程序运行结果理解程序代码,观察项目文件夹下文件myfile.txt的内容，掌握文件的输入输出操作。

下面是该实验的代码以及实验所得的结果：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.Arrays;

public class WriteReadFileTest {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {

        //写入文件演示
        PrintWriter out = new PrintWriter("myfile.txt");
        out.println("姓名 高数 Java 数据结构 平均成绩 总成绩");
        out.println("张三 20 30 40 0 0");
        out.println("李四 50 60 70 0 0");
        out.close();//切记，输出完毕，需要close
        
        
        //读入文件演示
        Scanner in = new Scanner(new File("myfile.txt"));//为myfile.txt这个File创建一个扫描器in
        int number = 1;//行号
        while(in.hasNextLine()){//判断扫描器是否还有下一行未读取，该循环把文件的每一行都读出
            String line = in.nextLine();//读出myfile.txt的下一行
            System.out.println("第"+(number++)+"行的内容" +"="+line);
            
            Scanner linescanner = new Scanner(line);//对每一行的内容建立一个扫描器
            linescanner.useDelimiter(" ");//使用空格作为分隔符
            String name = linescanner.next();
            String math = linescanner.next();
            String java = linescanner.next();
            String ds = linescanner.next();
            String avg = linescanner.next();
            String total = linescanner.next();
            System.out.println("name="+name+" math="+math+" java="+java+" ds="+ds+" avg"+avg+" total="+total);
        }
        in.close();//读入完毕，最后需要对其进行close。    

 }
}

实验7：按照实验5的操作步骤，导入第3章示例程序，每个示例程序从语法、算法两个角度总结学习内容。

（1）测试Retirement.java，Retirement2.java，LotteryOdds.java掌握循环控制结构；

Retirement.java:

Retirement2.java:

LotteryOdds.java:

（2）测试BigIntegerTest.java，掌握大数值类的用法；

（3）测试LotteryDrawing.java，掌握数组的用法；

（4）测试CompoundInterest.java，掌握多维数组的用法；

（5）测试LotteryArray.java，掌握不规则数组的用法。

实验总结：

      通过本周的学习有关Java语言的标识符、关键字、注释的基本知识。有了这些基本知识做铺垫，我就能够更好的去学习一些数据类型、变量、运算符、字符串、输入输出等的一些相关知识。尤其在学习字符串这一内容的时候，老师不但给我们复习了和C语言中相关的知识，而且还给我们介绍了一些与C语言不同之处，虽然在上课听得时候有点模糊，但在下午的一节实验课上老师有给我们讲了一些其他方面的知识；而且还学习了Java语言的控制流程、大数值和数组的一些基本知识，并在实验中能够再一次的加深我的记忆。

      在实验中同时也了解到了IDE在两种方式下Java程序开发的基本步骤；掌握了Eclipse集成开发环境下导入Java源程序的过程，再次过程中有老师助教同学的帮助，是我对这一部分内容学的相对比较轻松。最后我也在字符串当中了解到String类更深层次的知识,学习了有关 String类的构造方法、基本操作及文档以及在程序运行过程当中学习的StringBuilder类的一些基本方法。

201771010142 张燕 Java的基本程序设计结构第二周学习总结

                                                                                               第三章 Java的基本程序设计结构

第一部分 理论知识学习部分

一 基本知识：

1.标识符：由字母.下划线，美元符号和数字组成，第一个符号不能为数字，可以用作类名.变量名.方法名.数组名和文件名等。

2.关键字：Java语言中已经被赋予特定意义的一些单词，关键字不能作为变量名。

3.注释：①//②/*和/*③/**开始，*/结束

二 数据类型：

Chapter 3 Java的基本程序设计结构

1、源代码的文件名必须与公共类（public）的类名一致，而且一个源代码文件中最多只能有一个公共类（public）

2、注释： 3种

• 行注释  以双斜线  //  开始

• 段落注释  /*  注释内容  */     

• 文档注释  /**  注释内容 */

3、数据类型  8种基本类型

• 整型 4 种 ：  byte（1byte）、 short（2 bytes）、 int （4 bytes）、 long（8 bytes）     均为signed(有符号型)

• 浮点型 2 种：float（4 bytes）、double（8 bytes）     前者有效位6~7位，后者15位

• char类型 ：  char（2 bytes） 

• boolean（1 byte） 只有true和false两种取值，且不能与整型进行转换

     **在java编译器中default的整型数据为int类型，所以在给byte、short类型数据赋值时需要进行强制类型转换

     **long（长整型）数值有一个后缀L，十六进制前缀0x，八进制前缀0，二进制前缀0b

     **float后缀F，double后缀D（F、D大小写均可）

     **POSITIVE_INFINITY、NEGTIVE_INFINITY、NAN分别表示正无穷、负无穷和不是一个数字

4、逻辑运算符

• && 按照"短路"方式求值 ， eg : expression1 && expression2 , 若expression1为false，则不用计算expression2

• ||    按照"短路"方式求值 ， eg : expression1 || expression2 , 若expression1为true，则不用计算expression2

• ！   表示逻辑“非”

位运算符

• &  |   ^  ~   与、或、异或、非   **&  |  不按短路方式计算

• >>   <<   右移  左移

• >>>   也是右移的意思，与>>的区别在于>>是用符号位填充高位，而>>>是用0填充高位

     ***无<<<运算符

5、枚举类型

     用 enum 自定义枚举类型  eg: enum Size { SMALL , MEDIUM , LARGE , EXTRA_LARGE} ;

                                                  Size size = Size.SMALL ; 表示size只能是上述4种尺码中的一种

6、String

     java没有内置的字符串类型，而是在标准的类库中提供了一个预定义类，String类为不可变字符串

• 空串与null串的区别

空串“”是长度为0的字符串，是一个java对象，有自己的长度（0）和内容（空）

null串：表示目前没有任何对象与该变量关联

• JDK5.0引入了StringBuilder类，其前身是StringBuffer,其效率稍有些低，但允许采用多线程的方式添加和删除字符操作。

7、从控制台读取数据

• Scanner类   Scanner sc = new Scanner(System.in) ;

                            String  s1 = sc.nextLine() ;   //读入一行

                            String s2 = sc.next() ;          //读入一个单词，以空格区分

                            int i = sc.nextInt() ;               //读入一个int类型整数

• Console类   用于读取密码，因为Scanner不适合读取密码，所以专门采用Console类

                              Console c = new Console(System.in) ;

                                String ss = c.readLine() ;                    //读入一行

                                char[]  passwd = c.readPassword() ;   //读入密码

从控制台输出( 3种格式 )

• System.out.print("") ;

• System.out.println("") ;

• System.out.printf("%d,%s", age,name) ;

8、控制流程

• 不能在嵌套的两个语句块中申明同名的变量，但是可以在两个并行（平等）的语句块中申明同名的变量

• 选择语句  switch…case、if…else

• 循环语句  while  、 do…while 、 for

• 中断控制流程语句 ： 加标签label ,然后 break  label ；可以跳出循环到 label 标示的位置

9、大数值：如果基本的整数和浮点数的精度都无法满足要求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。BigInteger实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点数运算。

     **遗憾的是不能使用我们熟悉的算术运算符（+、-、/、*、%等），而是需要用到BigInteger、BigDecimal 的add、multiply、subtract、divide、mod （BigDecimal 无此方法）运算。

     eg：BigInteger a = BigInteger.valueOf(1000) ;

              BigInteger b = BigInteger.valueOf(34567) ;

              BigInteger c = a.add(b) ;

              BigInteger d = a.multiply(c) ;

10、数组   **数组长度为0 和为null不同

• 申明方法  2种   int[] a ;      int a[]  ;

• String[] s = new String[10] ; 会创建一个包含10个字符串的数组，所有字符串都为null 。  **一旦创建了数组，就不能再改变其大小，但是可以改变各个元素的内容。

•  匿名数组  new int[]  {2,14,35,47,57} ;

• 可以用Arrays的静态方法sort()对数值型数组进行排序（优化的快速排序算法）

我们今天的关于第一章JAVA的基本程序设计结构和第一章java的基本程序设计结构是什么的分享就到这里，谢谢您的阅读，如果想了解更多关于01_Java 的基本程序结构设计 1、201771010117马兴德 实验二 Java基本程序设计（1）、201771010142 张燕 Java的基本程序设计结构第二周学习总结、Chapter 3 Java的基本程序设计结构的相关信息，可以在本站进行搜索。