循环结构的分类：
for循环：
for循环语句格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续
(理解)while循环
while循环语句格式：
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续
(了解)do..while循环
do…while循环语句格式：
基本格式
do {
循环体语句;
}while((判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
三种循环的区别：
区别：
do…while循环至少会执行一次循环体
for循环和while循环只有在条件成立的时候才会去执行循环体
注意事项：
如果循环结束后，要需要使用初始化变量，请使用whlie,否则使用for
推荐使用for循环，因为for循环执行完后后，初始化变量就会在内存中消失了。提高内存效率
循环嵌套：
循环中包含另一个循环
for(){
for(){
}
}
控制跳转语句:
break: 结束当前循环，程序执行循环后面的代码
continue:结束本次循环，继续下一次循环
return: 结束当前方法，return后面的语句不执行
1、什么是方法（Method）？
方法是一组为了实现特定功能的代码块的集合。方法在语法上的功能主要有以下两个：
①：结构化代码
将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
②：减少代码重复
一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。
方法在书写时需要注意以下两点：
①：逻辑严谨
方法实现的一个完整的功能，所以在书写时要考虑到各种可能的情况，并对每种情况做出恰当的处理。
②：通用性强（可重复利用）
方法实现的是一种功能，在实际实现时，可以根据需要，使方法具备一定的通用性，除非必要，否则不要写专用的方法。在Java语言中，恰当的使用方法，将使程序更加优雅，便于阅读和使用。
我的总结：
方法：一段可重复使用的代码段；
程序中完成独立功能的一段代码的集合。
2方法格式
[修饰符]返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……])
{
执行语句; [return返回值;]//需要的话
}
参数列表（参数的类型 ，参数的个数，参数的顺序）
我的总结：只要上述有一个不一样，那么这个参数列表就不一样！对于方法而言，即使同名也不是同一个方法，也就是下面讲的方法签名。
3、方法里的属性方法里面的属性
访问控制符：访问控制符限定方法的可见范围，或者说是方法被调用的范围。方法的访问控制符有四种，按可见范围从大到小依次是：public、protected，无访问控制符,private。其中无访问控制符不书写关键字即可。具体的范围在后续有详细介绍。
形式参数：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。
返回值：方法在执行完毕后返还给调用它的环境的数据。
返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void。
方法签名：方法名和方法的参数列表(能区别方法)；//最关键的
java语言中调用方法：对象名.方法名（实参列表）。
实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。
return 语句终止方法的运行并指定要返回的数据。
4方法特点
它可以实现独立的功能;
必须定义在类里面;
它只有被调用才会执行;
它可以被重复使用;
方法结束后方法里的对象失去引用;
如何定义一个功能,并通过方法体现出来：
① 明确该功能运算后的结果.明确返回值类型;
② 明确在实现该功能过程中是否有未知内容参与运算，确定参数列表;
Eg：
package reviewDemo;
/**
* player 的值分别是1,2,3或者其他值时，该方法返回“大明”，“二明”，“小明”，“我没有这个孩子”。
*/
<span style="font-size:18px;"><span style="font-size:18px;">
public class Demo2 {
public static void main(String[] args) {
int player = 5;
System.out.println("返回的结果是："+show(player));
}
public static String show(int p){
switch (p) {
case 1:
return "大明";
case 2:
return "二明";
case 3:
return "小明";
default:
return "我没有这个孩子！";
}
}
}
</span></span>
注意：
1：方法不调用，不执行
2：方法与方法是平级关系，不能嵌套定义
3：方法定义的时候参数之间用逗号隔开
4： 方法调用的时候不用在传递数据类型
5： 如果方法有明确的返回值，一定要有return带回一个值
6： 如果方法没有明确返回值，请使用void来表示方法返回类型
void空类型
定义一个变量的时候，不能定义void类型变量
7: 如果方法的返回值是void类型，那么该方法的return语句可以省略
要是相加的话， 请使用 return ;
如何写一个方法呢?两个明确
返回值类型 明确功能结果的数据类型
参数列表 明确有几个参数，以及参数的类型
5、什么是方法的重载（Overload）？
概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可。
存在的原因：
屏蔽了一个对象的同一类方法由于参数不同所造成的差异。
特点：
与返回值类型无关，只看参数列表。
以下是方法重载的示例：
public void a(int a){}
public int a(){}
public void a(int a,String s){}
Eg：
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {
public static void main(String[] args) {
int[]age = {1,2,3,69,36,636,459};
show(age);
}
public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！
//把数组给打印出来！
System.out.println(Arrays.toString(a));
}
}
</span></span>
我的总结：方法重载，方法名相同，但是参数列表不一致！（和方法覆写不一样，方法覆写的方法名和参数列表都必须一样），注意方法重载和方法覆写的不同！
6可变参数
从java5开始出现了可变参数，这是对java方法及数组的拓展！
方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。
定义格式： 返回值类型 方法名(参数类型...形式参数){ }
可变参数的特点：
只能出现在参数列表的最后；
... 位于变量类型和变量名之间，前后有无空格都可以;
调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。
Eg：
package reviewDemo;
import java.util.Arrays;
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {
public static void main(String[] args) {
int []age = {1,2,3,69,36,636,459};
show(age);
}
public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！
//把数组给打印出来！
System.out.println(Arrays.toString(a));
}
}
</span></span>
Java中的参数传递
实际参数：调用方法时，使用的参数就是实际参数，如下面的a,b
getMax(a,b);
int[] arr = {1,2,3};
change(arr);
形式参数：定义方法时，参数列表中的参数,如下面的x,y
public static int getMax(int x, int y){
x = 200;
y = 100;
}
public static void change(int[] arr){
for (int i=0; i<arr.length; i++ ) {
arr[i] *= 2;
}
}
结论：
如果调用方法时，使用的参数是基本数据类型的值
那么，形式参数(x,y)的改变 对 实际参数(a,b)没有影响
如果调用方法时，使用的参数是引用数据类型的值
那么，形式参数的改变 对 实际参数有影响
7数组
数组：
概念：数组是存储同一种数据类型多个元素的容器
数组就是一个框，里面可以存储多个相同类型的元素
如何访问数组中的元素呢？
可以通过数组名下标的方式访问
格式: 数组名[索引]
数组的格式1：
数据类型[] 数组名；
数据类型 数组名[];
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组的格式2：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
数组常见问题：
数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时。
数组(Array)是Java语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。
备注：
1. 数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；
2. 使用Java数组：必须先声明数组，再给该数组分配内存；
3. 数组对应在内存中一段连续空间。
4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。
8 一维数组
一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；
一维数组的声明方式：
type varName[]; 或 type[] varName;(推荐)
Eg：int age[]; int []age;
数组的长度一旦确定,就不能改变,也就数组是定长的;
我的总结：java语言声明数组的时候不能指定其长度（元素的个数）
Eg：int a[5]; //非法
初始化：
Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；
数组初始化的两种方式：
静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；
格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};
简化语法：数组名 = {元素1,元素2,元素3...元素n};
动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；
格式：数组名 = new 数组类型[数组长度];
我的总结：
不能静态和动态初始化同时使用：
也就是说不能同时指定数组的长度和元素；
Eg:
/**
* 声明数组及初始化
*/
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo3 {
public static void main(String[] args) {
int []age = new int[10];
//动态初始化
for (int i = 0; i < age.length; i++) {
age[i] = i;
System.out.print(age[i]+" ");
}
}
}
</span></span>
输出：0 1 2 3 4 5 6 7 8 9
Java语言的数组索引是从0开始的，也就是说数组里的第一个元素的索引是0,第二个元素的索引是1，依次可以类推。
常见操作：
给数组元素赋值
数组名[索引] =数组类型的值;
访问数组元素
数组类型 变量 = 数组名[索引];
得到数组的长度
int len = 数组名.length; //length是数组的属性
遍历数组（备注：length 属性和循环语句）
数组元素的索引范围（0，长度—1）
Eg：判断数组是否重复
package reviewDemo;
/**
* 判断数组是否重复
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo3 {
public static void main(String[] args) {
int []age = {1,2,3,4,5,6,5};
for (int i = 0; i < age.length-1; i++) {//双层循环，定住一个，再考虑下一个！
for (int j = i+1; j < age.length; j++) {
if(age[i] == age[j]){
System.out.println("有重复的！"+i+" "+j);
break;
}
}
}
}
}
</span></span>
求最大值值
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo4 {
public static void main(String[] args) {
int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };
int max = age[0];
for (int i = 0; i < age.length; i++) {
if (max < age[i]) {
max = age[i];
}
}
System.out.println(max);
}
}
</span></span>
经典用法：冒泡法排序
package reviewDemo;
import java.util.Arrays;
//冒泡排序
<span style="font-size:18px;"><span style="font-size:18px;">public class Demo6 {
public static void main(String[] args) {
int []age = {1,2,36,363,56,95,12,32,1232,3263};
for (int i = 0; i < age.length; i++) {
for (int j = i+1; j <= age.length-1; j++) {
if(age[i] > age[j]){
int temp = age[i];
age[i] = age[j];
age[j] = temp;
}
}
}
System.out.println(Arrays.toString(age));
}
}
</span></span>
//输出为：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]
二维数组
概念：其实就是一个元素为一维数组的数组。
大框里 存放着多个小框，每个小框中存放着多个苹果
格式1：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
int[][] arr = new int[3][2];
格式2：
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3]
arr[2] = new int[1];
格式3：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
int[][] arr = {{1,2,3},{4,6},{6}};
打印杨辉三角形(行数可以键盘录入)
1
11
121
1331
14641
.......
规律：
两边赋值规律：
1
11
1*1
1**1
1***1
arr[i][0] = 1;
arr[i][i] = 1;
中间赋值规律：
arr[i][j] = arr[i-1][j-1] + arr[i-1][j]
打印规律：
*
**
***
****
for (int i=0; i<=n; i++) {
for (int j=0; j<=i; j++) {
SOP("*");
}
System.out.println();
}
*/
<span style="font-size:18px;">import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入杨辉三角形的行数：");
int row = sc.nextInt();
//创建二维数组，用来存储图形
int[][] arr = new int[row][row];
//两边赋值规律：
for (int i=0; i<row; i++) {
arr[i][0] = 1;
arr[i][i] = 1;
}
//中间赋值规律:
for (int i=2; i<arr.length; i++) {
//arr[0],arr[1] 一维数组
for (int j=1; j<i; j++) {
//arr[i][j] 具体一维数组的元素
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
//打印图形
printArray( arr );
}
//打印图形
public static void printArray(int[][] arr){
for (int i=0; i<arr.length; i++) {
//arr[0]...
//for (int j=0; j<arr[i].length; j++) {
for (int j=0; j<=i; j++) {
//arr[i][j] 元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();//换行
}
}
}</span>
import java.util.Scanner;
class Array2Test3 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入杨辉三角形的行数：");
int row = sc.nextInt();
//创建二维数组，用来存储图形
int[][] arr = new int[row][row];
//两边赋值规律：
for (int i=0; i<row; i++) {
arr[i][0] = 1;
arr[i][i] = 1;
}
//中间赋值规律:
for (int i=2; i<arr.length; i++) {
//arr[0],arr[1] 一维数组
for (int j=1; j<i; j++) {
//arr[i][j] 具体一维数组的元素
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
//打印图形
printArray( arr );
}
//打印图形
public static void printArray(int[][] arr){
for (int i=0; i<arr.length; i++) {
//arr[0]...
//for (int j=0; j<arr[i].length; j++) {
for (int j=0; j<=i; j++) {
//arr[i][j] 元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();//换行
}
}
}
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
