黑马程序员——java第四天：基础语法（函数、数组）

函数

<------- android培训、java培训、期待与您交流！ ----------/div>

函数（方法）：有特定功能的一小段代码程序。

函数的格式：

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

         {

                   执行语句；

                   return返回值；

         }

注解：

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

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

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

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

         return:用于结束函数。

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

函数的作用：

《1》      当要获取不同不同数值的运算结果，代码会出现重复

《2》      为了提高代码的复用性，对代码进行抽取，将这部分定义成独立的功能，方便日后调用。

《3》      java中对代码的定义是通过函数的形式实现的。

静态函数只能调用静态方法，主函数为静态（static）函数。

当函数运算后没有具体的返回值时，这时的返回值类型用“void”代替，这时return可以不写。

例如：

  publicstatic void main(String args[]){
         intx=getResult(4);
         inty=getResult(6);
         System.out.println(x+y);
}
public staticint getResult(int num){
         return num*3+5;
}

最小的函数单元是函数，那如何定义一个函数呢？

既然函数是一个独立的功能，那么该函数的运算结果是什么要先明确。

《1》      明确返回值。

在明确该功能的过程中是否需要未知的内容参与运算？

《2》      明确形式参数及形参类型。

注意：功能参数只做功能，而输出等是调用者来完成的。

 

例子：

public classFunctionTest{
    public static void main(String[] args){
       draw(5,6);
       printHr();
       draw(7,8);
       printHr();
       print99();
}
public static void print99(){
                  for(int x=1;x<=9;x++){
           for(int y=1;y<=x;y++){
               System.out.print(y+"*"+x+"="+y*x+"\t ");
           }
           System.out.println();
}
}
public static void draw(int row,int col){
    for(int x=0;x<row;x++){
       for(int y=0;y<col;y++){
           System.out.print("*");
       }
    System.out.println();
    }
}
public static void printHr(){
    System.out.println("----------------------------");
}
}

函数的重载

重载的概念：在同一个类中允许存在一个以上同名函数，只要他们的参数个数或参数类型不同即可；

特点：与返回值类型无关，只看参数列表（参数是有顺序的）；

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

数组

数组属于引用行数据类型。

数组概念：同一种数据类型的集合。（其实数组是一个容器）。

格式：元素类型[] 数组名=new 元素类型[元素个数]；

例如：int[] arr=newint[3];

特点：（1）数组是固定的不能扩展

•    （2）可以存储基本数据类型或对象

•    （3）通过数组名和下标可以访问各元素，下标从0开始

栈内存和堆内存：

         栈：栈内存中的数据使用完毕，会自动释放。（局部变量都是放在栈内存中的）。

实体包括数组和对象。

         堆：实体不放在栈内存中而是放在堆内存中。

                  实体：通过new创建出来的叫实体。

例如：在int[] arr=new int[3];其中arr放在 栈内存中，new出来的实体放在堆内存中，arr中放的是实体在堆内存中的地址值。arr就指向这个堆内存中的实体。

当arr=null；时（arr不再指向堆内存中的实体），堆中这些数组值就被视为垃圾，就会被系统回收。

注意：堆内存里的变量都有默认值。

1、整数类型（byte、short、int、long）的基本类型变量的默认值为0。
     2、单精度浮点型（float）的基本类型变量的默认值为0.0f。
     3、双精度浮点型（double）的基本类型变量的默认值为0.0。
    4、字符型（char）的基本类型变量的默认为 “/u0000”。
    5、布尔性的基本类型变量的默认值为 false。
     6、引用类型的变量是默认值为 null。

举例：

（1）      int[] x=newint[3];

         int[] y=x;  //x和y引用了同一个堆空间

         y[1]=89;  //其中y为其更改，x中的也变了

（2）      int[] x=newint[3];

         int[] y=new int[3];  //与（1）不同，y有了一个新的地址

         y[1]=89;  //x[1]不会随其改变值

数组定义：

       <1>int[] arr=new int[3];

              或int arr[]=newint[3];

       <2>int[] arr=new int[]{3,1,6,5,4};

              或int[]arr={3,1,6,5,4};//数组中的数据明确时常用

              当数组中的数据不明确时：

              int[] arr=newint[2];

              arr[0]=90;

              arr[1]=80;

注意：编译直检查语法错误，运行会才创建数组。

arr.length可以获取数组arr的长度。

当输出：System.out.println(arr);（arr为数组）输出的是arr的在堆存中的地址如：“[I@de6ced”“[”代表数组；“I”代表int型；“de6ced”代表堆内存中的地址值。

排序：

（1）  选择排序

特点：最小值先在前面出现

public class Test1 {
    public static void main(String[] args) {
       int[] a={4,8,1,3,9,5,7,2};
      
       /*调用选择排序方法给数组元素排序*/      
       selectSort(a);
      
       /*调用打印方法，打印排序后的数组*/
       ptintSort(a);
    }
    /*创建冒泡排序方法*/
    public static void selectSort(int[] arry){
       for(int x=0;x<arry.length-1;x++){
           for(int y=x+1;y<arry.length;y++){
              if(arry[x]>arry[y]){
              int temp=arry[y];
              arry[y]=arry[x];
              arry[x]=temp;           
               }
          }
       }
    }
    /*创建打印方法，并打印*/
    public static void ptintSort(int[] arry){
       System.out.print("排序后的数组 a={");
       for(int x=0;x<arry.length;x++){
           if(x<arry.length-1)
              System.out.print(arry[x]+",");
           else
              System.out.println(arry[x]+"};");
          
       }
    }

 

（2）  }冒泡排序

特点：大值先在后面产生

public class Test1 {
    public static void main(String[] args) {
       int[] a={4,8,1,3,9,5,7,2};
      
       /*调用冒泡排序方法给数组元素排序*/      
       bubbleSort(a);
      
       /*调用打印方法，打印排序后的数组*/
       ptintSort(a);
    }
    /*创建冒泡排序方法*/
    public static void bubbleSort(int[] arry){
       for(int x=0;x<arry.length-1;x++){
           for(int y=0;y<arry.length-x-1;y++){
              if(arry[y]>arry[y+1]){
              int temp=arry[y];
              arry[y]=arry[y+1];
              arry[y+1]=temp;            
               }
          }
       }
    }
    /*创建打印方法，并打印*/
    public static void ptintSort(int[] arry){
       System.out.print("排序后的数组 a={");
       for(int x=0;x<arry.length;x++){
           if(x<arry.length-1)
              System.out.print(arry[x]+",");
           else
              System.out.println(arry[x]+"};");
          
       }
    }
}

在java中的java。util包下有关于排序的算法：Arrays.sort(arr);//升序排序。

折半查找

在查找中的元素中没有要查找的数时通常返回负数以表示数组中无此元素

如果有两个查找的相同的元素，则返回前面那个元素的角标。

折半查找可以提高效率，但是数组需要是有序。

public class Zheban {
    public static void main(String[] args) {
       int arr[]={1,4,6,8,14,19};
       System.out.print(halfSearch1( arr,5));
System.out.print(halfSearch2( arr,6));
    }
    public static int halfSearch1(int[] arr,int key){
       int min,max,mid;
       min=0;
       max=arr.length-1;
       mid=(max-min)/2;
       while(arr[mid]!=key){
           if(key>arr[mid])
              min=mid+1;
           else if(key<arr[mid])
              max=mid-1;
           if(min>max)             
              return -1;
           mid=(max+min)/2;
       }
       return mid;
    }
public static int halfSearch2(int[] arr,int key){
       int min,max,mid;
       min=0;
       max=arr.length-1;
       while(arr[min]<arr[max]){
mid=(max-min)>>1;
           if(key>arr[mid])
              min=mid+1;
           else if(key<arr[mid])
              max=mid-1;
           else             
              return mid;
       }
       return -1;
    }
}

数组（进制转换）

class ArrayTest7
{
    public static void main(String[] args)
    {
       //toBin(-6);
       //toHex(-60);
       //toBa(60);
 
//     System.out.println(Integer.toBinaryString(6));
//     System.out.println(Integer.toHexString(6));
    }
 
    /*
    十进制-->二进制
    */
    public static void toBin(int num)
    {
       trans(num,1,1);
    }
 
    /*
    十进制-->八进制
    */
    public static void toBa(int num)
    {
       trans(num,7,3);
    }
    /*
    十进制-->十六进制
    */
    public static void toHex(int num)
    {
       trans(num,15,4);
    }
 
    public static void trans(int num,int base,int offset)
    {
 
       if(num==0)
       {
           System.out.println(0);
           return ;
       }
       char[] chs = {'0','1','2','3'
                  ,'4','5','6','7'
                  ,'8','9','A','B'
                  ,'C','D','E','F'};
       char[] arr = new char[32];
 
       int pos = arr.length;
 
       while(num!=0)
       {
           int temp = num & base;
           arr[--pos] = chs[temp];
           num = num >>> offset;
       }
 
       for(int x=pos; x<arr.length; x++)
       {
           System.out.print(arr[x]);
       }
 
       return ;
    }
}

二维数组

int[][] arr=new int[3][4]

定义一个二维数组，二维数组中有3个一位数组，每个一位数组中有4个元素；3是二维数组的长度，4为每个二维数组一位数组的长度。

如果做：System.out.println(arr);则输出的是二维数组的地址值，如：[[I@3x4d6.

如果做：System.out.println（arr[0]）;则输出的是二维数组中第一个一维数组的地址，如：[I@3de4。

如果做：System.out.println（arr.length）;则输出的是二维数组的长度。

如果做：System.out.println（arr[0].length）;则输出的是二维数组中第一个一维数组的长度。

 

在定义二维数组是必须定义二维数组的长度：

int[][] arr1=new int[3][];

如果做：System.out.println(arr1[0]);则输出的结果为null；为什么与上面不一样呢，因为它只定义的了二维数组为三个一维数组而没有定义其中的一维数组什么样子，所以在堆中默认数组为null。

对二维数组中小数组初始化：arr1[0]=new int[3];

                                                        arr1[1]=newint[1];

                                                        arr1[2]=newint[2];

 

第二种定义数组方式：int[][] arr={{3,5,1},{2},{5,1}};

总结三种二维数组的定义方式：

《1》         int[][] y;

《2》         int y[][];

《3》         int[] y[];

《4》其中int[] x,y[];这种定义方式x为一维，y为二维；同时定义了两个数组。

------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net