黑马程序员->基础部分 （2--语句，函数，数组

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

 

六6------语句。程序流程控制，6.1，判断结构，6.2，选择结构，6.3，循环结构。
  6.1.. if语句，三种格式，*/

6.1.1 if(条件表达式)            6.1.2. if (条件表达式)          6.1.3 if (条件表达式)
           {                                            {                                             {
              执行语句;                               执行语句;                            执行语句;
           }                                             }                                            }
         else                                       else if (条件表达式） 
          {                                            {
             执行语句;                              执行语句;
          }                                            }
                                                              .....
          else
         {
               执行语句;
          }
//      6.2...选择结构，switch语句，一种格式
// 2012年5月4日22:23:34
 switch(表达式)
 {
  case 取值1：
   执行语句;    //if和switch语句很像。如判断的具体数值不多，而且符合byte，short，int，char这四种类型。用switch。
  break;           //虽然两个语句都可以使用，建议使用switch语句，因为效率高。
  case 取值2：    
   执行语句;    //其他情况，对区间判断，对结果是boolean类型的判断，用if。if的使用范围更广。
  break;          
  .....           
  default:
   执行语句;
  break;
 }
//      6.3.....循环结构，代表语句：
6.3.1..while          6.3.2...do.while                            6.3.3...for      .....
 
  while语句表达式：      do.while语句格式:(中间没点)                for (初始化表达式; 循环条件表达式 ; 循环后的操作表达式 )
  while(条件表达式)      do.                                        {
  {                      {                                             执行语句;
   执行语句;             执行语句;                               }
  }                      }while(条件表达式);                     
 //                                                                 
//                      do while特点是条件无论是否满足，
//                      循环体至少被执行一次。

/*
1，变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句有效。
    for语句执行完毕，该变量在内存中被释放。
2，for 和 while 可以进行互换，如果需要定义循环增量，用for更为合适。
  总结： 当要对某些语句执行很多次是，就要用循环结构。
  
                            无限循环的最简单表现形式：*/
                                        for (; ; ){}                    while(true){}

 

循环一定要明确哪些语句需要参与循环，哪些不需要。
//累加思想：通过变量记录住每次变化的结果，通过循环的形式，进行累加动作。
计数器思想：通过一个变量记录住数据的状态变化，也通过循环完成。
//循环嵌套。语句嵌套形式，就是语句中还有语句。         （大圈套小圈。。）
对于打印长方形：外循环控制行数，内循环控制的是每一行的列数，也就是一行中元素的个数。

6.4.....其他流程控制语句
 6.4.1..break    语句：应用范围：选择结构和循环结构。
 6.4.2..continue 语句：应用于循环结构。
//  这两个语句离开应用范围，存在是没有意义的。这两个语句单独存在下面都不可以有语句，因为执行不到。
//  continue 语句是结束本次循环继续下次循环。标号（给循环起的名字）的出现，可以让这两个语句作用于指定的范围。

 

//  七7，函数________________________________________________________________________
2012年5月9日1:07:32

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

   函数的格式： //  修饰符 返回值类型 函数名（参数类型 形式参数1， 参数类型 形式参数2，....）
                    {
      执行语句;   如： public static void getResult(int num)
      return 返回值;           {
     }         return num * 3 + 4;
   返回值类型：函数运行后的结果的数据类型。      }
     参数类型：是形式参数的数据类型。
     形式参数；是一个变量，用于存储调用函数时传递给函数的实际参数。
  实际参数：传递给形式参数的具体数值。
   return ：用于结束函数；
    返回值：该值回返回给调用者。// 当函数运算后，没有具体的返回值时，这时返回值类型用一个特殊的关键字来标示。
                                   // 就是 void ：代表的是函数没有具体返回值的情况。
           // 当函数的返回值类型是 void 时，函数中的return 语句可以省略。
   //------------------------------------------------------------------------------------------
7.2....函数特点：
   定义函数可以将功能代码进行封装；
   便于对该功能进行复用；
   函数只有被调用才会被执行；
   函数的出现提高了代码的复用性；
   对于函数没有返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
 // 注意：函数中只能调用函数，不可以在函数内部定义函数。
 //       定义函数时，函数的结果应该返回给调用者，交由调用者处理。

7.3.....函数的应用。。如何定义一个函数？
                   1.）既然函数是一个独立的功能，那么该功能的运算结果是什么先明确。
       2.）在明确咋定义该功能的过程中是否需要未知的内容参与运算。
  两个明确：
    ..明确要定义的功能最后的结果是什么？
    ..明确在定义该功能的过程中，是否需要未知内容参与

7.4......函数的重载（overload）
               重载的概念：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
      重载的特点：与返回值无关，只看参数列表。
      重载的好处；方便与阅读，优化了参数设计。
2012年5月11日0:37:42

  public static void main(String[] args)
  {
   add(4,5);
   add(4,5,6);   
  }
  public static int add(int x,int y) //与下面定义的函数名一样，但是参数个数不一样，是重载，所以不冲突。 
  {
   return x+y;        // 什么时候定义重载呢？
  }           // 当定义的功能相同，但参与运算的未知数不同。
  public static int add(int x,int y,int z); // 那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同
  {           //来区分多个同名函数。
   return x+y+z;
  }
// 八8.数组———————————————————————————————————————————————————————————————————————————————————————————数组

8.1..........数组的概念：同一种类型数据的集合，其实数组就是一个容器。
          // 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
    格式1 ： 元素类型[] 数组名 = new 元素类型[ 元素个数或数组长度];
                     int[] arr = new int[5]; //默认初始化值为0

    格式2：  元素类型[] 数组名 = new 元素类型[]{元素，元素，.....}; //静态初始化形式
                     int[] arr = new int []{3,5,1,7};
         int[] arr = {3,5,1,7}; // 可以理解成简化形式
8.2..........// 内存结构
         java在运行时，需要在内存中的分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的
      处理数据方式和内存管理方式。
          // 栈内存
      用于存储局部变量，当数据使用完，所占空间会自动释放。
   //  堆内存
      数组和对象，通过 new 建立的实例都存放在堆内存中。   每一个实体都有内存地址值。
   实体中的变量都有默认初始化值。                      实体不再被使用，会在不确定的时间内被垃圾回收器回收。
                                                              //（方法区、本地方法区、寄存器）
2012年5月14日 02:52:41————————————————————————————————————————————————
 //例：
  class  ArrayDemo
 {
  public static void main(String[] args) //这个代码会出项两个错误；
  {  
   int[] arr = new int[3];
   arr = null;//因为这项，而会出现错误2，这个语句会使下面的打印找不到实体。
   System.out.println(arr[3]);//因为让打印的值超过数组定义的范围，这个会出现错误1.
  }
 }
  错误提示1：java.lang.ArrayIndexOutOfBoundsException: 3  操作数组时，访问到了数组中不存在的角标。
    2：java.lang.NullPointerException   空指针异常，当引用没有任何指向值为null的情况，该引用还在用于操作实体。
8.2.1.............//数组的遍历
  数组中有一个属性可以直接获取到数组元素个数。 length.
  使用方法：数组名称.length =
  遍历用 for 循环。
  int[] arr = new int[]{3,6,7,8,6565,54,7,783}; 
  for (int x=0; x<arr.length; x++)
  {
   System.out.println("arr["+x+"]="+arr[x]+";");
  }
8.2.2................//获取数组中的最值
  int[] arr ={3,5,7,12,45,8,9,1,};
  int max = arr[0];            //这里可以是int max = 0; 因为0不是作为数组元素，而是以初始化为数组中任一角标存在。
  for (int x=1; x<arr.length; x++)
  {
   if (arr[x]>max)
    max = arr[x];
  }
  System.out.println("max="+max);
选择排序 ...................................
  int[] arr ={3,1,5,7,8,9,4,11};
  for (int x=0; x<arr.length-1; x++)
  {
   for (int y=x+1; y<arr.length; y++)//选择排序，内循环结束一次，最值出现在头角标位置上。
   {
    if (arr[x]>arr[y])
    {
     int temp = arr[x];
     arr[x] = arr[y];
     arr[y] = temp;
    }
   }      
  }
  for (int x=0; x<arr.length; x++)
  {
   System.out.print(arr[x]+"; ");
  }
冒泡排序 .......................................//相邻的两个元素进行比较，如果符合条件换位。
  int[] arr = {3,5,6,1,2,8,13,7};
  for (int x=0; x<arr.length; x++)
  {
   for (int y=0; y<arr.length-x-1; y++)//-x：让每一次比较的元素减少，-1：避免比较越界。
   {
    if(arr[y]>arr[y+1]）
    {
     int temp = arr[y];
     arr[y] = arr[y+1];
     arr[y+1] = temp;
    }
   }
  }
  for (int x=0; x<arr.length; x++)
  {
   if(x!=arr.lengh-1)
   {
    System.out.print(arr[]+";");
    else
    System.out.print(arr[]);    
   }
  }
2012年5月18日22:45:21/
数组的查找..................................................
//折半查找。 提高效率，但是必须要保证该数组是有序的。
    public static int halfsearch(int[] arr,int key)
 {
  int min,max,mid;
  min = 0;
  max = arr.length-1;
  mid = (min+max)/2;
  while (arr[mid]!=key)
  {
   if (arr[mid]<key)
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   mid = (min+max)/2;
   
  }
  return mid;
 }
 //折半查找（二分查找）第二种方法，先让两头的值不二分过头，在开始循环二分。
 public static int halfsearch2(int[] arr,int key)
 {
  int min = 0,max = arr.length-1,mid;
  while (min<=max)
  {
   mid = (min+max)>>1;
   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   else
    return mid;
  }
  return -1;
 }
 public static void main(String[] args)
 {
  int[] arr ={2,4,6,8,11,13,24};
  int fuck = halfsearch2(arr,131);
  System.out.println("fuck="+fuck);
 }
数组的进制转换应用...............................................
// 查表法：将所有的元素临时存储起来，建立对应关系，每一次&15后的值作为索引区查建立好的表，就可以找对应的元素。
 public static void main(String[] args)
 {
  char[] chs ={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; //如果求二进制此处为 char[] chs ={'0','1'}; 
  //定义一个临时容器。
  char[] arr = new char[8];     //如果求二进制此处为 char[] arr = new char [32];  
  int i = -121;                
  int j = arr.length;
  while (i!=0)       //如果求八进制为 char[] chs ={'0','1','2','3','4','5','6','7'};
  {          //               char[] arr = new char [8];
   int k = i & 15; 
   arr[--j] = chs[k];
   i = i >>> 4;
  }
  System.out.println("j="+j);
  for (int x=j; x<arr.length; x++)
  {
   System.out.print(arr[x]);
  }
 }
8.2.3.......................................//二位数组

     格式1：int [][] arr = new int[3][2];                格式2：int[][] arr = new int [3][];
  // 定义了名称为arr的二维数组。         二维数组中有3个一维数组。
     二维数组中有3个一维数组。          每个一维数组都是默认初始化值null
  // 每一个一维数组中有2个元素。         可以对着三个一维数组分别进行初始化
     一维数组的名称分别为arr[0],arr[1],arr[2]      arr[0] = new int[3];
  //给第一个一维数组1角标为赋值为78的写法为：arr[0][1] = 78   arr[1] = new int[1];
                     arr[2] = new int[2];

 

 

 

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