分支+循环+方法+数组

最新推荐文章于 2023-03-15 21:43:10 发布

椰子树的皮

最新推荐文章于 2023-03-15 21:43:10 发布

阅读量379

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/Ant_Spirit/article/details/107855307

版权

JAVA 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

一、分支结构

概述：分支结构出现的目的是因为，顺序结构的程序虽然能解决计算，输出等问题，但不能左判断再选择，对于要先做判断在选择的问题就

要选用分支结构来解决

1、if分支结构

1.1、if 单分支结构

语法结构

if(判断条件){
	代码块1....
	代码块2...
}

1.2、多分支结构

语法结构

if（判断条件）{
	代码块1...
	代码块2...
}else{
	代码块1...
	代码块2...
}

1.3、嵌套 if 分支结构

语法结构

if（判断条件1）{
	代码块1...
	代码块2...
}else if（判断条件2）{
	代码块a...
	代码块b...
}else if（判断条件3）{
	代码块c...
	代码块d...
}else{
	代码块5...
	代码块6..
}

2、switch 分支结构

1、概述：当一个case成立，从这个case向后穿透所有case，包括default，知道遇到break或者程序结束才会结束

2、语法结构

switch（变量或者表达式）{
	case 1：
		代码1
		break
	case 2：
		代码2
		break
	case 3：
		代码3
		break
	default：
		代码5
		break
}

3、注意：switch（exprl）,exprl一个整数表达式，整数表达式支持的类型：(byte，short，char都会隐式的转成int类型)，int，
Integer，在jdk1.7版本以后也支持String类型

二、循环结构

1、for循环结构

概述：循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。它由循环体中的条件，判断继续执行某个功能还是退出循环。

根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。

1.1、单层for循环结构

1、语法结构

for(数据类型 开始位置：判断条件；结束位置){
	代码1
	代码2
	代码3
}

2、语法执行顺序

在这里插入图片描述

1.2、嵌套for循环结构

1、嵌套for循环结构由外层for循环和内层for循环结构组成，外层控制“行”，内层控制“列”，根据外层的条件，判断里层能否执行，如果能执

行，就把里层代码都循环完毕后，再继续执行外层，继续判断。。

2、语法结构

for(数据类型1 开始位置1：判断条件1；结束位置1){
	for(数据类型2 开始位置2：判断条件2；结束位置2){
		代码1
		代码2
		代码3
	}
}

3、执行顺序：外层循环执行一次，内存循环全部执行一次

在这里插入图片描述

2、while循环结构

1、语法结构——先判断，再执行

while（判断条件）{
	代码1
	代码2
	代码3
}

2、执行顺序

在这里插入图片描述

3、do-while循环结构

1、语法结构——先执行一次，再判断

do{
	代码1
	代码2
	代码3
}while（判断条件）

2、执行顺序在这里插入图片描述

4、什么时候选择什么循环结构

1、知道了循环的开始位置和结束位置时，可以使用for循环

2、对循环的开始和结束位置不清楚，也不需要代码至少执行一次可以使用while循环

3、对循环的开始和结束位置不清楚，不管满不满足条件都想代码执行一次可以使用do-while循环

三、方法

1、概述

被命名的代码块，方法可以含参数可以不含参数可以提高代码的复用性

2、命名格式

修饰符返回值方法名（参数列表）{ 方法体 }

public void show(){
	代码块1
	代码块2
}

3、分类

①、构造方法

——特殊的一种方法

——构造方法的定义为：修饰符类名(参数列表){方法体}

——注意：构造方法没有返回值，并且构造方法的方法名与类名一致，如果不写构造方法，类里面有个隐

藏的无参构造方法，在创建对象的时候会自动调用

public ClassName(){
	代码块1
	代码块2
}

②、类方法（静态方法）

——特殊的一种方法，由关键字 static 修饰，是一种类的资源，在类加载的时候就已经加载了，类方法只能调用静态资源可以通过对象调用，也可以使用类名调用

——定义格式：修饰符 static 返回值方法名（参数列表）{方法体}

public static void show(String[] args){
	代码块1
	代码块2
}

③、成员方法（实例方法）

——最普通方法，通过方法名调用

——定义格式：修饰符返回值方法名（参数列表）{方法体}

public void show(){
	代码块1
	代码块2
	代码块3
}

④、抽象方法

——特殊的一种方法用关键字 abstract 修饰，通过方法名调用

——定义格式：修饰符 abstract 返回值方法名（参数列表）；

——注意：抽象方法没有方法体

public abstract void show(参数列表)

4、方法的重载

方法的重载是指在一个类中定义了多个同名的方法，但要求每个方法的具有不同的参数列表，参数类型或者参数个数不同的现象

//方法的重载
class A{
	public void show(){
		方法体1
		方法体2
	}
	public void show(int a){
		方法体3
		方法体4
	}
	public void show(String b){
		方法体5
		方法体6
	}
	public void show(int c,String d){
		方法体7
		方法体8
	}
}

5、方法的返回值

方法的返回值通过关键字 return 表示，用于接收返回值的数据类型必须与方法返回值数据类型一致

四、数组

1.概念

数组——Array ，是一个可以用来存储多个相同类型的集合，创建出来的一个数组是在内存中开辟一段连续的存储空间存储数据

2、创建数组

2.1静态初始化数组

int[] array=new int[]{1,2,3,4,5}
//或者
int[] array={1,2，3,4，5}

2.2动态初始化数组

//动态初始化数组必须确定数组的长度
int[] array=new int[length]

2.2.1动态创建数组，内存是什么运行的？？

例如：

int[] array=new int[5]
1、首先在堆内存中开辟一段长度为5的连续存储空间

2、给数组的每一个空间位置完成初始化，整型的默认值为“0”

3、给完成初始化的数组分配一个唯一的标志——地址值

4、在栈内存中开辟一个空间用于存储“引用类型”变量a

5、将数组的地址值交给引用变量a保存

3、数组的类型

整数类型——默认值为“0”

浮点类型——默认值为“0.0”

字符类型——默认值为“\u0000”

字符串类型——默认值为“Null”

4、数组的长度和下标

数组的下标从“0”开始，下标最大值为数组长度-1

如果数组超过最大下标值会报异常：ArrayIndexOutBoundsException(下标越界异常)

Array.length  用来获取数组长度

数组一旦创建，长度不可以在改变

运行长度为“0”的数组

5、数组常用的工具类

5.1、Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。

	int array=new int[]{1,2,3,4,5}
	System.out.Println(Arrays.toString(array))		//输出为：[1，2,3,4，5]

5.2、Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。对引用类型数组，使用优化后的合并排序算法。排序顺序为——升序

	int array=new int[]{2,4，1,3，5}
	Arrays.sort(array)
	for（int i=0;i<array.length;i++）{
		Sytem.out.print(array[i)
	}//输出结果：1,2,3,4,5

5.3、Arrays.copyOf(数组，新的长度)

把数组复制成一个指定长度的新数组。

新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容

新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容

int[] arr={12, 30, 20, 90, 34}	//原数组

nt[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容
System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]
System.out.println(a.length);//10       

int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，晓宇原来长度相当于截取前几个数据
System.out.println(Arrays.toString(a2));//[12, 30, 20]
System.out.println(a2.length);//3