java教材笔记第二章Java编程基础

a__999

已于 2023-08-04 23:35:42 修改

阅读量135

点赞数

分类专栏： java教材笔记文章标签：开发语言 java 笔记

于 2023-07-28 01:37:34 首次发布

本文链接：https://blog.csdn.net/a__999/article/details/131971282

版权

java教材笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

2.1java的基本语法

2.1.1java的基本语法格式

编写java程序必须先声明一个类然后在类中编写实现需求的业务代码。类用class关键字定义，在class前可以有修饰符。

[修饰符] class 类名{

程序代码

}

修饰符--用于限定类的访问权限，可以省略
class--声明类必须用class关键字
定义的类名通常使用首字母大写的形式
程序代码--类中定义的功能代码

注意:

java中程序执行语句可分为结构定义语句和功能执行语句。结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句结构都必须用英文分号结束。中文分号会报"invalid character（无效字符）"错误信息
java严格区分大小写。
良好格式排版。最好让程序整齐美观、层次清晰。
字符串太长，想分开在两行书写：

System.out.printlin("这是一个"+

"例子");

2.1.2java中的注释

//单行注释

/*多行

注释*/

/** * 文档注释：通过JDK的javadoc文档工具可以将文档注释提取出来生成API帮助文档、

* Title: HelloWorld类

* @author plh

* @version1.0

*/

//多行注释中可以嵌套单行注释

//但多行注释中不可嵌套多行注释

2.1.3java中的关键字

关键字（keyword)是编程语言里事先定义好并赋予了特殊含义的单词

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throws	throws
transient	try	void	volatile	while
true	false	null

其中true、false、null 不是关键字，而是文字。包含Java定义的值。和关键字一样,它们也不可以作为标识符使用。

大致含义

abstract ：表明类或者成员方法具有抽象属性
assert： 断言，用来进行程序调试
boolean： 基本数据类型之一，布尔类型
break ：提前跳出一个块
byte ：基本数据类型之一，字节类型
case ：用在switch语句之中，表示其中的一个分支
catch ：用在异常处理中，用来捕捉异常
char ：基本数据类型之一，字符类型
class ：声明一个类
const ：保留关键字，没有具体含义
continue ：回到一个块的开始处
default ：默认，例如，用在switch语句中，表明一个默认的分支
do ：用在do-while循环结构中
double ：基本数据类型之一，双精度浮点数类型
else：用在条件语句中，表明当条件不成立时的分支
enum ：枚举
extends ：表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final ：用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally ：用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float ：基本数据类型之一，单精度浮点数类型
for ：一种循环结构的引导词
goto ：保留关键字，没有具体含义
if ：条件语句的引导词
implements： 表明一个类实现了给定的接口
import ：表明要访问指定的类或包
instanceof ：用来测试一个对象是否是指定类型的实例对象
int ：基本数据类型之一，整数类型
interface： 接口
long ：基本数据类型之一，长整数类型
native ：用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new ：用来创建新实例对象
package： 包
private：一种访问控制方式：私用模式
protected： 一种访问控制方式：保护模式
public ：一种访问控制方式：共用模式
return ：从成员方法中返回数据
short ：基本数据类型之一,短整数类型
static ：表明具有静态属性
strictfp ：用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范 [1]
super ：表明当前对象的父类型的引用或者父类型的构造方法
switch ：分支语句结构的引导词
synchronized： 表明一段代码需要同步执行
this ：指向当前实例对象的引用
throw ：抛出一个异常
throws ：声明在当前定义的成员方法中所有需要抛出的异常
transient ：声明不用序列化的成员域
try ：尝试一个可能抛出异常的程序块
void ：声明当前成员方法没有返回值
volatile ：表明两个或者多个变量必须同步地发生变化
while ：用在循环结构中

2.1.4java中的标识符

在编程过程中，经常需要在程序中定义一些符号来标记一些名称，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但标识符不能以数字开头，也不能是java中的关键字。

定义标识符的规范：

包名所有字母一律小写；
类名和接口名每个单词的首字母都要大写，例如ArrayList；
常量名所有字母都大写，单词之间用下划线，例如DAY_OF_MATH；
变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，例如lineNumber；
在程序中，应尽量使用有意义的英文单词来定义标识符，使程序便于阅读。

2.2java中的变量与常量

2.2.1变量的定义

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

定义变量语法格式

变量类型变量名[=初始值];

//变量类型决定变量的数据性质、范围、存储在内存中所占的字节数以及可以进行的合法操作，变量名必须是一个合法的标识符，而[]中的内容是可选项，即可以在定义变量的同时对该变量进行初始化赋值。

2.2.2变量的数据类型

java是一门强类型的编程语言，对变量的数据类型有严格的限定。定义变量前必须先声明变量的数据类型，在为变量赋值时必须赋予和变量同一种类型的值，否则会出现类型匹配错误的问题。

java中变量的数据类型

基本数据类型
- 数值型
  - 整数类型（byte,short,int,long)
  - 浮点类型（float,double)
- 字符型（char）
- 布尔型（boolean)
引用数据类型
- 类（class)
- 接口（interface）
- 数组
- 枚举（enum)
- 注解（Annotation）

其中，

8种基本数据类型是java语言内嵌的，任何操作系统中都具有相同大小和属性；
引用数据类型是在java程序中由编程人员自己定义的数据类型。

基本数据类型

1.整数类型变量

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

数据类型	占用空间	取值范围	举例说明
byte(位)	8（1个字节）	-2^7 — 2^7-1	byte b = 10;
short(短整数)	16（2个字节）	-2^15 — 2^15-1	short s = 10;
int(整数)	32（4个字节）	-2^31 — 2^31-1	int i = 10;
long(长整数)	64（8个字节）	-2^63 — 2^63-1	long l = 10l;

注意：为long类型的变量赋值时，所赋值后需加一个字母L（或写l），说明赋值为long类型。如果赋值未超出int型的取值范围，可以省略。

2.浮点数数据类型

浮点数类型变量用来存储小数数值。在jaca中，浮点数分为单精度浮点数（float）双精度浮点数（double）。

double型所表示的浮点数比float更精确。

数据类型	占用空间	默认值	取值范围	举例说明
float(单精度)	32（4个字节）	0.0	-2^31 — 2^31-1 (1.4E-45 — 3.4E+38,-1.4E -45— -3.4E+38 )	float f = 10.0f;
double(双精度)	64（8个字节）	0.0	-2^63 — 2^63-1 (4.9E-324 — 1.7E+308,-4.9E -324 — -1.7E+308 )	double d = 10.0d;

注意：

java中小数会默认是double类型的值，因此在一个为float类型的变量赋值时，所赋值后面一定要加字母F（或f)，而为double类型的变量赋值时，可以加D（或d）,也可以不加；
在程序中可以为一个浮点数类型变量赋予一个整数数值。

3.字符类型变量

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

数据类型	占用空间	默认值	取值范围	举例说明
char(字符)	16（2个字节）	空	0-2^16-1 （ 0—65535）	char c = 'c';

注意：

给char类型变量赋值时，需用一对英文半角单引号括起来，也可将char类型的变量赋值为取值范围内的整数，计算机会自动将整数转化为所对应的字符。

4.布尔类型变量

布尔类型变量用来存储布尔值，在java中用boolean表示。变量只有true和false。

数据类型	占用空间	默认值	取值范围	举例说明
boolean（布尔值）	8（1个字节）	false	true,false	boolean b = true;

2.2.3变量的类型转换

在程序中，把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换，分为自动类型转换和强制类型转换。

自动类型转换
自动类型转换也叫隐式类型转换，指两种数据类型在转换过程中不需要显式地进行声明。（把一个类型取值范围小的数值直接赋给另一个取值范围大的数据类型时，系统自动进行数据转换，否则就需要强制数据类型转换）。

byte b = ;
int x = b;//程序把byte类型的变量b转换成了int类型，无需特殊声明
double y = x;//将int类型的变量x转换成double类型，无需特殊声明

强制类型转换
- 也叫显式类型转换，指的是两种数据类型之间的转化需要显式地声明。两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，此时需要强制类型转换。
- 将取值范围大的数据类型的变量赋值给取值范围小的数据类型的变量时，就可能造成数据的丢失，所以系统默认不支持，只能由开发者自己决定是否进行强制类型转换。
- 语法格式

目标类型 变量名 = (目标类型)值;
byte b = num;     ====>      byte b = (byte) num;

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

目标类型变量名 = (目标类型)值;
byte b = num; ====> byte b = (byte) num;

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

数据精度的丢失

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

        //数据精度的丢失
        byte a;
        int b = 298;
        a = (byte) b;
        System.out.println("b="+b);
        System.out.println("a="+a);
    }
}

注意：

所谓表达式是指由变量和运算符组成的一个算式。变量在表达式中进行运算时，也有可能能发送自动类型转换，这就是表达式类型的自动提升。

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

        byte b = 3;
        short s = 4;
        char c = 5;
        //将byte、short、char类型数值增加，再赋值给byte类型
        //byte b2 = b+s+c; //会报错，此处都被自动提升为int类型，表达式运算结果也为int，需要强制类型转换为byte
        byte b2 = (byte) (b+s+c);
        System.out.println(b2);
    }

2.2.4变量的作用域

变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域就是这个变量的作用域。

public class Example04 {
    public static void main(String[] args) {
        int x = 23;
        {
            int y = 96;
            System.out.println("x="+x);
            System.out.println("y="+y);
        }
        //y=x;//此行代码报错，超过了变量y的作用域。
        System.out.println("x="+x);
    }
}

2.2.5java中的常量

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

整型常量

整型常量就是整数类型的数据，有二进制、八进制、十进制、十六进制4中表现形式。

注意：程序中为了标明不同进制，数据都有特定的标识。所以十进制第一位不能是0
- 二进制：由数字0和1组成的数字序列。在JDK7以后，允许使用二进制字面值来表示整数，此时二进制数值前面要加上0b或者0B开头，和十进制进行区分。
- 八进制：以0开头并且其后由0~7（包括0和7）的整数组成的数字序列。
- 十进制：由数字0~9（包括0和9）的整数组成的数字序列。
- 十六进制：以0x或0X开头，其后由0~9、A-F（包括0和9、A和F）的整组成的字符序列。
浮点数常量

浮点数常量就是在数学中用到的小时，分为float单精度浮点数和double双精度浮点数两种类型。前者以f或F结尾，后者以d或D结果，或不加后缀。

浮点数常量还可通过指数形式表示

2e3f 3.6d 3.84d 5.022e+23f

字符常量

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号括起来，可以是英文字母、数字、标点符号以及由转义序列来表示的特殊字符。

'a' '1' '&' '\r'

字符串常量

字符串常量用于表示一串连续的字符，一个字符常量要用一对英文半角的双引号引起来：

"HelloWorld" "123" " welcome \n xxx"

一个字符串常量可以包含一个或多个字符，也可以不包含任何字符，即长度为0。

布尔常量

布尔常量即布尔类型的两个值true和false，常用于区分一个条件的真假。
null常量

null常量只有一个值null，表示对象的引用为空。

java中的常量就是特殊的变量，是固定不变的量。定义常量只需在定义变量语法的基础上加一个final关键字修饰。

final 常量类型常量名 [=初始值];

可以在定义时对常量进行赋值，也可在后续赋值。

final a=0,b;

b=1;

转义字符--反斜杠（\）

\r -----回车符，将光标定位到当前行的开头，不会跳到下一行
\n ----换行符
\t -----制表符将光标移动到下一个制表符的位置
\b -----退格符号，就像键盘上的backspace
\ ' ------表示单引号字符
\ “ -----表示双引号字符
\ \ -----表示反斜杠字符

2.3java中的运算符

程序中经常出现一些特殊的符号，这些如+、-、*、/、=、>、<等，这些符号称作运算符，用于对数据进行算术运算、赋值和比较操作。

2.3.1算术符运算符

运算符	运算	范例	结果
+	正号	a=1;a;	3
-	负号	b=4,-b;	-4
+	加	5+5	10
-	减	6-1	5
*	乘	2*3	6
/	除（即算术中整数的结果）	7/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;

注意：

自增自减的先后；
进行除法运算时，除数被除数都为整数，则结果为整数，如果其中有小书，则结果会时一个小数；
取模运算结构的正负取决于被模数（%左边）的符号，与模数无关。

2.3.2赋值运算符

运算符	运算	范例	结果
=	赋值	a=3;b=2;	a=3;b=2;
+=	加等于	a=3;b=2;a+=b;	a=5;b=2;
-=	减等于	a=3;b=2;a-=b;	a=1;b=2;
*=	乘等于	a=3;b=2;a*=b;	a=6;b=2;
/=	除等于	a=3;b=2;a-=b;	a=1;b=2;
%=	模等于	a=3;b=2;a-=b;	a=1;b=2;

注意：

赋值过程中，运算顺序从右往左，将右边赋值给左边。
可以通过一条赋值语句对多个变量进行赋值

int x,y,z;

x=y=z=5;

但下面这种写法是不可以的

int x=y=z=5;

除了=，其他都是特殊运算符。
使用特殊运算符进行赋值时，强制类型转换会自动完成。不需要显示声明。

public class Example05 {
    //特殊运算符进行运算时，强制类型转换会自动完成，不需要显式声明
    public static void main(String[] args) {
        short s = 3;
        int i = 5;
        s+=i;  //所以此处不报错
        System.out.println("s="+s);
    }
}

2.3.3比较运算符

运算符	运算	范例	结果
==	相等于	4 == 3;	false
！=	不等于	4 !=3;	true
<	小于	4 < 3;	false
>	大于	4 > 3;	true
<=	小于等于	4 <= 3;	false
>=	大于等于	4 >= 3;	true

2.3.4逻辑运算符

运算符	运算	范例	结果
&	与	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 ^ true	false
		true ^ true	true
		true ^ true	false
		false ^ true	true
!	非	!false	true
		!true	false
&&	短路与	true && true	true
		true && false	false
		false && false	false
		false && true	false
\|\|	短路或	true \|\| true	true
		true \|\| false	true
		false \|\| false	false
		false \|\| true	true

注意：

逻辑运算符可以针对结果为布尔值的表达式进行逻辑运算。
与和短路与的区别。

public class Example06 {
    //&和&&的区别
    public static void main(String[] args) {
        int x = 0;
        int y = 0;
        int z = 0;
        boolean a,b;
        a = x > 0 & y++>1;  //逻辑运算符&对表达式进行运算然后将结果赋值给a
        System.out.println("a="+a);
        System.out.println("y="+y);
        b = x >0 && z++>1;  //逻辑运算符&&对表达式进行运算然后将结果赋值给b
        System.out.println("b="+b);
        System.out.println("z="+z);
    }
}

或和短路或的区别

int x = 0;
int y = 0;
boolean b = x==0 || y++>0;

^是异或，两边布值不同为true，相同为false。

2.3.5位运算符

位运算符是针对二进制的每一位进行运算的符号，是专门针对数字0进行操作的。

运算符	运算	范例	结果
&	按位与	0 & 0	0
		0 & 1	0
		1 & 1	1
		1 & 0	0
\|	按位与	0 \| 0	0
		0 \| 1	1
		1 \| 1	1
	1	\| 0	1
~	取反	~0	1
		~1	0
^	按位异或	0 ^ 0	0
		0 ^ 1	1
		1 ^ 1	0
		1 ^ 0	1
<<	左移	00000010<<2	00001000
		10010011<<2	01001100
<<	左移	01100010>>2	00001000
		11100010>>2	11111000
>>>	无符号右移	01100010>>>2	00011000
		11100010>>>2	00111000

&：都为1则为1，否则为0
|：一个为1则为1
~：只针对一个操作数进行操作
^：二进制数值不同为1，相同为0
<<：将操作数所有二进制位左移指定位数，左边移走部分舍去，右边补0
> >：将操作数所有二进制位右移指定位数，右边移走部分舍去，左边补0或1（正数补0，负数补
>>>：无符号右移，不考虑正负数移动指定位数

2.3.6条件运算符

也称三元运算符（三目运算符)，由?:组成。基本等价于if...else精简写法

(boolean_expr) ? true_statement : false_statement;

2.3.7运算符的优先级

优先级	运算符
1	. [] ()
2	++ -- ~ !
3	* / %
4	+ -
5	<< >> >>>
6	< > <= >=
7	== !=
8	&
9	^
10	\|
11	&&
12	\|\|
13	?:
14	= *= /= %= += -= <<= >>= >>>= &= ^= \|=

2.4选择结构语句

2.4.1if条件语句

有三种语法格式

1.if语句

if(判断条件){
执行语句
}

public class Example07 {
    //if语法格式1
    public static void main(String[] args) {
        int age = 17;
        if(age<18){
            System.out.println("此人未成年");
        }
    }
}

2.if...else语句

if(判断条件){
   执行语句1；
   ...
}else{
   执行语句2；
   ...
}

public class Example08 {
    //if...else语句
    public static void main(String[] args) {
        int num = 19;
        if(num % 2 == 0){
            System.out.println("是一个偶数");
        }else{
            System.out.println("是一个奇数");
        }
    }
}

3.if...else if ...else语句

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

public class Example09 {
    //if...else if ...else语句
    public static void main(String[] args) {
        int grade =79;
        if(grade>80){
            System.out.println("成绩为优");
        }else if(grade>70){
            System.out.println("成绩为良");
        }else if(grade>60){
            System.out.println("成绩为重");
        }else{
            System.out.println("成绩为差");
        }
    }
}

2.4.2switch条件语句

是一种常见的选择结构语句，由switch控制表达式和case关键字组成，但是switch条件语句的控制表达式结果类型智能是byte、short、插入、int、enum枚举以及String类型，不能是boolean类型。

语法格式：

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

}

public class Example10 {
    //switch语句
    public static void main(String[] args) {
        int month = 5;
        switch (month){
            case 12:
            case 1:
            case 2:
                System.out.println("当前时间为冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("当前时间为春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("当前时间为夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("当前时间为秋季");
                break;
            default:
                System.out.println("输入的月份不正确!");
                break;
        }
    }
}

注意：

switch条件语句后{}中多个case以及default标签顺序可以随机，不影响程序执行结果，
在default标签中的执行语句后务必加上break关键字，用于执行完语句后跳出switch条件语句，否则会接着执行后续的执行语句，直到遇到break关键字或者switch语句末尾为止。

2.5循环结构语句

2.5.1while循环语句

while语句会反复判断循环条件是否成立，只要条件成立{}中的执行语句就会执行，直到循环条件不成立，while循环才结束。

while(循环条件){
执行语句
...
}

{}中的执行语句被称为循环体。

public class Example11 {
    //while循环
    public static void main(String[] args) {
        int x = 1;
        while (x <= 4) {
            System.out.println("x="+x);
            x++;
        }
    }
}

2.5.2do...while循环语句

也称后测试循环语句

do{
执行语句
...
}while(循环条件);

do...while循环语句先执行循环体再进行循环条件判断，无论如何都会先执行一次。

public class Example12 {
    //do...while语句
    public static void main(String[] args) {
        int x = 4;
        do{
            System.out.println("x="+x);
            x++;
        }while(x<=4);
    }
}

2.5.3for循环语句

是最常用的循环语句，一般用在循环次数已知的情况下，通常情况下可以代替while循环

for(初始化表达式;循环条件;操作表达式){
执行语句
...
}
/*
1、执行初始化表达式
2.执行循环条件，如果循环条件结果为true,则执行第三部，如果结果为false，执行第五步
3.执行4
4.执行3，然后重复执行第二步
5.退出循环
*/

在for循环中，程序会首先执行一次初始化表达式，然后进行循环条件判断，结果为true，执行循环体，再执行操作表达式来控制循环条件，这样就完成一轮for循环，直到循环条件为false时，跳出整个for循环。

public class Example13 {
    //for循环
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 4; Qi++) {
            sum += i;
        }
        System.out.println("sum="+sum);
    }
}

2.5.4循环嵌套

嵌套循环是指在一个循环语句的循环体重再定义一个循环语句的语法结构。以上循环语句都可以进行循环嵌套，并且它们之间也可以互相嵌套。实际开发中，最常用的是for循环嵌套。

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

public class Example14 {
    //嵌套循环-----九九乘法表
    public static void main(String[] args) {
        //外层循环，变量i控制输出1-9行
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j < i; j++) {
                //使用字符串拼接的形式，打印每个内层循环的执行语句
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            //使用println()方法控制外层循环进行换行
            System.out.println("");
            //print函数用于将文本或变量的值输出到控制台，但不会在输出结束后自动换行。
            // 而println函数与之类似，也是将文本或变量的值输出到控制台，但在输出结束后会自动换行。
        }
    }
}

2.5.5跳转语句

1.brak语句

switch条件语句和循环结构语句都可以使用break语句。
出现在switch语句中，作用是跳出某个case并跳出switch结构，
出现在循环结构语句中，作用是跳出当前循环结构语句，执行后面的代码

public class Example15 {
    //break语句
    public static void main(String[] args) {
        int x = 1;
        while(x<=4){
            System.out.println("x="+x);
            if(x == 3){
                break;
            }
            x++;
        }
    }
}

public class Example16 {
    //break outer
    public static void main(String[] args) {
        outer:for (int i = 1; i < 9; i++) {
            //外层循环，变量i控制输出1-9行
            for (int j = 1; j <= i; j++) {
                if(j>=3){
                    break outer;    //当循环打印第3行时，直接跳出outer外层循环
                }
                //使用字符串凭拼接的形式，打印每个内层循环的执行语句
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            //使用println()方法控制外层循环进行换行
            System.out.println("");
        }
    }
}

//break默认跳出当前所在的循环
//在外层for循环前面增加了标记"outer",使用”break outer"语句会跳出指定的外层循环，所以只打印了2行结果

2.countinue语句

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

public class Example17 {
    //continue语句------求1-100之间所有奇数的和
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){   //i是偶数时，不累加
                continue;
            }
            sum +=i;
        }
        System.out.println("sum="+sum);
    }
}

2.6数组

数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。数组可分为一维数组和多维数组。

2.6.1数组的定义

数组的三种定义方式

//01-------数组类型[] 数组名 = new 数组类型[数组长度];
int [] ids = new int[100];

//02-------数组类型[] 数组名 = new 数组类型[]{数组元素0，数组元素1，...};
String[] names = new String[] {"张三","tom",...};

//03-------数组类型[] 数组名 = {数组元素0，数组元素1，...};
Object[] object = {"张三","tom",....}

其中：

数组类型就是变量的数据类型；
数组名就时定义的变量名，要符合标识符的规范；
数组长度表示该数组中可容纳的数组元素的个数；
数组元素1-n表示定义的数组中具体包含的数据；
数组中最小的索引是0，最大的索引是“数组的长度-1”。（超出数组范围报错："ArrayIndexOutOfBoundsExcepiton"，数组角标越界异常错误。

public class Example20 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        System.out.println("arr[4]="+arr[4]);//数组角标越界异常
    }
}

length属性，通过数组名.length获得数组的长度，即数组中元素的个数。

public class Example18 {
    public static void main(String[] args) {
        //第一种方式定义数组
        int[] ids = new int[100];
        System.out.println("ids[0]="+ids[0]);
        System.out.println("ids[99]="+ids[99]);
        System.out.println("=================");

        //第二种方式定义数组
        String[] names = new String[]{"张三","tom","jack","rose"};
        System.out.println("names[0]="+names[0]);
        System.out.println("names[2]="+names[2]);
        System.out.println("=================");

        //第三种方式定义数组
        Object[] object = {"张三","tom","jack","rose"};
        System.out.println("数组的长度为："+object.length);
        System.out.println("object[0]="+object[0]);
        System.out.println("object[2]="+object[2]);

    }
}

java不同数据类型元素的默认值

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

为数组中的元素赋值和修改

public class Example19 {
    public static void main(String[] args) {
        //第一种方式定义数组
        int[] ids = new int[100];
        System.out.println("ids[0]="+ids[0]);
        //为数组指定元素进行初始化复制
        ids[0] = 2500;
        System.out.println("ids[0]="+ids[0]);
        System.out.println("=================");

        //第二种方式定义数组
        String[] names = new String[]{"张三","tom","jack","rose"};
        System.out.println("names[0]="+names[0]);
        //为数组定义时指定的初始值进行修改
        names[0]="李四";
        System.out.println("names[0]="+names[0]);
        System.out.println("=================");

        //第三种方式定义数组
        Object[] object = {"张三","tom","jack","rose"};
        System.out.println("object[0]="+object[0]);
        //为数组定义时指定的初始值进行修改
        object[0]="李四";
        System.out.println("object[0]="+object[0]);

    }
}

使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。

public class Example21 {
    public static void main(String[] args) {
        int [] arr = new int[3];
        arr[0] = 5;
        System.out.println("arr[0]="+arr[0]);
        arr = null;//将变量arr置为null
        System.out.println("arr[0]="+arr[0]);
    }
}

2.6.3数组的常见操作

数组遍历

public class Example22 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);

        }
    }
}

数组最值

public class Example23 {
    public static void main(String[] args) {
        //1.定义一个int[]数组
        int[] arr = {4,1,6,3,9,8};
        //2.定义变量max用于记住最大数，首先假设第一个元素为最大值
        int max = arr[0];
        for (int i = 1; i < arr.length ; i++) {
            //比较arr[i]的值是否大于max
            if(arr[i]>max){
                //条件成立，将arr[i]的值赋给max
                max=arr[i];
            }
        }
        System.out.println("数组中的最大值为："+max);
    }
}

数组排序

常见的数组排序算法--冒泡排序。不断地比较数组中相邻的两个元素，叫嚣着向上浮，较大者向下沉。

public class Example24 {
    public static void main(String[] args) {
        int[] arr = {9,8,3,5,2};
        //1.冒泡排序前，先循环打印数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();//换行

        //2.进行冒泡排序
        //2.1外层循环定义需要比较的论述（两数对比，要比价n-1轮）
        for (int i = 1; i < arr.length; i++){
            //内层循环定义第i轮需要比较的两个数
            for (int j = 0; j < arr.length-i; j++) {
                if (arr[j] > arr[j + 1]) {    //比较相邻元素
                    //元素交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        //完成冒泡排序后，再次循环打印数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");

        }
    }
}

2.6.3多维数组

二维数组可以被看做是特殊的一维素组。

定义方式

//第一种方式---指定二维数组的长度和每个数组的元素个数
int[] arr=new int[3][4];

//第二种方式---只指定二维数组的长度，不确定每个数组的元素个数
int[][] arr=new int[3][];

//第三种方式--直接使用嵌套大括号，对二维数组初始化复制
int[][] arr={{1,2},{3,4,5,6},{7,8,9}};

public class Example25 {
    public static void main(String[] args) {
        int[][] arr=new int[3][];
        arr[0] = new int[]{11,12};
        arr[1] = new int[]{21,22,23};
        arr[2] = new int[]{31,32,33,34};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            int groupSum = 0;
            for (int j = 0; j < arr[i].length; j++) {
                groupSum +=arr[i][j];
            }
            sum +=groupSum;
            System.out.println("第"+(i+1)+"小组销售额为：" +
                    groupSum + "万元");
        }
        System.out.println("总销售额为："+sum+"万元");
    }
}