第二周 2.10-2.16

Day6

循环

概念
- 通过某个条件，重复的执行一段逻辑代码
执行流程
- 程序开始
  - 循环条件
    - true
      - 循环操作
    - false
      - 循环结束，执行后续代码
循环的组成

需求：打印100遍“helloworld”

package demo;

public class TestWhile{
public static void main(String[] args){
int i =1;//初始部分；用来判断的变量
while(i<=100){//循环条件，决定是否继续循环的依据
System.out.println(“HelloWorld”)；//循环操作；单次执行的逻辑代码或任务
i++;//迭代部分；控制循环条件改变的增量
}

]

}
While循环
- 语法
  
  while（布尔表达式）{
  
  //逻辑代码（循环操作）
  
  }
- 执行流程
  - 先对布尔表达式进行判断，结果为true，则执行逻辑代码
  - 本次执行完毕后，再次进行判断，结果仍然为true 则，再次执行后续代码
  - 直至布尔表达式的结果为false 时，才会退出循环结构，执行后续代码
- 注意：循环有四个部分组成
- 特点：首次即有入口条件，先判断、再执行，适用于循环次数明确的情况
  
  public calss TestWhile{
  public static void main(String[] args){
  
  iint i = 1000;
  while(i<=1000){/首次判断不满足，这一次都不会执行，（执行次数：0-n次）
  System.out.println(“helloWorld”）；
  }
  System.out.println("程序结束“）；
  }
  
  }
do while循环
- 语法
  
  do{
  逻辑代码(循环代操作）
  
  }while(布尔表达式）；
- 执行流程
  - 先执行一次循环操作之后，再进行布尔表达式的判断
  - 如果结果为true,则执行循环操作
  - 如果结果为false，才会退出循环结构，执行后续代码
- 特点：首次没有入口条件，先执行，再判断
- 应用场景：适用于循环次数不明确的情况
for 循环
- 语法
  
  for(初始部分；循环条件；迭代部分){
  //循环操作
  }
- 执行流程
  - 首次执行初次部分（仅一次）
  - 对布尔表达式进行判断，结果为true，则执行逻辑代码
  - 本次执行完毕后，执行迭代部分，再次判断，结果仍然为true，则再次执行逻辑代码
  - 直至布尔表达式的结果为false时，才会退出循环结构
- 特点：首次即有入口条件，先判断、再执行，适用于循环次数明确的情况
- 子主题 4
流程控制关键字
- break:终止、跳出switch 、循环结构
  
  public calss TestBreak{
  public static void main(String[] args){
  
  for (int i =1;i<=10;i++){
  if（i==5）{
  break;
  }
  System.out.println("当前循环次数：“+i);
  }
  System.out.println(“循环结束”);
  }
  }
- continue:结束本次、进入下一次循环。
  
  public class TestContinue{
  public static void main(string args){
  for (int i =1;i<=10;i++){
  if(i==5){
  continue;
  }
  System.out.println("循环结束“)；
  }
  System.out.println(“循环结束”);
  }
  
  }
补充：引用类型不可以在循环体里定义，基本数据类型可以在循环体里面定义
嵌套循环
- 概念：在完整的循环结构中，嵌套另一个完整的循环结构
- 例子
  
  public class TestNesFor{
  public static void main(String[] args){
  for(int i = 1;i<=3;i++){//外层控制行数
  for (int j =1;j<=5;j++){//内层控制列数
  System.out.println("*");
  }
  System.out.println();
  }
  }
  }
  
  }

Day7

break和continue的程序训练

断点

在程序行左边打一个点，debug
- 右键watch
  - F 8运行到下一个断点

函数

函数的概念
- 实现特点功能的一段代码，可反复使用
函数的定义：语法

public static void 函数名称（）{//遵循标识符命名规范

//函数主体功能代码
}
- 定义的位置：函数的定义在类的内部，与main()函数并列
  
  //位置1
  public class TestDefinitionFunction{
  //位置2
  public static void main(String[] args){
  //位置3
  
  }
  //位置4
  }
  //位置5
  
  正确位置：位置2，位置4
- 定义第一个函数
  
  public class TestFunction{
  public static void main(String[] args ){
  System.out.println(“床前明月光”);
  System.out.println(“疑是地上霜”);
  System.out.println(“举头望明月”);
  System.out.println(“低头思故乡”);
  
  }
  //定义：打印10个分割符的函数
  public static void printSign(){
  for(int i =1;i<=10;I++){
  System.out.println("-");
  }
  System.out.println();
  }
  
  }
  - 运行结果：
    
    床前明月光，疑是地上霜，举头望明月，低头思故乡
  - 注意：函数的定义并没有改变执行结果
经验：将需要在多个位置重复使用的一组代码，定义在函数内
函数的组成
函数的调用
- 在需要执行函数代码的位置，通过函数名称进行调用
- 注意：调用函数时，会优先执行函数内部代码，结束后，返回到函数调用处，继续向下执行
函数的好处
- 方便函数与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使函数完成相应的功能
- 调用函数时，所传入的数据被称为“参数”

Day8

函数参数

函数的参数
- 形参
  - 定义语法
    
    public static void 函数名称（形式参数）{
    
    //函数主体
    }
    - 经验：“形参”等价于局部变量的声明
- 实参
  - 调用语法
    - 函数名称（实际参数）;
      - 经验:"'实参等价于局部变量的赋值
单个参数

public class TestFunction{
public static void main(String[] args ){
System.out.println("床前明月光’);
printSign();

}
public static void printSign(int count){
for (int i =1;i<count;i++){
```
  			System.out.println("-");
```
}
System.out.println();
}
}

//实际参数：10 调用带参函数时，必须传入实际参数，为形式参数赋值

//形式参数：int count
当函数被执行时，循环count 次
多个参数

public class TestFunction{
public static void main(String[] args){
System.out.println("床前明月光’);
printSign(10,’#’);
System.out.println(“疑是地上霜”);
System.out.println(“举头望明月”)
System.out.println(“低头思故乡”
}
//定义;打印
}

//实参： 10 ，#
调用带参数时，依次传入实参，类型、个数、顺序，必须与形参对应

//形参： int count ,char sign 当函数被执行时，打印 count 次 sign
如何定义参数：根据具体的业务需求，来定函数的参数

返回值和返回值类型

定义语法

public static 返回值类型函数名称（形式参数列表）{

//函数主体
return value ;// 返回值

}
调用语法

变量 =函数名称（）；
变量 = 函数名称（）；
1、规定返回值的具体类型（基本、引用、void） 2、根据需求返回一个结果（值） 3、变量类型与返回值类型一致 4 变量类型与返回值类型一致
例子

public class TestResultValue {
public static void main(String[] args ){
int result =add(5,6);//接收返回值：函数调用的表达式，最终代表了所返回的结果
System.out.println(result);

}
public static int add（int a ,int b ）{//返回值类型：定义时，即约定了返回的结果类型

return a+b;//返回值：与返回值类型匹配的具体结果。在return 关键字的后面追加具体值
}
]
return 关键字
- 一个函数只能有一个返回值
- 当有返回值得函数存在分支结构时，必须保证每一个分支都具有正确的返回值
- return 的两种用法：
  - 应用在具有返回值类型的函数中： return value ;//表示结束当前函数，并伴有返回值，返回到函数调用处
  - 应用在没有返回值类型（void ）的函数中： return ;//表示结束当前函数，直接返回到函数调用处
    
    例子：
    public static void show (){
    
    for (int i =1;i<=100;i++){
    if (i==50){
    return ;// 结束当前函数直接返回
    
    }
    }
    }
- 注意：一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套
- 经验：一个函数只做一件事
- 好处：
  - 减少代码亢余
  - 提高复用率
  - 提高可读性
  - 提高维护性
  - 方便分工合作

Day9

多级调用

public class TestNestInvoke{

public static void  main(String[] args){
m1();

}
public static void m1(){
System.out.println(“m1() -start”);
m2();
System.out.println(“m1()-end”);

}
public static void m2(){
System.out.println(“m2() --start”);
System.out.println(“m2() -end”);
}
}

运行结果：

运行结果：
m1() -start
m2() -start
m2() -start
m1() -start
优先执行函数内部代码，结束后，返回到调用处，继续向下执行

无穷递归

public class TestRecursionInvoke{
public static void main(String[] args ){
m1();
}
public static void m1(){
System.out.println("m1() -start’);
m1();
System.out,println(“m1() -end”);

//当函数自己调用自己时，如果没有正确的出口条件，则产生无穷递归
}

}

注意： exception in thread “main” java.lang.StackOverFlowError 内存溢出

递归的概念：实际的开发中，递归可以解决具有机油规律的特定问题

递归的应用场景： 1 、当需要解决问题可以拆开若干个小问题，大小问题的解决方法相同 2、有固定规律，函数中个，自己调用自己

如何正确使用递归：设置有效的出口条件，避免无穷递归

循环阶乘的例子

计算5的阶乘 5！=54321

public class TestFactorial{

public static void main(String[] args){

	System.out.println(factorial(5));

}
public static int factorial(int n){
int sum =1;
for(int i =2;i<=n;i++){
sum*=i;

//循环计算阶乘较为简单，依次与每个值相乘即可
}
return sum;
}
}

注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归的实现方式更为简单

Day10

数组

概念
- 一组连续的存储空间，存储多个相同数据类型的值
特点：
- 类型相同
- 长度固定
数组的创建

public class TestCreateArray{

public static void main(String [] args){

int [] a = new int[5];//分配长度为5的连续而空间

}

}

//可以存储5个int 类型的值
- 先声明、再分配空间
  - 数据类型 [] 数组名；
  - 数组名 =new 数据类型[长度]
- 声明并分配空间：
  - 数组类型 [] 数组名 = new 数据类型
- 声明并赋值（繁）
  - 数组类型 [] 数组名 = new 数据类型 [] {value 1 ,value 2 ,value3 ,、、、、、、} ；
- 声明并赋值（简）
  - 数据类型 [] 数组名 = { value1， value2，value3} //显示初始化，注意：不可换行
数组的使用

public class TestCreateArray{

public static void main(String[] args){

int [] a = new int [5];//创建数组
a[0]=5;//依次赋值
a[1]=3;
a[2]=4;
a[3]=7;
a[4]=10;
System.out.println(a[0]);//依次取值
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);

}
}
- 数组中的每个数据被称为“数组元素‘
- 对每个元素进行赋值或取值的操作被称为”元素的访问“
- 访问元素时，需要使用“下标”（从0开始，依次+1，自动生成）
- 访问的语法：数组名[下标]；// 例如存 a [0]=10 ;取：a [0];
数组的下标
- 有效下标范围：0-数组长度-1
- 访问无效下标，会导致数组下标越界
数组的遍历

public class TestVisitArray{

public static void main(String[] args){
```
int [] a = new int [5];
```
a[0]=5;
a[1]=3;
a[2]=4;
a[3]=7;
a[4]=10;
for( int i = 0 ; i<a.length;i++){
System.out.println(a[i]);
}
}

}
- 遍历：从头至尾，逐一对数组的每个元素进行访问
- 数组名 .length 可动态获得数组长度
- 使用循环变量 “i” 充当下标，逐一访问数组中的每个元素
数组的默认值

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

int []a = new int[5];

for(int i =0; i<5;i++){
System.out.println(a[i]);
//在没有为数组元素赋值的情况下，依旧可以正确访问。
}
}

}
- 数组的默认值：整数 0；小数 0.0 字符 \u00000 布尔 false 其他 null;
数组的扩容
- 创建数组时，必须显示指定长度，并在创建之后不可更改长度
- 扩容的思路：
  - 创建大于原数组的新数组
  - 将原数组中的元素依次复制到新数组中
复制的方式
- 循环将原数组中所有元素逐一赋值给新数组
- System.arraycopy (原数组，原数组起始，新数组，新数组起始，长度)
- java.util.Arrays.copyOf(原数组，新长度)；//返回带有原值新数组
地址的替换
- 数组作为引用类型之一，其变量中存储的是数组的地址
- 完成元素复制后，需将新数组地址，赋值给原变量进行替换
数组类型的参数

public class TestArrayParameter{

public static void main(String[] args ){
int [] nums ={111,222,333,444,555};
printArray(nums);

}
public static void printArray(int [] oneArray){

for(int i= 0;i<oneArray.length;i++){
System.out.println(oneArray[i]);

}

}
}
- 方法调用时，将nums 中的地址赋值给oneArray,此时二者指向同一个数组
可变长参数

public class TestArrayParameter{

public static void main(String[] args ){

}
public static void printArray(int … oneArray){
for (int i =0;i<oneArray.length;i++){

System.out.println(oneArray[i]);
}

}

}
- 概念：可接收多个同类型实参，个数不限，使用方式与数组相同
- 语法：数据类型、、、、、形参名 //必须定义在形参列表的最后，且只能有一个
数组的排序
- 冒泡排序：相邻的两个数值比较大小，互换位置
- 选择排序：固定值与其他值依次比较大小，互换位置
- JDK排序：java.util.Arrays.sort(数组名);// JDK提供（升序）
二维数组
- 概念：一维数组中的一堆数组，数组中的元素，还是数组
- 当查找excle 中的某个单元格时，需要两个下标配，n代表行，m 代表列二维数组相当于一个多行多列的表格
- 查找X表中的“B3”单元格二维数组的语法为 x[3][B]行下标在前，列下标在后
二维数组的赋值

public class Test2DArray{

public static void main(String[] args){
```
  int [] [] array = new int [3][5];
  array[0][0] =10;
  array[0][3]=20;
  array[1][1]=30;
  array[1][2]=40;
  array[2][4] =50;
```
}

}
- 使用双下标访问二维数组中的元素，第一个下标代表：行号（高维下标）,第二个下标代表：列号（低维下标）
二维数组的内存分配

erwei
- 高维数组中的每一个元素，保存了低维数组的地址。访问array[0] 等价于在访问0x0000A111
二维数组的访问

public class Test2DArray{
public static void main(Sring[] args{
int [] [] array = new int [3][5];
array[0][0]= 10;
array[0][3]=20;
array[1][1]= 30;
array[1][2]=40;
array[2][4] =50;
for(int i = 0; i<array.length;i++){
for(int j =0;j<array[i].length;j++){

System.out.println();

}
System.out.prinltn();
}

}

}
- 访问低维长度 array[0].length 首个低维数组的长度
- 访问低维数组元素；array[0][0] 首个低维数组的首个元素

讲函数的调用

数组的声明与赋值

思维学习总结思维导图

PS_DaPa微信公众号《爱编码程序员》

发布了32 篇原创文章 · 获赞 9 · 访问量 3148

私信关注

java EE学习总结----第二周《包含思维导图》

第二周 2.10-2.16

Day6

循环

Day7

break和continue的程序训练

断点

函数

Day8

函数参数

返回值和返回值类型

Day9

多级调用

无穷递归

注意： exception in thread “main” java.lang.StackOverFlowError 内存溢出

递归的概念：实际的开发中，递归可以解决具有机油规律的特定问题

递归的应用场景： 1 、当需要解决问题可以拆开若干个小问题，大小问题的解决方法相同 2、有固定规律，函数中个，自己调用自己

如何正确使用递归：设置有效的出口条件，避免无穷递归

循环阶乘的例子

注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归的实现方式更为简单

Day10

数组

讲函数的调用

数组的声明与赋值

猜你喜欢

java EE学习总结----第二周 《包含思维导图》

第二周 2.10-2.16

Day6

循环

Day7

break和continue的程序训练

断点

函数

Day8

函数参数

返回值和返回值类型

Day9

多级调用

无穷递归

注意： exception in thread “main” java.lang.StackOverFlowError 内存溢出

递归的概念：实际的开发中， 递归可以解决具有机油规律的特定问题

递归的应用场景： 1 、当需要解决问题可以拆开若干个小问题，大小问题的解决方法相同 2、 有固定规律，函数中个，自己调用 自己

如何正确使用递归：设置有效的出口条件，避免无穷递归

循环阶乘的例子

注意：所有能以递归解决的问题，循环都可以解决。当解决复杂问题时，递归的实现方式更为简单

Day10

数组

讲函数的调用

数组的声明与赋值

猜你喜欢

java EE学习总结----第二周《包含思维导图》

递归的概念：实际的开发中，递归可以解决具有机油规律的特定问题

递归的应用场景： 1 、当需要解决问题可以拆开若干个小问题，大小问题的解决方法相同 2、有固定规律，函数中个，自己调用自己