Java 的函数和数组

Java基础系列

1. 函数的定义

函数，function，方法 method 
函数不可以嵌套定义
函数就是定义在类中的具有特定功能的一段独立小程序。
函数又称为方法。

1.1 Java的函数格式

函数格式
   修饰符  返回值类型  函数名（类型 名称1，....）
   { //函数体
   .....
   return ; //返回值类型
   }
   返回值类型，函数运行后的结果的数据类型
   参数类型， 是形式参数的数据类型
   形式参数：是一个变量，用于存储调用函数式传递给函数的实际参数
   实际参数：是传递形式参数的具体数值
   return :用于结束函数
   返回值：该函数运算后的结果，该结果会返回给调用者。

1.2 函数的特点

1. 定义函数可以将功能代码进行封装
2. 便于对该功能进行复用
3. 函数只有被调用才会被执行
4. 函数的出现提高了代码的复用性
5. 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略 不写
注意： 
   1. 函数中 只能调用函数，不可以在函数内部定义函数
   2. 定义函数时，函数的结果应该返回给调用者，交由调用者处理

1.3 函数的调用

1. 一般在主方法的中调用

• 1.3.1 实例：

class  funcationDemo{
  public static void main(String[] args){
    System.out.println("hello world");
    int a = 1
    int b = 2 
    int c = add(a,b);
    System.out.println(c)
    }
    public  static int add (int a, int b){
    //  int res = a + b ;
      return  a + b ;
    }
}

package FuncationDemo;
public class FuncationDemo {
    public static void main(String[] args) {
        int a =1;
        int b =2;
     int c = add(a,b);
     System.out.println("c="+c);
      hello("hello world");
    }
    public static int add (int a , int b) {
        return a + b ;
    }
    public static void hello(String mes) {
        System.out.println(mes);
    }
}

package day03;
public class max {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(max(1,2,3));
    }
    public static int max(int a ,int b ,int c) {
        int max = a > b? a:b;
        max = max >c ? max : c ;
        return max ;
    }
}

package day03;
public class he {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
           System.out.println("sum ="+sum(100));
    }
    public static int sum(int a) {
        int sum = 0;
        for(int i = 1 ; i<=a ; i++ ) {
            sum +=i ;
        }
            return sum;
    }
}

package day03;
public class HeSumDemo {
     public static void main(String [] args) {
         jiujiu(9);
     }
     public static void jiujiu(int row) {
         for (int i =1 ; i <= row ; i++) {
             for(int j =1; j<=i ; j++) {
                 System.out.print(j + "*" + i + "=" + (j * i) + "\t");
             }
             System.out.println();
         }
     }
}

- 1.3.2 递归

// 阶乘计算递归
package day03;
public class JieChen {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
          System.out.println("5!="+fanc(5));
    }
    public static int fanc(int n) {
        if (n == 1) {
            return 1;
        }
        return n* fanc(n-1);
    } 
}   

1.4 函数的应用

 一： 两个明确
       1. 明确定义的功能最后的结果是什么？
       2. 明确在定义该功能的过程中，是否需要未知内容参与运算
二： 示例：
     1. 需求：定义一个功能，可以实现两个整数的加法运算。
     2. 分析：
      该功能的运算结果是什么？ 两个数的和，也是一个整数（int）
      在实现改功能的过程中是否有未知内容参与运算？加数和被加数是不确定的 （两个参数int,int）
      代码：
         int getSum(int x ,int y){
                return x+y;
             }

1.5 函数的重载

重载的概念：
在同一个类当中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表、
重载的好处：
方便与阅读，优化了程序设计。
重载实例：
// 返回两个整数的和
  int add(int x , int y){return x+y;}
// 返回三个整数的和：
  int add(int x , int y , init z){return x+y+z;}
 //返回两个小数的和
 double add(double x , double y){return x+y;}

2. java 的数组

2.1 什么是数组：

概念：
同一种类型数据的集合，其实数组就是一个容器
数组的好处：
可以自动给数组中的元素从０开始编号，方便操作这些元组
格式１：
元素类型[] 数组名　＝　new 元素类型[元素个数或数组长度]
实例：　int [] arr = new int[5];
格式２：
元素类型[] 数组名　＝ new 元素类型[] {元素，元素}
int [] arr = new int[] {3,5,1,7};
int [] arr = {3,5,1,7};

package day03;
public class arr01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //  定义一个数组
        int [] arr = new int [5];  // 表示长度
        //java.lang.ArrayIndexOutOfBoundsException 数组的下标越界
        int [] arr01 = new int [] {8,7,6,5,4};
        int [] arr02 = {1,2,4,5,7,8};
        //java.lang.NullPointerException 空指针异常
        int [] arr03 = null;
        // length 是属性
        System.out.println(arr.length);
        System.out.println(arr01[1]);
        System.out.println(arr02[2]);
        System.out.println(arr03.length);
    }
}

注意：
　　java 是没有指针
　　　没有显示的指针操作，引用就是指针。指针就是对象的内存地址，null 对象不存在，不能访问其属性和方法，否则　就是会出现空指针异常。

2.2 数组的结构：

- 2.2.1:给定一个数组求最大值与最小值：

package day03;
public class ArrayTest {
    /**给定一个数组{5,1,6,4,2,8,9}获取数组中的最大值，以及最小值。
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
           int []arr ={5,1,6,4,2,8,9};
           int max=getMax(arr);
           int min=getMin(arr);
           System.out.println("max="+max);
           System.out.println("min="+min);
    }
    public static int getMax(int []arr){
        int max = arr[0];
        for(int x=1;x<arr.length;x++){
            if(arr[x]>max)
                max=arr[x];
        }
        return max;
    }
    public static int getMin(int []arr){
        int min = arr[0];
        for (int x=1;x<arr.length;x++){
            if(arr[x]<min)
                min=arr[x];
        }
        return min;
    }
}

- 2.2.2 java 的冒泡排序：

　冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
　　冒泡排序算法的运作如下:
 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
 针对所有的元素重复以上的步骤，除了最后一个。
 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class BubbleSort{
       public static void main(String[] args){
           int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
           for (int i = 0; i < score.length -1; i++){    //最多做n-1趟排序
               for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                   if(score[j] < score[j + 1]){    //把小的值交换到后面
                       int temp = score[j];
                       score[j] = score[j + 1];
                       score[j + 1] = temp;
                  }
              }            
              System.out.print("第" + (i + 1) + "次排序结果：");
              for(int a = 0; a < score.length; a++){
                  System.out.print(score[a] + "\t");
              }
              System.out.println("");
          }
              System.out.print("最终排序结果：");
              for(int a = 0; a < score.length; a++){
                  System.out.print(score[a] + "\t");
         }
      }
  }