Java语言基础组成之：程序流程控制、函数、数组

一、程序流程控制

1.1 判断结构

1.1.1 if语句三种格式：



if语句特点：

1、每一种格式都是单条语句。

2、第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。

3、条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;

以下代码为应用三元运算符替代if else格式的示例

class IfElse
{
public static void main(String[] args)
{
int a=5,b,c;
//if...else语句
if(a>6)
{
b=6;
}
else
{
b=66;
}
System.out.println(b);

/*
if...else结构在一定情况下可简化为（条件表达式）？表达式1：表达式2；

三元运算符
好处：可简化if。。。else语句
弊端：因为是一个运算符，所以运算必须要有结果
*/

//三元运算语句
c=(a>6)?6:66;
System.out.println(c);
}
}

1.1.2 switch语句格式：

switch(表达式)

{

case 取值1:

执行语句；

break；

case 取值2:

执行语句；

break；

…...

default:

执行语句；

break；

}

switch结构特点：

1、switch语句选择的类型：byte short int char

2、case之间与default在代码书写上没有顺序要求。程序会先执行case，没有匹配的case才执行default。

3、结束switch语句的两种情况：遇到break，或执行到switch语句结束

4、如果匹配的case或者default没有对应的break，则程序会继续向下执行，运行可以执行的语句，

直到遇到break或者switch结尾结束。

代码实例：

class Switch
{
public static void main(String[] args)
{
//switch语句选择的类型：byte short int char
int a=60,b=6;
char ch='*';
switch (ch)
{
default:
System.out.println("无法进行操作");
case '+' :
System.out.println(a+b);
break;
case '-' :
System.out.println(a-b);
break;
case '*' :
System.out.println(a*b);//先被执行
//break;
case '/' :
System.out.println(a/b);//没有break，继续执行
//break;

}
}
}

1.2 循环结构

代表语句：while ， do while ， for

1.2.1 while语句格式：

while(条件表达式)

{

执行语句；

}

1.2.2 do while语句格式：

do

{

执行语句；

}

while(条件表达式);

do while特点是无论条件是否满足， 循环体至少被执行一次。

1.2.3 for语句格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)

{

执行语句；

}

如执行输出0-9十个数字的语句

for(int x=0;x<10;x++)

{

System.out.println(x);

}

嵌套循环（forfor结构）

语句嵌套形式，其实就是语句中还有语句。形象说法是大圈套小圈

以下代码为应用嵌套实现九九乘法表

class ForFor
{
public static void main(String[] args)
{
<span style="white-space:pre">		</span>for(int e=1;e<=9;e++)
{
for(int f=1;f<=e;f++)
{
System.out.print(f+"*"+e+"="+(f*e)+'\t');//print无法自动换行,\t制表符 表格对齐
}
System.out.println();//用于实现换行
}
}
}

累加思想

累加思想：(变量记录+循环)通过变量记录住循环操作后的结果，通过循环的形式，进行累加动作

如分别用while和for语句实现1-9九个数字的累加

class ForTest2
{
public static void main(String[] args)
{
//用while语句求出

int sum=0;<span style="font-family: Arial, Helvetica, sans-serif;">//1、定义变量sum，存储不断变化的和</span>
int x=1;<span style="font-family: Arial, Helvetica, sans-serif;">//2、定义变量x，存储不断变化的被加的数</span>
<span style="white-space:pre">		</span>while(x<=10)<span style="font-family: Arial, Helvetica, sans-serif;">//3、定义循环，重复加法的过程。</span>
{
<span style="white-space:pre">			</span>sum=sum+x;
x++;
}
System.out.println(sum);
//用for语句求出
int sum1=0;<span style="font-family: Arial, Helvetica, sans-serif;">//1、定义变量sum1，存储不断变化的和</span>
for(int y=1;y<=10;y++)<span style="font-family: Arial, Helvetica, sans-serif;">//2、定义循环，重复加的过程</span>
{
sum1=sum1+y;
}
System.out.println(sum1);
}
}

计数器思想

计数器思想：通过一个变量记录住数据的状态变化，也许通过循环完成。

以下代码应用计数器思想实现记录1-100以内能7整除的数的个数

class  ForTest3
{
public static void main(String[] args)
{
//1、定义变量x，用来存储除7的数
//2、定义变量y，用来存储100以内能被7整除的数的个数
int x=100,y=0;
//思路：1、定义循环语句，选择for语句
//		2、在循环中定义判断，只要可被7整除即可。使用if语句。条件：x%7==0
//		3、通过变量y来记录符合x%7==0的数出现的次数
for(;x>0;x--)
{
if(x%7==0)
{
System.out.println(x+"可被7整除");
y++;
}
}
System.out.println("100以内可被7整除的数有"+y+"个");
}
}

注：

1、for循环中语句运行的顺序：初始化表达式只读一次(int x=0)，判断循环条件( x<10)，为真就执行

循环体(System.out.println(x))，然后再执行循环后的操作表达式(x++)，接着继续判断循环条件(x<10)， 重复这个

过程，直到条件不满足为止。

代码示例：

for(System.out.println("a");y<3;System.out.println("c"),y++)
{
System.out.println("d");
}
//结果：adcdc

2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束时就在内存中被释放。而while循环

使用的变量在循环结束后还可以继续使用；如果变量只为控制循环的次数而存在，用for语句优于while语句，内存

更优化

3、最简单无限循环格式：“while(true)”和“ for( ; ; )”，无限循环存在的原因是并不知道循环多少次，而是根据

某些条件，来控制循环。

以下代码解释了while与for的区别：

/*
while与for的区别
while与for可以互换，区别在于for为了循环而定义的变量在for循环结
束时就在内存中被释放。而while循环使用的变量在循环结束后还可以继续
使用；如果变量只为控制循环的次数而存在，用for语句优于while语句，内存
更优化
*/
class ForDemo
{
public static void main(String[] args)
{
for(int x=1;x<5;x++)
{
System.out.println("x="+x);
}
//System.out.println("x最终为"+x); //报错，x的作用域只在for循环语句中

int y=1;
while(y<5)
{
System.out.println("y="+y);
y++;
}
System.out.println("y最终为"+y);//正确，语句在y的作用域范围内。
}
}

1.2.4 其他流程控制语句

break(跳出)， continue(继续)

break语句：应用于选择结构(if或switch)和循环结构(for)。

continue语句：应用于循环结构(for)。

注：

1、这两个语句离开应用范围，存在是没有意义的。

2、这个两个语句在流程控制语句块的最后，其后面不可以有语句，因为执行不到。

3、continue语句是结束本次循环继续下次循环。

4、标号的出现，可以让这两个语句作用于指定的范围。

代码实例：

/*
break,continue 语句
break语句：应用范围（选择结构：switch case default）、循环结构（loop）
continue语句：应用于循环结构
注：a、这两个语句离开应用范围，无存在意义。
b、这两个语句单独存在下面都不可以有语句，因为执行不到
c、continue语句是结束本次循环继续下次循环
d、标号的出现，可以让这两个语句作用于指定的范围
记住：1、break和continue语句作用的范围。
2、break和continue单独存在时，下面不可以有任何语句，因为执行不到，是废话，系统会报错
*/
class  BreakContinue
{
public static void main(String[] args)
{
/*break应用1*/
for(int x=0;x<3;x++)
{
for(int y=0;y<4;y++)
{
System.out.print("x="+x+";");//x在外循环中
break;
}
}
System.out.println();

/*break应用2*/
for(int a=0;a<3;a++)
{
for(int b=0;b<4;b++)
{
System.out.print("b="+b+";");//b在内循环中
break;
}
}
System.out.println();

/*break应用3 输出为c=0*/
w:for(int c=0;c<3;c++)//给循环语句编号，标号为w
{
v:for(int d=0;d<4;d++)
{
System.out.println("c="+c);
break w;  //跳出w:for()循环
}
}

/*continue应用1*/
for(int e=0;e<3;e++)
{
System.out.print("e="+e+";");
continue;				//跳回for语句重新执行
}
System.out.println();

/*continue应用2 输出f=2 f=4 f=6 f=8 f=10*/
for(int f=1;f<=10;f++)
{
if(f%2==1)
{
continue;//当f为奇数时，跳回for语句重新执行
}
System.out.print("f="+f+";");//当f为偶数时，执行此语句
}
System.out.println();

/*continue应用3 输出为g=0 g=1 g=2*/
w:for(int g=0;g<3;g++)    //给循环语句编号，标号为w
{
v:for(int h=0;h<4;h++)
{
System.out.print("g="+g+";");
continue w;       //跳到w标号位置继续执行
}
}
System.out.println();

//break;     //报错: 在switch或loop外部中断
//continue;  //报错: continue在loop外部
}
}

二、函数(function)

2.1 函数的基本组成

函数的定义：函数就是定义在类中的具有特定功能的一段独立小程序；函数也称为方法。

函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，)

{

执行语句;

return 返回值;

}

如:

public int he(int x,int y)

{

return x+y;

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

2.2 函数的特点

1、定义函数可以将功能代码进行封装

2、便于对该功能进行复用

3、函数只有被调用才会被执行

4、函数的出现提高了代码的复用性

对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在

最后一行可以省略不写。

注意：

1、函数中只能调用函数，不可以在函数内部定义函数。

2、定义函数时，函数的结果应该返回给调用者，交由调用者处理。

2.3 函数的应用

两个明确

1、明确要定义的功能最后的结果是什么？

2、明确在定义该功能的过程中，是否需要未知内容参与运算

示例：

需求：定义一个功能，可以实现两个整数的加法运算。

分析：

1、 该功能的运算结果是什么？两个数的和，也是一个整数(int)

2、在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确 定的。(两个参数int，int)

代码：

int-getSum(int-x,int-y)

{

return-x+y;

}

2.4 函数的重载(overload)

重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的特点：与返回值类型无关，只看参数列表。

重载的好处：方便于阅读，优化了程序设计。

重载示例：

int add(int x,int y)//返回两个整数的和

{

return x+y;

}

int add(int x,int y,int z)//返回三个整数的和

{

return x+y+z;

}

double add(double x,double y)//返回两个小数的和

{

return x+y;

}

2.5 数组

2.5.1 数组的定义

概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处；可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[-]||数组名 = new 元素类型[元素个数或数组长度];

示例：int[-]-arr=new-int[5];

格式2：

元素类型[-]-数组名=new-元素类型[-]{元素,元素,……};

示例：int[-]-arr=new-int[-]{3,5,1,7};

代码示例：

class ArrayDemo
{
public static void main(String[] args)
{
//定义一个可以存储3个整数的容器
int[] x=new int[3];//x是数组数据类型
int x[]=new int[3];//此形式也行

//数组定义格式一
int[] arr1=new int[]{1,5,6,55,66};
int[] arr2={1,5,6,55};

//数组定义格式二
int[] arr3=new int[3];
arr3[0]=5;
arr3[1]=6;
arr3[2]=55;

System.out.println(arr3[4]);//ArrayIndexOutOfBoundsException:4   提示数组标号越界了
arr3=null;
System.out.println(arr3[1]);//  NullPointerException     无指针报错
}
}

获取数组中的元素、通常会用到遍历

int[] arr={1,2,3,4,5,6,7,8,9};
for(int a=0;a<arr1.length;a++)
{
System.out.println("arr["+a+"]="+arr[a]);
}

2.5.2 数组内存结构
下图展示了"int[ ] x=new int[100]"再栈内存和堆内存中的存储情况



内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空 间进行了不同区域的划分，因为

每一片区域都有特定的处理数据方式和内存管理方式。
栈内存内存结构：

用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存内存结构：

1、数组和对象，通过new建立的实例都存放在堆内存中。

2、每一个实体都有内存地址值

3、实体中的变量都有默认初始化值

4、实体不在被使用，会在不确定的时间内被垃圾回收器回收

2.5.3 数组操作常见问题

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[-]-arr=new-int[2];

System.out.println(arr[3]); //访问到了数组中的不存在的脚标时发生。

2、空指针异常(NullPointerException)

int[-]-arr=null;

System.out.println(arr[0]);//arr引用没有指向实体，却在操作实体中的元素时。



2.5.4 数组常见操作

1、获取最值(最大值，最小值)

2、排序(选择排序，冒泡排序)

3、折半查找(二分查找)

2.5.5 数组中的数组

二维数组[-][-]

格式1：int[-][-]-arr=new-int[3][2];

解释：

1、定义一个名称为arr的二维数组

2、二维数组中有3个一维数组

3、每一个一维数组中有2个元素

4、一维数组的名称分别为arr[0], arr[1], arr[2]

5、给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：int[-][-]-arr=new-int[3][-];

解释：

1、二维数组中有3个一维数组

2、每个一维数组都是默认初始化值null

3、可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

格式3：int[-][-]-arr={{3,8,2},{2,7},{9,0,1,6}};

解释：

1、定义一个名称为arr的二维数组

2、二维数组中的有三个一维数组

3、每一个一维数组中具体元素也都已初始化

arr[0] = {3,8,2};

arr[1] = {2,7};

arr[2] = {9,0,1,6};

4、第三个一维数组的长度表示方式：arr[2].length;

引申：Java中length与length()的区别

length是针对数组的属性，用于获取数组的长度

length()是字符串的方法，用于获取字符串的长度