黑马程序员——java流程控制与函数

                                                  ------- android培训、java培训、期待与您交流！ ----------

 

Never saydie ! try ! try ! try !  -- 永不言败,努力,努力,再努力!

<1> 判断结构 if

语句格式分三种:

 

1.    if(条件表达式) {

执行语句;

}

举例:

           int x = 19;

           if (x >= 18){

                      System.out.println("可以浏览本网站");

           }

            System.out.println("完了");

 

2.    第二种:if(条件表达式){

         执行语句；    

       }else{          

                执行语句；    

       }

            举例:

             int x = 1;

                   if (x == 1){

                            System.out.println("男厕所欢迎您");

                   }else {

                            System.out.println("女厕所欢迎您");

                   }

 

3.      第三种:if(条件表达式){

              执行语句；

       }else if (条件表达式){

              执行语句；

       }else{

              执行语句；

       }

           举例:

           int x = 1;

           if (x == 1){

                    System.out.println("男厕所欢迎您");

           }else if(x == 0){

                    System.out.println("女厕所欢迎您");

           }else {

                    System.out.println("无法识别您的性别");

           }

<2> 选择结构 switch

         格式:

         switch(表达式){

         case 表达式里对应的值:

                   执行语句;

         break;

         case 表达式里对应的值:

                   执行语句;

         break;

         ......

         default:

                   执行语句;

         break;//最后一句的break可写可不写,因为程序已经执行到了末尾

         }

 

         举例:

         Stringname = "丽丽";

                   Stringgender = "女士";

                   switch(gender){

                   case"先生":

                            System.out.println(name+ "是一位" + gender + "喜欢吃饭睡觉打dota");

                   break;

                   case"女士":

                            System.out.println(name+ "是一位" + gender + "逛街购物美容");

                   break;

                   default:

                            System.out.println(name+ "是一位" + gender + "打雌性激素保持美貌容颜");

                  

                   }

         重点:switch 结束只有两种情况

         1,当程序执行过程中遇到了break

         2,当程序执行到了末尾处

         应用 switch需要注意的两个细节

 

         1,      当switch表达式的值与其中一个case匹配的时候,这个case里没有写break;语句,那么程序会继续执行下个case里

                  的执行语句,不会再对case值进行判断,应用于当几个case里的值所要执行的语句都一样的时候,我们可以不写break

 

2,       当我们把 default 不是写在最后,default 里面还没有写break的是时候,switch里的表达式与各个case里

的值都部匹配的时候,上面两个条件同时满足的话,程序在default里执行完了还会再去执行case里的语句

 

例如:

int x = 3;

switch (x){

case 4:

           System.out.print("a");

break;

default:

           System.out.print("b");

//这里没有写break,程序不再判断下个case里面的值会继续向下执行

case 5:

           System.out.print("c");

case 6:

           System.out.print("d");

break;//当程序执行到这里遇到了break就结束了

case 7:

           System.out.print("e");

}//此程序输出结果应该是:bc

 

<3> 循环结构

代表语句：while ，do while ，for

 

1.               while语句：

        while (条件表达式)

       {

          执行语句;

        }

例如:

                   intx = 3;

                   while(x<6){

                            System.out.println("x="+x);//循环体

                            x++;//用x自增来控制循环次数

  

   特点：先判断条件，只有条件满足时才执行循环体。

 

2.      do while语句：

 

   do

   {

    执行语句;

   }while(条件表达式);

例如:

                   intx = 3;

                   do{

                            System.out.println("x="+x);//循环体

                            x++;//用x自增来控制循环次数

                   }

                   while(x<6);

  

   特点：无论条件表达式是否成立，循环都先执行一次。

 

3.       for语句：

 

   for(初始化表达式；循环条件表达式；循环后的操作表达式)

   {

    执行语句;

   }

例如:

         for(intx=0; x<10; x++){

                   System.out.println("x="+x);

 

特点：初始化表达式只读一次，判断循环条件为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件重复,到条件不满足为止。

 

4.  for 的嵌套循环,建议做题的时候就弄个双层嵌套就可以,不要弄太多层,影响效率

         格式:

         for(初始化表达式；循环条件表达式；循环后的操作表达式){//这是外层循环

                   执行语句；(循环体)

                   //下面是内层循环

                   for(初始化表达式；循环条件表达式；循环后的操作表达式){

                   执行语句；(循环体)

                   }

         }

例如:

         for (int x=1;x < 6;x++ ){

                   for(int y=1; y<6; y++){

                            System.out.print("*");

                   }

                   System.out.println();

         }

 

注意：

 

(1) for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。

 

                  (2) while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是,在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。

 

                  (3 ) 最简单无限循环格式：while(true), for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

 

 

 

5、break与continue语句：

 

        (1)break（跳出）:应用于选择结构和循环结构。跳出循环体继续执行下面程序。

 

              (2)continue（继续）:应用于循环结构。结束本次循环继续下次循环。

注意：

 

(1)这两个语句离开应用范围，存在是没有意义的。

 

(2)这个两个语句单独存在下面都不可以有语句，因为执行不到.

 

(3)continue语句是结束本次循环继续下次循环。

 

(4)标号的出现，可以让这两个语句作用于指定的范围。

 

<4> 函数   

 

(1)    函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。

 

          (2)函数的格式

                   修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) {

                            执行语句;

                            return返回值;

                   }

 

                   A：修饰符 后面会重点讲。publicstatic

                   B：返回值类型 这个特定的功能完成后，需要返回一个结果。这个地方就是返回结果的类型。

                   C：函数名 为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。

                   D：参数类型 形式参数的数据类型

                            **：形式参数 自定义的接收方

                            **：实际参数 发出方

                   E：执行语句 那么这个语句是由多条语句组成。

                   F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字return带回。

 

         (3)函数的特点

                   A：函数只有被调用后，才执行。

                   B：void 表示没有返回。在这个函数的结尾可以不写return。

                            **其实jvm会自动的结尾处加上return;

 

         (4)如果定义自己的函数 两个明确

                   A：明确该功能的结果 其实就是该功能的返回类型。

                   B：明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。‘

                                         明确未知内容的类型和个数。

 

         (5)函数的重载

                   A：函数名相同，参数列表不同。      

                            **参数类型不同。

                            **参数个数不同。

                   B：特点：与返回值类型无关，只看参数列表。

                   C：好处：便于阅读，优化程序设计。

 

<5> 数组

(1)同一种类型数据的集合。其实数组就是一个容器。

           A：只要是容器，就得重点掌握。

(2)数组的好处

           A：可以自动给数组中的元素从0开始编号，方便操作这些元素。

(3)数组的定义格式

           A：当不明确数组中的元素时

                    **举例 int[] arr= new int[3];

           B：当明确数组中的元素时

                    **举例 int[] arr= new int[]{1,2,3,4,5};

(4)什么时候使用数组？

           A：当要操作的数据是多个的时候，你就得想着先把这些数据用数组进行存储。

(5)内存图

           A：栈

                    **存储的是局部变量(在函数中定义的变量)。

                    **变量被使用完后，立即自动释放。

           B：堆

                    **存储的是实体(数组和对象)。

                    **实体：new出来的东西，可以存放很多数据的东西。

                             ***class定义一个类。

                    **堆内存数据的特点

                             ***每个实体都有内存地址

                             ***堆内存中的变量都有默认初始化值

                                       ****int--> 0

                                       ****double--> 0.0

                                       ****boolean--> false

                                       ****char--> '\u0000' 空字符，unicode编码。

                             ***当实体不在被使用的时候，会在jvm空闲的时候，

                                通过java垃圾回收机制使其自动释放。

           C：方法区 后面讲。

           D：本地方法区 调用是Windows系统底层资源，我们也不用考虑。

           E：寄存器 和CPU相关。我们不用考虑。

(6)操作数组最常见的问题

           A：当你访问到数组中的最后一个元素时，还想继续访问，这个时候，会发生角标越界异常。

                    **ArrayIndexOutOfBoundsException

                    **举例 int[] arr= new int[3];

                           System.out.println(arr[3]);

           B：当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。

                    **NullPointerException

                    **举例 int[] arr= new int[3];

                           arr = null;

                           System.out.println(arr[1]);

(7)常见的数组的操作

           记住：对数组的操作，一定要从角标下手。

           A：遍历操作

                    **数组的属性：length 数组的长度。

                    **格式：数组名.length

           for (int x=0;x < arr.length ;x++){

                    System.out.println("arr["+x+"]="+arr[x]);

           }

           B：获取最值

                    **获取最大值

                    public static intgetMax(int[] arr){

                             int max = arr[0];

                            

                             //i从1开始，因为第一个数不用跟自己比

                             for(int x=1;x<arr.length; x++) {

                                       if(arr[x]>max){

                                                max= arr[x];

                                       }

                             }

 

                             return max;

                    }

 

                    **获取最小值

                    public static intgetMin(int[] arr) {

                             int min = arr[0];

                            

                             //i从1开始，因为第一个数不用跟自己比

                             for(int i=1;i<arr.length; i++) {

                                       if(arr[i]<min){

                                                min= arr[i];

                                       }

                             }

 

                             return min;

                    }

 

C：排序

                    **选择排序

                    原理：如果拿0角标上的元素依次和后面的元素进行比较，

                      第一次内循环结束后，最小值出现在了0角标位置。

                   

                    就比如我们打印三角形:

                    ****

                    ***

                    **

                    *

                    代码实现:

                    public static voidselectSort(int[] arr){

                             //i<arr.length-1n个数两两比，n-1次就能获得最值。

                             for(int i=0;i<arr.length-1; i++){

                                       //0角标元素没必要和自己比，所以j从1开始。

                                       //发现j为了不重复比较，总是要比i大1，所以j从i+1开始

                                       for(intj=i+1; j<arr.length; j++){

                                                if(arr[j]<arr[i]){

                                                         inttemp = arr[i];

                                                         arr[i]= arr[j];

                                                         arr[j]= temp;

                                                }

                                       }

                             }

                    }

 

                    **冒泡排序

                    原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。

 

                    public static voidbubbleSort(int[] arr){

                             //i<arr.length-1n个数两两比，n-1次就能获得最值。

                             for(int i=0;i<arr.length-1; i++){

                                       //为了防止角标越界，j<arr.length-1

                                       //为了减少比较次数，j<arr.length-1-i

                                       for(intj=0; j<arr.length-1-i; j++){

                                                if(arr[j]>arr[j+1]){

                                                         inttemp = arr[j];

                                                         arr[j]= arr[j+1];

                                                         arr[j+1]= temp;

                                                }

                                       }

                             }

                    }

           D：传递参数

                    **调用的时候，传递是基本类型的值的时候，形参改变对实参没有任何影响。

                    **调用的时候，传递是引用类型的地址值的时候，形参改变对实参有直接影响。

数组初始化过程

<1> 主函数进栈,然后在main()中有一个数组的引用arr

<2> 在堆内存中开辟空间，

<3> 在堆内存中建立数组对象，并进行默认初始化

<4> 对属性进行初始化,分配内存地址值

         <5> 将内存地址赋给栈内存中的p变量

 

<6> 二维数组

(1)int[][] arr = new int[3][2];

                   A：定义了名称为arr的二维数组

                   B：二维数组中有3个一维数组

                   C：每一个一维数组中有2个元素

                   D：一维数组的名称分别为arr[0],arr[1], arr[2]

                   arr:二维数组名

                   arr[1]:二维数组中的第二个数组名

                   arr[1][1]:二维数组中的第二个数组的第二个元素

                   E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1]= 78;

         (2)格式2：int[][] arr= new int[3][];

                   A:二维数组中有3个一维数组

                   B:每个一维数组都是默认初始化值null

                   C:可以对这个三个一维数组分别进行初始化

                     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}};

                   A：二维数组有3个一维数组。

                   B：第一个一维数组有3个元素

                      第二个一维数组有2个元素

                      第三个一维数组有4个元素

         (4)二维数组的遍历

                   publicstatic void printArray2(int[][] arr2)

                   {

                            for(inti=0; i<arr2.length; i++){

                                     for(intj=0; j<arr2[i].length; j++){

                                               System.out.print(arr2[i][j]+"");

                                     }

                                     System.out.println();

                            }

                   }

                                                               ------- android培训、java培训、期待与您交流！ ----------