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

最新推荐文章于 2024-06-24 15:48:35 发布

espose

最新推荐文章于 2024-06-24 15:48:35 发布

阅读量718

点赞数

分类专栏：学习笔记文章标签： Java语言程序流程控制函数数组

本文链接：https://blog.csdn.net/espose/article/details/43226091

版权

学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、程序流程控制

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()是字符串的方法，用于获取字符串的长度

espose

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录