java实训第二天

分支

程序的执行流程，分为三种；分别是：顺序，分支，循环

if分支

    if语句块的基本语法：
    if(逻辑表达式){
      //语句块
    }
    /**
       先写if，再写（） 再写花括号{}
    **/
    逻辑表达式：
    1 > 2  false
 if分支一共有三个基本的形式：
  第一种： if(逻辑表达式){
            语句块
           }
           执行逻辑：如果逻辑表达式运算的结果为true,那么就执行语句块的值，否则不执行语句块的值。
  第二种: if(逻辑表达式){
            语句块1;
         }else{
            语句块2;
        }
        执行逻辑： 逻辑表达式的运算结果为true,那么就执行语句块的1，否则执行语句块2;
 第三种形式:
       if(逻辑表达式1){
              语句块1;
         }else if(逻辑表达式2){
             语句块2;
         }.....
         else if(逻辑表达式n){
            语句块n;
         }else{
            语句块n+1;
          }
        执行流程：执行逻辑表达式1到n，判单1到n对应的逻辑表达式运算的结果是否为true，如果为true,那么执行相应的语句块从而结束分支，如果一个逻辑表达式都不满足，执行else
        对应的语句块n+1;

swich分支

      语法的基本格式：
        switch（表达式）{
             case 值1:
                 语句块1；
                 break;
                  case 值2:
                 语句块2；
                 。。。。。。
                 break; case 值n:
                 语句块n；
                 break;
                 default:
                    默认语句块
         }
         执行流程：将表达式运算的结果依次和每一个case的值比较，如果个相等就执行对应
         case语句块，如果不相等则执行默认语句块。
           注意一点：表达式的值的类型只能是 整型，字符型以及String类型（JDK1.7以上版本支持）

循环

 Java语言里面的循环一共分为三种，第一种 while循环  do-while循环   for循环

while循环的执行步骤

1. 先判断循环的条件
2. 条件的运算结果为true
3. 执行循环体里面的语句库
4. 再回到循环条件
5. 再次判断，如果为循环条件的运算结果为false，则结束循环，否则执行步骤3，步骤4.
   
   
   注意：在使用循环的时候一定要避免死循环的出现，死循环出现的条件是条件表达式的运算结果一直为true.
   循环的注意事项：
   循环一开始应该有一个初始化状态的变量，这个变量必须参与bool表达式运算，如果成功的执行循环体，该变量的值应该要做更新操作，否则可能会出现死循环的问题。

循环里面使用break和continue关键字

   break：如果break关键字出现在循环体里面，表示结束该循环，该循环不会在被执行
   continue: 如果continue关键字出现在循环体里面，表示结束本次的循环，程序会继续下一次循环（程序会马上跑到循环条件去再次判断是否执行循环）

do-while循环

do-while循环的执行流程如下两个图所示：

程序一开始会去执行语句块的语句，然后判断循环条件，如果循环条件的表达式值为true的时候，那么会去再次的执行语句块，直到循环条件的值为false为止。
注意：while 循环和do-while循环的区别
while 首先是判断条件表达式的值，再判断是否需要执行语句块，而对于do-while来说，会先去执行语句块的逻辑，再去判断循环条件；do-while与while循环最大的区别是 无论循环条件的值是否是true，语句块都会至少被执行一次。

for循环

比较while  和 do-while循环会发现，每一次的更新的初始化变量都是在循环以外定义的，在有些实际的业务中，需要确定每次循环的次数；这种需求的刚好满足for的需求。

for循环的格式

    for(表达式1;表达式2(逻辑表达式);表达式3){
         语句块;
   }
    执行逻辑：
    1、先执行表达式1;
    2、执行表达式2（逻辑表达式），如果表达式2的值为true,那么语句块将会被执行，否则退出循环。
    3、执行语句块；
    4、执行表达式3；
    5、执行表达式2；
    6、重复执行步骤2到6直到表达式2的值为false为止
    
   注意：  表达式1只会被执行一次。表达式2是一个逻辑表达式，该表达式运算的结果只有两个值可选，分别是true或者是false.

   1、使用for循环来求一个数的阶乘.
     执行逻辑
   2、使用for循环求1到n的和
   3、使用for循环打印九九乘法表

多重循环问题（循环的嵌套）

多重循环需要注意的是：外层循环执行一次，内层循环执行多次。

 /**
         * 使用for循环打印九九乘法表
         *  步骤：
         *  应该需要使用到循环嵌套
         *  第一个循环控制行
         *  第二个循环控制列
         *  循环体将打印 行和列的乘积，如果打印到行的结尾应该
         *  输出一个回车(换行)
         */
        //第一个for循环控制行变化
        for (int i = 1; i <= 9 ; i++) {
            //第二个for循环控制列

            for (int j = 1; j <= i ; j++) {

                /**
                 * 注意 println和print的区别
                 * 前者输出会换行 而后者不会
                 */
                System.out.print(j+"x"+i+"="+i*j+"\t");
            }
            System.out.println();
        }

循环小节

   java语言里面的循环类型一共有3种，分别是 while循环，do-while循环， for循环，while和do while循环有相似之处就是循环的初始化变量需要在循环外面定义，不同点是，while一开始执行的时候直接判断逻辑表达式，如果逻辑表达式的值为true，才去执行循环体，否则结束while循环；而do-while循环则至少执行一次循环体之后才去判断逻辑表达式进而判断是否要继续下一次循环。而for则是一个确定次数的循环，可以明确的直到循环是第几次（用于那些循环次数已经确定的业务问题）。
   循环体里面出现break和continue关键字的作用，break用于结束整个循环，而continue用于结束本次循环，直接跳到逻辑表达式部分，通过执行逻辑表达式判断是否继续下一次循环（也就是结束本次的循环，重新开始下一次循环）。
三种循环的死循（一定要避免 但是有些时候某些业务问题需要使用死循才能解决。）
   while循环的死循环：

  while(true){
     语句块
  }

do-while循环的死循环：

  do{
     语句块 
  }while(true); 

for循环的死循环

  for(;;){
     语句块
  }
   //可以讲for循环拆分
   int i = 0;
        for (; i <100 ; ) {
            System.out.println("hello");
            i++;
        }

数组

数组的定义：相同数据类型的元素的集合（是一种简单的数据结构），可以存放多个数据类型相同的变量。
数组的定义：

1. List item

比如：double类型的数组
double[] arrs = new double[10];
int [] arrs = new int[10];
byte[] bs= new byte[1024];
申明数组的7步：
1、确定数据类型
2、写上[]
3、确定数组名
4、写上=
5、写上new关键字
6、写上数据类型
7、写上申明的数组的长度
long[] ls = new long[20];
/**
* 申明数组的同时为数组指定初始值
* 数据类型[] 数组名称 = {初始值1,初始值2,初始值3.。。};
*/
double[] ds = {1,3,6,7,8,9};
System.out.println(ds[0]);

数组的初始哈

 由于数组类型主要有基本数据类型和引用数组类型
 如果是基本数据类型的时候，当没有显示初始化数组的时候，默认的初始化规则如下：
 byte类型      short     int    long    float   double    char    boolean
 0                   0          0       0       0.0      o.o          “”       false
 如果是引用数据类型初始化为 nul

数组的访问

  数组的访问是按照下标进行访问的，下标是重0开始一直到数组的长度-1结束
  数组的长度：表示数组元素的个数，可以使用length属性表示
  比如访问第三个元素：  数组名[2]

数组的遍历

  主要使用for循环进行遍历

数组的两大API 实现数组的复制与扩容

  ![在这里插入图片描述](https://img-blog.csdnimg.cn/2020022916242216.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMDk4MjYz,size_16,color_FFFFFF,t_70)
  ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200229162436510.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMDk4MjYz,size_16,color_FFFFFF,t_70)

数组的排序

  Aarrys类封装了一个排序方法叫做sort ，可以调用该方法进行排序（从小到大）
  可以编写自己的排序算法：
  冒泡排序

 //第一层循环是用来比较排序的轮数
	    for (int i = 0; i < ds.length-1; i++) {
			//第二层用来比较排序的次数
	    	for (int j = 0; j < ds.length-i-1; j++) {
				if(ds[j]<ds[j+1]) {
				     double tmp = ds[j];
				     ds[j] = ds[j+1];
				     ds[j+1] = tmp;
				}
			}
		}
	  System.out.println("-------------排序完毕--------------");
	  for (int i = 0; i < ds.length; i++) {
			  System.out.print(ds[i]+"\t"); 
			  }

  选择排序
  快排
  二叉排序
  希尔排序
  。。。。。

方法

方法的定义：方法也叫做函数，只的是某一个特定业务的代码块的集合。使用方法可以使得代码有良好的可读性，而且代码可以得到良好的复用。

方法的申明

   1、方法的修饰符
        public static 
   2、方法的返回值类型
           基本数据类型
           引用用数据类型
           void类型
   3、 方法的参数表
          参数表，如果方法有多个参数，那么各个参数之间必须使用”，“号隔开
   4、 方法体
         方法的具体实现

方法的调用

    如果方法的修饰符是 public static 表示该方法是一个静态方法，静态方法可以通过类名.方法名(参数表)这里的参数表必须要传入具体的参数，这个过程叫做实参初始化形参，如果方法是在本类调用，那么
    可以省略类名，直接通过方法名调用