黑马程序员--Java语言基础二

 Java语言基础

知识提纲：

1，判断结构（if）

2，选择结构（switch）

3，循环结构（for,while,do-while）

4，break,continue

5，函数（重载）

6，数组（排序，折半查找）

 

1、程序流程控制

        也称语句，主要有：判断结构、选择结构和循环结构。

1.1、 判断结构——if

         if语句的三种格式：

            1)  if(条件表达式)

                 {

                        执行语句；

                 }

            2)  if(条件表达式)

                {

                       执行语句；

                }

                else

                {

                         执行语句；

                }

            3)  if(条件表达式)

                {

                        执行语句；

                }

               else  if (条件表达式)

               {

                       执行语句 

               }

                ……

               else

              {

                       执行语句；

              }

if语句特点：

（1），每一种格式都是单条语句。

（2），第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以简化if else代码。

 （3），条件表达式无论写成什么样子，最终的结果不是true就是 false。

1.2、 选择结构——switch

        switch语句格式：

                switch(表达式)

                {

                       case取值1:

                            执行语句；

                              break；

                       case取值2:

                            执行语句；

                              break；

                       …...

                      default:

                            执行语句；

                             break；

                }

switch语句特点：

（1），switch语句选择的类型只有四种：byte，short，int，char。

（2），case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。

（3），结束switch语句的两种情况：1、遇到break结束；2、执行到switch结尾结束。

（4），如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

注：JDK1.5以后可以接收枚举类型，JDK1.7以后可以接收字符串。

        if和switch语句很像。具体什么场景下，应用哪个语句呢？

如果判断的具体数值不多，而且符合byte  short  int  char这四种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

1.3、 循环结构——while，do while，for

        while语句格式：

            while(条件表达式)

             {

                 执行语句；

             }

        do while语句格式：

             do

             {

                 执行语句；

             }while(条件表达式);

while和do while的区别：

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

        do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。

简单一句话：do while：无论条件是否满足，循环体至少执行一次。

        for语句格式：

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

            {

                 执行语句；

            }

说明：

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

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

        （3），最简单无限循环格式：while(true){}, for(;;){}，对于for来讲，不写条件表达式默认就是ture。无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。

        什么时候使用循环结构？

        当要对某些语句执行很多次时，就使用循环结构。

循环注意：一定要明确哪些语句需要参与循环，哪些不需要。

1.4、其他流程控制语句——break，continue

        break（跳出）语句：应用范围：选择结构和循环结构。

        continue（继续）语句：应用于循环结构。

注：

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

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

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

        4，标号的出现，可以让这两个语句作用于指定的范围。只能用于循环结构1

练习：打印九九乘法表：

/*
打印九九乘法表
思路：嵌套循环，大圈套小圈
1,由外循环控制横坐标，内循环控制纵坐标
2，因为1(1) 2(1,2) 3(1,2,3) 4(1,2,3,4)...
所以由前一个可以控制后一个的大小
*/
class  JiuJiu
{
 public static void main(String[] args)
 {
  for (int x = 1; x<=9; x++)  
  {
   for (int y=1; y<=x; y++)
   {
    System.out.print(y+"*"+x+"="+y*x+"\t");  //输出，\t制表符，相当于tab
   }
   System.out.println(); //换行
  }
 }
}

 

/*
绘制如下矩形
 *****
 *    *
 *    *
 *****
分析：
1,通过观察发现*都是在x y方向上第0行和第length-1上
*/
class  JuXing
{
 public static void main(String[] args)
 {
  int chang =8,kuan =10;
  
  if (chang<2||kuan<2) //长或宽小于2没法设置
  {
   System.out.println("无效的长或宽");
  }
  else
  {
   mankRec(chang,kuan);
  }
 }

 public static void mankRec(int chang ,int kuan)
 {
  for (int i=0; i<chang; i++ )
  {
   for (int j=0; j<kuan ; j++)
   {
    if (i ==0 || i==chang-1 || j==0 || j==kuan-1) //在边界位置
     System.out.print("*");
    else
     System.out.print(" ");
   }
   System.out.println();
  }
 }
}

 

2，函数

        定义：定义在类中的具有特定功能的一段独立小程序。也称方法。

    格式：

        修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）

        {

                    执行语句；

                      return返回值；

            }

  其中：

        返回值类型：函数运行后的结果的数据类型。

        参数类型：是形式参数的数据类型。

        形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

        实际参数：传递给形式参数的具体数值。

          return：用于结束函数。

        返回值：该值会返回给调用者。

    特点：

• 定义函数可以将功能代码进行封装，便于对该功能进行复用。
• 函数只有被调用才会被执行。
• 函数的出现提高了代码的复用性。
• 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：

        1) 函数中只能调用函数，不可以在函数内部定义函数。

        2) 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

如何定义一个函数？

• 明确要定义的功能最后的结果是什么。
• 明确在定义该功能的过程中，是否需要未知内容参与运算。
  (就是看该函数功能是否有返回值，是否需要传递参数)
   

2.1函数的一个重要特性——重载(override)

     概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数列表的个数或者参数类型不同即可。

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

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

     示例：

              //返回两个整数的和

              int add(int x,int y){return x+y;}

              //返回三个整数的和

              int add(int x,int y,int z){returnx+y+z;}

              //返回两个小数的和

              double add(double x,double y){return x+y;}

什么时候用到重载？

     当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示起功能，方便阅读，而通过参数列表的不同来区分多个同名函数。,

3，数组

概念：

        同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

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

3.1，一维数组的格式

        格式1：元素类型 [ ]数组名 = new元素类型 [元素个数或数组长度] ;

                 如： int []  arr = new int [3];也可以写成： int arr[] = new int[3];

        格式2：元素类型 []数组名 = new元素类型 [ ]{元素1,元素2,…};

                  如： int []  arr = new int []{1,2,3,4,5};

        还有一种简写的静态初始化格式：如： int [] arr={1,2,3,4,5};

        其中：new是用来在堆内存中产生一个容器实体。

数组也被称为引用数据类型。在内存中的堆内存中。

 

注：1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

        2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

内存小知识：

        Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

        栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

        堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。

                      2、每一个实体都有内存地址值。

                      3、实体中的变量都有默认初始化值。

                      4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

3.2，数组操作常见问题

    1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例：

             int[] arr = new int[2];

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

            访问到了数组中的不存在的脚标时发生。

    2、空指针异常(NullPointerException)。例：

            int[]arr = null;

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

           arr引用没有指向实体，却在操作实体中的元素时。

 3.3，数组中的数组

        也称多维数组，这里我们主要讲二维数组。

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

        解释：以上格式表示定义了名称为arr的二维数组。有3个一维数组，每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78。

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

        注：此种格式中每个一维数组都是默认初始化值null。

       格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。

注：一种特殊定义写法：int[]x,y[]; x是一维数组，y是二维数组

 

4，数组常见操作

1、 数组排序：

        常见的排序方式：冒泡排序和选择排序。在Java已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

下面是选择和冒泡两种排序方式的程序：

/*
排序方法：
有一个含有多个元素的整型数组，按照从大到小的顺序排列打印出来

1，选择排序法：使用第一个元素和后面的元素一一相比较，大的放在第一位
               使用第二个元素和后面的元素一一相比较，大的放在第二位
      。。。
      直到排出最小的哪位

2,冒泡排序法：某一个与相邻的数字比较，如果前一个比后一个小，交换，
              第一轮比较arr.length - 1 ,求出最小值，在最后面
     第二轮比较arr.length - 1 ,求出最小值，倒数第二位
     第三轮比较arr.length - 1 ,求出最小值，倒数第三位
     。。。
     最后求出最大值在第一位
*/
class  PaiXu
{
 public static void main(String[] args)
 {
  int[] arr = new int[]{12,58,65,41,25,9,87,31};
  print(arr);

  //xuanZhen(arr);
  maoPao(arr);
 }

 public static void maoPao(int[] arr) //冒泡排序
 {
  for (int x=arr.length-1; x>0; x--)
  {
   for (int y=0; y<x; y++)
   {
    if(arr[y]<arr[y+1])
     swp(arr,y,y+1);
   }
  }
  print(arr);
 }

 public static void swp(int[] arr,int x,int y) //函数用于数组元素的互换
 {
  int temp=arr[x];
  arr[x]=arr[y];
  arr[y]=temp;
 }

 public static void print(int[] arr)  //函数用于打印数组元素
 {
  System.out.print("[");
  for (int s =0; s< arr.length; s++)
  {
   if (s == arr.length-1)
   {
    System.out.print(arr[s]+"]");
   }
   else
   System.out.print(arr[s]+",");
   
  }
  System.out.println();
 }

 public static void xuanZhen(int[] arr) //选择排序
 {
  for (int x=0; x<arr.length; x++)
  {
   for (int y=x+1; y<arr.length; y++)
   {
    if (arr[x]<arr[y])
    {
     swp(arr,x,y);
    }
   }
  }
  print(arr);
 }
}

2、需求：二分查找法，从一组有序的数组元素中查找其中是否有数字5，使用二分查找法;

思路：二分查找法是从中间开始查找，可以定义第一个元素（mix角标为0），后最后一个元素（max角标为数组长度-1）
开始查找的数据是中间的数据(mid=(min+max)/2 ), 然后是把中间的数据和要比较数据进行比较，

首先判断中间值是否等于比较数，等于的话就返回中间值

不等于：有两种情况，
 中间数据大于比较数据，那么max就可以设置为中间值-1，再得出新的中间值，
 中间数据小于比较数据，min就等于mid加1，得出新的中间值
第三种情况：如果数组中没有要比较的数字呢，怎么办，返回-1；
*/
class  JavaGrammarBase
{
 public static void main(String[] args)
 {
  int[] arr = {2,5,9,11,18,24,32};
  int  key=5;
  int index = halfSeach(arr,key); //返回的值是第几个角标上的值和key相等
  if(index!= -1)
   System.out.println("和key相等的数字是第"+index+"个，他的大小是："+arr[index]);
  else
   System.out.println("该数组中没有该元素");
 }

 public static int halfSeach(int[] arr,int key)
 {
  int min = 0;
  int max= arr.length-1;
  int mid = (min+max)/2;

  while (arr[mid]!=key)
  {
   if(min>max)
    return -1；
   else if (arr[mid]>key)
    max=mid-1;
   else
    min=mid+1;
   mid=(min+max)/2; //折半操作
  }
  return mid;
 }
}