第二章 Java程序设计-编程基础2_1.5e-2转换成整数

2.1 Java的基本语法

 

 

 

2.1.1 Java程序的基本格式

（1)Java程序代码必须放在一个“类”中，类使用class关键字定义，在class前面可以有修饰类的修饰符。类的定义格式如下：

修饰符 class 类名 {

        程序代码

}

/class前的修饰符大多是用 public

(2)Java的运行必须要有main方法，main方法是程序运行的入口。

main方法的定义格式如下：

 

修饰符 class 类名 {

        public static void main(String[] args){

            main方法的方法体：功能执行语句

}

}

/public公共的    static 表示静态的    void 不返回main方法的返回值     main main方法的名字

括号里是main方法的参数

（3）Java程序代码可分为结构定义语句和功能执行语句。结构定义语句用来说明一个类或者方法；功能执行语句用来实现具体的功能。每条功能执行语句的最后都需要用分号;作为结束。例如下面的语句：

System.out.println("这是我的第一个Java程序！");

/编写代码时输入法的状态需是英文状态下

（4）在编写代码时，为方便阅读提高代码的可读性，可以在连个单词或者符号之间插入 空格、制表符、回车符等任意的空白字符。

 

2.1.2 Java程序中的注释

1.单行注释

单行注释用于对程序的某一行代码进行注释，一般用于局部注释。

格式：//+被注释的内容

int c = 10; //定义一个整数型变量

2.多行注释

多行注释用于多行代码的注释。

格式：/*被注释的内容*/

/*int a = 1 ;
    int b = 2 ; */

3.文档注释

文档注释是以 /** 开头，并在注释内容以 */ 作为结束。文档注释是对一段代码的概括性解释说明，可以使用javadoc命令（命令提示符窗口）将文档命令提取出来生成帮助文档。

下图示例打开HelloWorld

 进入DOS窗口，并执行javadoc命令：

 此时放置编写的程序的目录会出现许多新的文件：

 找到index.html文件并双击打开：

 

2.1.3 Java中的标识符

1.概念：在程序用于标识名称的符号。

（例如：包名、类名、方法名、参数名、变量名等)

2.规则：由字母、数字、下划线（_）、和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的关键字。（标识符区分大小写）

/合法的标识符：username、uesrname123、user_name、userName、$uname

/不合法的标识符：19.9（开头位数字且有小数点）、2user（开头为数字）、class（是Java的标识符）、H W（有空格）

为了增强代码的可读性，建议初学者遵循一下规则：

1）包名所有字母一律小写。

（例如：cn.baidu.text     层级之间用 . 来间隔 cn文件夹下的baidu文件夹，baidu文件夹下的text文件夹）

2）类名和接口名每个单词的首字母都要大写。

（例如：ArrayList、Iterator）

（接口：主要作用是可以帮助实现类似于类的多重继承的功能）

3）常量名所有单词都大写，单词之间用下划线连接。

（例如：DAY_OF_MONTH）

4）变量名和方法名的第一个单词的首字母小写，从第二个单词开始每个单词首字母大写。

（例如：lineNember、getLineNember、main）

5)尽量使用有意义的英文单词定义标识符，使程序便于阅读。

（例如：userName定义用户名、passWord定义密码）

/可参考：阿里巴巴Java开发手册

 

2.1.4 Java中的关键字

1.概念：在Java语言中事先定义的，有特别意义的标识符，有时候也叫保留字。

2.关键字：

1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。

3）3个特殊直接量：true、false、null。

3.编写Java程序时，需要注意以下几点：

1）所有的关键字都是小写的。

2）不能使用关键字命名标识符。

3）goto和const是保留字关键字，虽然目前在Java中还没有任何意义，但在程序中不能用来作为自定义的标识符。

4）true、false、null虽然不属于关键字，但它们具有特殊的意义，也不能作为标识符来使用。

 

2.2常量、变量的定义与使用

2.2.1 Java中的常量

1.概念：常量就是在程序中固定不变的值，是不能改变的数据。

（例如：数字1、字符串'a'「字符串要用英文状态的单引号括起来」、浮点数3.2）

常量包括整型常量、浮点数常量、布尔常量（判断真假 F和T）、字符常量、字符串常量等。

2.分类：

(1)整数常量

• 二进制：由数字0和1组成的数字序列，前面要以0b或者0B开头，目的是为了和十进制区分开来。（例如：0b11010101、0B010101110）
• 八进制：以0开头，并且其后由数字0~7范围内(包括0和7）的整数序列组成。（例如：0273）
• 十进制：由数字0~9范围内（包括0和9）的整数序列组成。（例如：123）
• 十六进制：以0x或0X开头，其后由0~9、A~F（包括0、9、A、F 字母不区分大小写）组成的数字序列。（例如：0x24CD）

（2）浮点数常量

• 单精度浮点数（float）：结尾以F或f结尾。
• 双精度浮点数（double）：结尾以E或e结尾。

在使用浮点数时，也可以不加任何后缀，此时JVM会将其默认为双精度double类型的浮点数。

浮点数常量还可以通过指数形式表示。(例如：1.88E-3等同于1.88的10的-3次方）

（3）字符常量

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（''）括起来。

字符常量可以是英文字母、数字、标点符号、以及由转义数列表示的特殊符号。（\n换行等）

 （4）字符串常量

用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）括起来。

（例如："HelloWorld"、"123"、"  "空字符串）

（5）布尔常量

即布尔型的值，用于区分事物的真假，布尔常量由true和false两个值。

（6）null常量

null常量只有一个值，即null，表示引用的对象为空。（与"  "不同，"  "表示一个空字符串）

 

2.2.2 Java中的变量

1.定义

在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在内存单元中，每个内存单元都用一个标识符标识，这些用于标识内存单元的标识符就称之为“变量”，内存单元中存储的数据就是变量的值。

（概括的讲就是：在程序运行期间可能会发生变化的量）

定义：

（1）数据类型 变量名称 = 数据值 ; //声明变量的同时进行初始化

   例如：int a = 1 ；

（2）数据类型 变量名称 ; //声明变量

         变量名称 = 变量值 ; //初始化变量

例如：int a ;

           a = 1 ;

 2.变量的数据类型

定义变量的语法：数据类型 变量名称 = 数据值；

Java中所有数据类型如下

3.变量的数据类型

• 整数类型变量

        整数类型变量用来存储整数数值，即没有小数部分的值。

        整数类型分为4种不同的类型，分别是字节型（byte）、短整型（short）、整型（int）和长整 型（long）。

/ 在为一个long类型的变量赋值时，所赋值的后面要加上字母L（或小写l），说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母L（或小写l）。

• 浮点数类型变量

        浮点数类型变量用于存储小数数值。double类型所表示的浮点数比float类型更精确。

/在Java中，小数会被默认为double类型的值。因此在为一个float类型的变量赋值时，在所赋值的后面一定要加上字母F（或者小写f）。而为double类型的变量赋值时，可以在所赋值的后面加上字母D（或小写d），也可以不加。

•  字符类型变量

       在Java中，字符类型变量用char表示，用于存储一个单一字符。

        /Java中每个char类型的字符变量都会占用2个字节。在给char类型的变量赋值时，需要用一对英文半角格式的单引号（' '）把字符括起来。（例如：'a'）

• 布尔类型的变量

        在Java中，使用boolean定义布尔类型变量，布尔类型变量只有true和false两个值。例如：

        

boolean flag = false;  // 定义一个boolean类型的变量flag，初始值为false 
 
 flag = true;    // 改变变量flag的值为true

4.变量的类型转换

容量大小（此大小依据谁能包含谁）：

①byte<short<int<long<float<double；

②          char<int<long<float<double

•  自动类型转换

自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明，由编译器自动完成。

自动类型转换必须同时满足两个条件：第一是两种数据类型彼此兼容，第二是目标类型的取值范围大于源类型的取值范围。

例如：

byte b = 3;
int x = b;  
/*上面的代码中，使用byte类型的变量b为int类型的变量x赋值，
  由于int类型的取值范围大于byte类型的取值范围，编译器在赋值过程中不会造成数据丢失，
  所以编译器能够自动完成这种转换，在编译时不报告任何错误。*/

•  强制类型转换

强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。

当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

例如：

public class text01 {
	public static void main(String[] args) {
		int num = 4;
		byte b = num;
		System.out.println(b);
	}
}

以上代码，程序机会报错。原因是：数据类型不兼容，不能将int类型转换成byte类型。

解决办法：进行强制类型转换，即强制将int类型的值赋值给byte类型的变量。

强制类型转换格式：目标类型  变量 = （目标类型）值

public class text01 {
	public static void main(String[] args) {
		int num = 4;
		byte b = (byte) num;
		System.out.println(b);
	}
}

/注意代码的第4段

/在对变量进行强制类型转换时，如果将取值范围较大的数据类型强制转换为取值范围较小的数据，极容易造成数据精度的丢失。（例如：将一个int类型的数转为byte类型）

例如：

public class Example02 {
	public static void main(String[] args) {
		byte a;                // 定义byte类型的变量a
		int b = 298;          // 定义int类型的变量b
		a = (byte) b;
		System.out.println("b=" + b);
		System.out.println("a=" + a);
	}
}

运行结果如下：

从运行结果可知变量b本身的值为298，但再赋值给变量a后，a的值为42。

原因：变量b为int类型，在内存中占用4个字节；byte类型的数据在内存中占用1个字节，当将变量b的类型强转为byte类型后，前面3个高位字节的数据丢失，数值就会发生变化。

 

总结：

小容量向大容量转换为自动（隐式）类型转换。

大容量向小容量转换为强制（显式）类型转换。

注意：byte和char ，short和char都不会存在隐式转换，相互之间只能进行强制类型转换。

 5.Java的作用域

定义：变量一定会被定义在某一对大括号中（李变量最近的那对大括号），该大括号所包含的代码区域便是这个变量的作用域。

例1:

 例2:

出错的原因：原变量y在作用域范围之外被使用（y=x;)

 

 

///以下作为分享及拓展///

十进制转二进制：

十进制转换成二进制就是一个除以2取余数的过程。把要转换的数，除以2，得到商和余数，将商继续除以2，直到商为0。最后将所有余数倒序排列，得到的数就是转换结果。

习题：

1.Java程序代码可分为结构定义语句和功能执行语句，其中，  结构定义语句 用于声明一个类或方法，功能执行语句           用于实现具体的功能。

2.标识符可以由 字母   、 数字   、 下划线  和  美元符号    组成，但标识符不能以  数字  开头，且不能是Java中的  关键字     。

3.单精度浮点数后面以  F或f  结尾，而双精度浮点数则以 D  或 d 结尾。如果在浮点数的末尾不加任何的后缀，则JVM默认浮点数的类型为   double   类型。

4.布尔常量即布尔型的值，用于区分事物的真与假。布尔常量有 true  和 false   两个值。

5.Java中的基本数据类型分为  整数类型 ， 浮点类型 ，  字符型   和   布尔型    。

6.整数类型中包含4种不同的类型，分别是： 字节型 byte    、 短整型 short   、 整型 int   、 长整型 long

7.在为一个long类型的变量赋值时，所赋值的后面要加上字母 L 或 l 

8.浮点数类型分为单精度浮点数和双精度浮点数两种，单精度浮点数的数据类型名是 float ，双精度浮点数的数据类型名是 double .

9.在计算机中1.5E-2，等价于  1.5*10^-2 

10.变量的类型转换方式有  自动类型转换  和  强制类型转换  两种。

11.在对变量进行强制类型转换时，如果将取值范围较大的数据类型强制转换为取值范围较小的数据，如将一个int类型的数转为byte类型，极容易造成 数据精度的丢失 。

User,name   （  非合法 ）

3Q            （  非合法 ）

_username   （  合法 ）

User_name     （  合法 ）

public    （  非合法 ）

pass$123    （  合法 ）

long num = 2200000000L;   （  正确 ） 

char c = ‘\r’;      （  正确 ） 

float f = 100.1;  （  错误 ） 

char c = 100; （  正确 ） 

float f = 100;   （  正确 ） 

int nu

 

2.3Java中的运算符

1.概念：在程序中经常出现一些特殊的符号，如 +、—、*、=、> 等，这些特殊的符号就叫做运算符。

2.作用：运算符用于对数据进行算数运算、赋值运算和比较运算等。

3.分类：算数运算符、赋值运算符、比较运算符、逻辑运算符和三元运算符等。

 

2.3.1算术运算符

用来处理四则运算的符号（加减乘除）的符号，算术运算符是最简单最常用的运算符。

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4;-b;	-4
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模（即算术中的求余数）	7%5	2
++	自增（前）	a=2;b=++a;	a=3;b=3;
++	自增（后）	a=2;b=a++;	a=3;b=2;
--	自减（前）	a=2;b=--a	a=1;b=1;
--	自减（后）	a=2;b=a--	a=1;b=2;

需注意的点：

1）除法 /  

System.out.println(10 / 5);
/*
    此代码的结果为2
*/

System.out.println(10 / 3);
/*
    此代码结果为3
        两个整数相除，结果也为整数
*/

10/3的结果应为3.3333333，那我们如何得到这种结果呢？应如下图所示：

System.out.println(10 / 3.0);
System.out.println(10.0 / 3);
/*
    这两种的输出结果均为3.3333333
        若想让除法输出小数，只需将任意一个数字写成小数形式
*/

2）取模 %

System.out.println(7 % 3);
/*
    此代码的结果为1   
        7除以3等于3余1，取余数，取1
*/

在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。例如，(-5)%3=-2，而5%(-3)=2

/当有负数进行取余%的运算时，结果的符号与被除数一致

例如：

10 % 3 = 1       10 % -3 = 1    -10 % 3 = -1    -10 % -3 = -1

3）自增（前）++a

int a = 2 , b ;
b = ++a ;
/*
    上述代码最终会输出：
            a = 3
            b = 3
    式子中的b = ++a ;等同于下列两个式子
        a = a + 1;
        b = a ;
*/

自增（后）a++

int a = 2 , b ;
b = a++ ;
/*
    上述代码最终会输出：
            a = 3
            b = 2
    式子中的b = a++ ;等同于下列两个式子
        b = a ;
        a = a + 1;
*/

自增、自减的运算规则如下：

在进行自增（++）和自减（--）运算时，如果运算符++或--放在操作数的前面，则先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面，则先进行其他运算再进行自增或自减运算。

 

<当数字与字符串联用时>

System.out.println("5 + 5 + hello");

上述结果为：10hello

加法运算符是从左到右进行运算，加法与字符串进行运算是一种“拼接”的效果。

System.out.println("hello + 5 + 5");

上述结果：hello55

首先会进行 hello +5 的运算，结果为 hello5 ，然后进行 hello5 + 5 的运算，所以最后的输出为 hello55

2.3.2 赋值运算符

1. 作用：将常量、变量或表达式的值赋给某一个变量。

 

2. 赋值方式：

(1)
int a ,b ,c ;
a = b = c = 5;

(2)
int a , b ;
a = 8;
b = 8;

(3)
int a = 6 , b = 8;

但不能出现以下写法

（错误）
int a = b = c =5

表格中，除了“=”，其他的都是特殊的赋值运算符。

///以“+=”为例，x += 3就相当于x = x + 3，表达式首先会进行加法运算x+3，再将运算结果赋值给变量x。

-=、*=、/=、%=赋值运算符都可以此类推。

3.强制类型转换

在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，需要进行强制类型转换。

//例如，将一个int类型的值赋给一个short类型的变量，需要进行强制类型转换。然而在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

//强制类型转换
public class text{
    public static void main (String[] args){
        short a = 3;
        int b = 5 ;
        a = b ; //把b赋值给a，但此处会报错，因为a的类型shot,比b的类型int所表达的范围小
        /*
          解决方法应如下：
            a = (short)b;
        */
        System.out.println("a = "+a);
 
}
 
}

//强制转换自动完成
public class text{
    public static void main(String[] args){
        short a = 1 ;
        int b = 10 ;
        a += b ;
            /*
            此时不会报错，因为运算符为复合运算符，两个变量相加后，数值会自动提升成大范围的数值类型                            
            此处是int类型
               此处的 a += b ;
               等价于：
                a = (short)(a + b) ;
            */
        System.out.println(a)   
}
 
}

2.3.3 比较运算符

1.作用：用于对两个数值或变量进行比较，比较运算结果是一个布尔值，即true或false。

 

 

2.3.4逻辑运算符

1.作用：用于对布尔型的数据进行操作，其结果仍是一个布尔值。

运算符	运算	范例	结果
&	与	true & true	true
		true & false	false
		false & false	false
		false & true	false
|	或	true | true	true
		true | false	true
		false| false	False
		false| true	true
!	非	!true	false
		!false	true
^	异或	true ^ true	false
		true ^ false	true
		false ^ false	false
		false ^ true	true
&&	短路与	true && true	true
		true && false	false
		false && false	false
		false && true	false
||	短路或	true || true	true
		true || false	true
		false|| false	false
		false|| true	true

（1） & 与

同真则真，有假则假。

 （2） | 或

同假则假，有真则真。

 

（3） ！ 非

非真即假，非假即真。

在对整体取反时，需对整体加小括号。

 （4） ^ 异或

相同为真，不同为假。

 

（5） && 短路与

运算符“&”和“&&”都表示与操作。

当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。

区别：在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。在使用“&&”进行运算，当左边为false时，右边的表达式就不再进行运算，因此“&&”被称作短路与。

 （4）||  短路或

运算符“|”和“||”都表示或操作，当运算符两边的任一表达式值为true时，其结果为true。

只有两边表达式的值都为false时，其结果才为false。

同逻辑与操作类似，“||”运算符为短路或，当运算符“||”的左边为true时，右边的表达式不再进行运算。

 

2.3.5 三元运算符

语法：<表达式1> ？<表达式2> : <表达式3> 
先计算<表达式1>的值，
当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；
当<表达式1>的值为false时，则将<表达式3>的值作为整个表达式的值。

 

2.3.6 运算符优先级

在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，通常把这种顺序称作运算符的优先级。

///Java输入数字的方法/

public class Demo
    public static void main(String[] args){
        //简单的文本扫描器
        Scanner sc = new Scanner (System.in);
        System.out.println("请输入一个三位数： ");
        int num = sc.nexInt();  //堵塞式
        System.out.println("您输入的数字是： ");
        System.out.println(num);
    }
}

 

2.4 流程控制语句

1.概念：用来控制程序中各语句执行顺序的语句。

2.作用：可以把语句组合成能完成一定功能的小逻辑模块。

3.分类：顺序结构（理解：先.....再.....）、选择结构（如果.....就......）、循环结构（如果....就继续.......）

2.4.1 顺序结构语句

 

2.4.2 选择结构语句

1，概念理解：Java需要对一些条件做出判断，从而决定执行哪一段代码。

2，分类：if条件语句和switch条件语句。

if条件语句

if语句    （单分支）

 

if语句的格式：
 
    if (条件语句){
 
           代码块
 
    }

例如：

 if..else     （双分支）

1.理解：如果满足某种条件，就进行某种处理，否则就进行另一种处理。

语法格式如下：
if (判断条件){
	执行语句1
	...
}else{
	执行语句2
	...
}

例如：

 

if…else if…else    （多分支）

1.用于：用于对多个条件进行判断，进行多种不同的处理

语句格式：
if (判断条件1) {
	执行语句1
} 
else if (判断条件2) {
	执行语句2
}
...
else if (判断条件n) {
	执行语句n
}
else {
	执行语句n+1
}

例如：

 switch条件语句    （多分支）

1.表达式中的取值：byte、short、char、int、enum枚举（JDK5 之后新增的特性）、String（JDK7 之后新增的特性）

2.理解：switch 条件语句也是一种很常用的选择语句，和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定程序执行哪一段代码

switch (表达式){
	case 目标值1:
		执行语句1
		break;
	case 目标值2:
		执行语句2
		break;
	．．．．．．
	case 目标值n:
		执行语句n
		break;
	default:
		执行语句n+1
		break;     
 }

//break的作用是跳出switch语句

例如：

 //在使用switch语句时，如果多个case条件后面的执行语句是一样的，则执行语句只需书写一次即可。

例如：

 

2.4.3 循环结构语句

while循环语句

while循环

1.特点：while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环结束。

语法结构如下：
while(循环条件){
    执行语句（循环体）
    ...
}

                                          

例如：

 do while 循环

1.特点：关键字do后面{}中的执行语句是循环体。do…while循环语句将循环条件放在了循环体的后面。

//区别：

do while 在循环时，至少会执行一次。（即使不符合条件也会有一个输出）。 但 while 在不符合循环条件时，不会有输出结果。

 

                                                  

例如：

 for循环

for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。

语法格式如下：
 
for（初始化表达式; 循环条件; 操作表达式）
 
{
 
  执行语句
 
  ...
 
}

①表示初始化表达式，②表示循环条件， ③表示操作表达式， ④表示循环体，通过序号分析for循环的执行流程。

for（① ; ② ; ③）{

  ④

}

例如：

 上述代码的运行过程可用表格分析：

 

循环嵌套

1.定义：循环嵌套是指在一个循环语句的循环体中再定义一个循环语句的语法结构。

//while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，其中最常见的是在for循环中嵌套for循环

语法格式：
for(初始化表达式; 循环条件; 操作表达式) {
	...
	for(初始化表达式; 循环条件; 操作表达式) {
		执行语句
		...
	}
	...
}

例如：

 

//下面分步骤讲解循环过程，具体如下：

第一步，第3行代码定义了两个循环变量i和j，其中i为外层循环变量，j为内层循环变量。

第二步，第4行代码将i初始化为1，判断条件为i <= 9为true，首次进入外层循环的循环体。

第三步，第5行代码将j初始化为1，由于此时i的值为1，条件j <= i为true，首次进入内层循环的循环体，打印一个“*”。

第四步，执行第5行代码中内层循环的操作表达式j++，将j的值自增为2。

第五步，执行第5行代码中的判断条件j<=i，判断结果为false，内层循环结束。执行第8行代码，打印换行符。

第六步，执行第4行代码中外层循环的操作表达式i++，将i的值自增为2。

第七步，执行第4行代码中的判断条件i<=9，判断结果为true，进入外层循环的循环体，继续执行内层循环。

 

2.4.5 跳转语句（break、continue)

break

在switch条件语句和循环语句中都可以使用break语句。

当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。

当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码。

//当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环，则需要在外层循环中使用break语句。

例如：

 

continue

continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。

例如：

 

 

2.5 方法

2.5.1

1.定义：方法的定义就是一段可以重复的代码

2.语法格式：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．){ 
	//方法体
	执行语句
	...
	return 返回值;
}

对于方法的语法格式，具体说明如下：

● 修饰符：方法的修饰符比较多，例如，对访问权限进行限定的修饰符，public修饰符，static修饰符，final修饰符等

● 返回值类型：用于限定方法返回值的数据类型。

● 参数类型：用于限定调用方法时传入参数的数据类型。

● 参数名：是一个变量，用于接收调用方法时传入的数据。

● return关键字：用于返回方法指定类型的值并结束方法。

● 返回值：被return语句返回的值，该值会返回给调用者。

<注意事项>

方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，参数列表用于描述方法在被调用时需要接收的参数

如果方法不需要接收任何参数，则参数列表为空，即()内不写任何内容。

方法的返回值类型必须是方法声明的返回值类型，如果方法没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。

例如：

1.无参数、无返回值：

//因为main是一个静态的，而我们自己定义的参数名（printtree）是一个非静态的，静态参数无法访问非静态参数，所以我们需要在修饰符的后面再加一个static修饰符

public class Demo32 {
	public static void main(String[] args) {
		printtree();
	}
 
	//定义方法-打印圣诞树
public static void printtree() {
	System.out.println(" *");
	System.out.println("***");
	System.out.println("****");
	System.out.println("*****");
	System.out.println(" **");
	System.out.println(" **");
	System.out.println(" **");
	System.out.println(" **");
	
}
}

2.有参数，无返回值：

public class Demo33 {
	public static void main(String[] args) {
		printRectangle(3,5);
	}
	
	//定义方法-有参数无返回值（打印矩形）
	public static void printRectangle(int row ,int column) {
		int i , j ;
		//打印row行
		for (i = 1 ; i <= row ; i++) {  //行数
			//打印column个
			for(j = 1 ;j <= column ;j++) {  //列数-一行有几个*
				System.out.print("*");
			}
			//换行
			System.out.println();
		}
	}
}

 

3.有参数，有返回值：

public class Demo34 {
	public static void main(String[] args) {
		//注意 调用有返回值的方法 需要定义相应的数据类型的变量来接收返回值
		int area = getArea(3 ,5);
		System.out.println("The area is "+area);
	}
	
	//定义了一个求矩形面积的方法 接受两个参数 x y
	public static int getArea(int x , int y) {
		int temp = x * y ; //使用变量temp记住运算结果
		return temp ; //将变量temp的值返回
	}
}

 

4.无参数，有返回值：

public class Demo35 {
	public static void main(String[] args) {
		int num = getnum();
		System.out.println(num);
	}
	
	//
	public static int getnum() {
		Random random = new Random();
		int num = random.nextInt(10); //在10之内随意取值
		return num ;
	}
}

 

 

 

2.5.2 方法重载

1.定义：在同一个作用域内，方法名相同但参数个数不同或者参数类型不同的方法。

2.特点：在同一个类中  &   方法名相同   &  参数列表不同（参数的：顺序、个数、类型）

例如：

//注意：方法重载跟 返回类型 和 参数名 无关

 

2.5.3 方法中的值传递

 

 

2.6  数组

1.定义：是指一组类型相同的数据的集合，数组中的每个数据被称作元素。

2.特点：

•  数组可以存放任意类型的元素，但同一数组里的元素的类型必须相同。
• 数组是一种引用数据类型。

• 数组中的每个元素都有一个索引，数组中最小的索引是0，最大的索引是“数组的长度-1”。

• 在程序中可以通过“数组名.length”的方式获得数组的长度，即元素的个数。

 

2.6.1  数组的定义

在Java中，定义数组的方式有两种

    动态初始化     ：      由系统自动为元素赋初值的方式称作动态初始化

第一种方式：

数据类型[] 数组名;//声明数组

数组名 =  new 数据类型[长度]；//创建数组

int [] arr ;
arr = new int [10] ;

第二种方式：

数据类型[] 数组名 = new 数据类型[长度];  //声明数组并创建数组

int [] arr = new int [10] ;

 

上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99] 。

 

当数组不进行初始化，系统默认初始化，不同类型数组元素的默认值如下：

数据类型	默认初始化值
byte、short、int、long	0
float、double	0.0
char	一个空字符，即’\u0000’
boolean	false
引用数据类型	null，表示变量不引用任何对象

 

<使用数组>

1.访问数组元素： 数组名[索引]

2.给数组元素赋值： 数组名[索引] = 值 ;

例如：

 

      静态初始化      ：   在定义数组的同时就为数组的每个元素赋值

第一种 ：类型[] 数组名 = new 类型[]{元素,元素,……};

第二种 ： 类型[] 数组名 = {元素,元素,元素,……};

例如：

 //注 ： 上图第五行代码不可写成 int[] x = new int[4]{1,2,3,4}; ，这样写编译器会报错。

原因在于编译器会认为数组限定的元素个数[3]与实际存储的元素{1,2,3}个数有可能不一致，存在一定的安全隐患。

 

<常见错误>

异常：异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因。

第一种 ：数组下标越界异常--ArrayIndexOutOfBoundsException

 //错误分析：

运行结果中所提示的错误信息是数组越界异常ArrayIndexOutOfBoundsException。

出现这个异常的原因是数组的长度为4，索引范围为0~3，文件2-25中的第4行代码使用索引4访问元素时超出了数组的索引范围。

 

第二种 ： 空指针异常--NullPointerException

  //错误分析：

10~12行代码都能通过变量arr正常地操作数组。第13行代码将变量置为null，第14行代码再次访问数组时就出现了空指针异常NullPointerException。

 

画图示例内存

 

2.6.2 数组的常见操作

1.数组的遍历

1.定义：在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。

      例如：

 

2.数组最值

在操作数组时，通常会需要数组元素的最值

     例如：

 

3.数组排序 

在操作数组时，经常需要对数组中的元素进行排序。下面主要介绍 “冒泡排序”------在冒泡排序的过程中，不断地比较数组中相邻的两个元素，较小者向上浮，较大者往下沉。

  循环过程如下（假设数组元素分别为9，8，3，5）：

 代码如下：

 

2.6.3 二维数组  （了解即可）

第一种方式：

            数据类型[][] 数组名 = new数据类型[行的个数][列的个数];

例如：

int[][] xx= new int[3][4];

上面的代码相当于定义了一个3*4的二维数组，即3行4列的二维数组

 

第二种方式：

                数据类型[][] 数组名 = new int[行的个数][];

例如：

int[][] xx= new int[3][];

第二种方式和第一种类似，只是数组中每个元素的长度不确定。

 

第三种方式：

        数据类型[][] 数组名= {{第0行初始值},{第1行初始值},...,{第n行初始值}};

例如：

int[][] xx= {{1,2},{3,4,5,6},{7,8,9}};

上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}。

 

以下通过一个案例演示二维数组的使用，该案例要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。