初识java--javaSE(3)--方法，递归，数组，

---

一 方法的使用

1.1 什么是方法？

方法类似于c语言中函数，
//方法的形式是：
/*
public static 返回值类型 方法名 (形式参数列表){
         方法体
}*/
 //其中public static 属于修饰符的部分， 先当做默认的方法格式，以后会阐述到

  public static int  add(int a,int b){
        return a+b;
    }

没有main方法的调用，此方法是执行不了的。

main方法

main方法：java程序是从main方法开始执行的，这与c语言main函数的作用类似。
 一个类中只能有一个main方法.
/*    public static void main(String[] args) {
                        方法体
}*/
在main方法格式中：
public  static以后再阐述，先当做一种必备的格式
 void是返回值类型， main是main方法特有的函数名
String[]  args是字符串类型的数组

注意事项

1  java中方法不能够嵌套定义！
2  java中方法没有声明的说法！
3  java中，方法如果有返回值，则返回值类型与返回的实体类型必须保持一致！（没有c语言中当返回类型与返回实际值类型不一样应该返回谁的说法。）如果没有返回值，则设置成void类型
4  在java中方法必须定义在类中。
5  修饰符：当前默认为public static 以后会阐述到，
6 方法名字采用小驼峰命名（即方法名字如果有两个单词组成，将后面单词的首字母大写，如果只有一个单词则小写即可）

1.2 方法的调用

 java中方法的调用与c语言中的函数调用没有区别

嵌套调用

public static void print(){
        System.out.println("我嵌套调用了方法！");
    }
    public static int add(int x,int y){
        print();
        return x+y;
    }

    public static void main(String[] args) {
        System.out.println(add(5,3));
    }

在方法调用时形参与实参的关系：

java方法调用与c语言函数调用的形参与实参的关系是相同的，用下面这个代码分析：

public static int func1(int x){
    if(x>1){
        return 1;
    }else {
        return 0;
    }
}

    public static void main(String[] args) {
        func1(5);
    }

如图解析：形参的改变不会影响实参

public static int func1(int x){
//将形参中的x值改为10，观察实参中值是否会变？
    x=10;
    if(x>1){
        return 1;
    }else {
        return 0;
    }
}

    public static void main(String[] args) {
    int x = 5;
        func1(x);
        System.out.println(x);
    }

结果并未发生变化！

1.3 方法的重载

在java中可以有两个名字相同的方法,那如何区分不同之处呢？取决于方法的参数列表

方法重载的意义？

这样做的目的是方便程序员不需要记录过多的方法名，而选择调用实现的功能大体相同，但操作数据不同的方法。

举例：

   public static int add(int a,int b){
        return a+b;
    }
    public static double add(double a,double b,double c){
        return a+b+c;
    }
      //创建main方法:
    public static void main(String[] args) {

      double d1 = add(3.14,5.2,6.4);
        System.out.println(d1);
        int i = add(5,6);
        System.out.println(i);
    }

另一种情况：

  public static void add(int a,int b) {
        return;
    }
    public static int add(int a,int b){
        return a+b;
    }

此时编译器会报错，原因在于返回值类型与方法重载无关

总结方法重载：

//总结：对于方法重载的规则：
    //   1 方法名必须相同
   //    2  参数列表必须不同（个数，类型，顺序）
  //     3 返回值类型与重载无关！

方法签名：

在作用域中不能有两个相同名字的标识符，比如不能定义两个相同名字的变量，但是为啥类中就可以定义两个相同名字的方法呢？
因为方法签名才是方法最终的名字！
方法签名即：经过编译器编译修改过之后的名字。具体方式：方法的全路径名+参数列表+返回值类型，构成方法完整的名字

二 递归

什么是递归？

 递归就是方法自己调用自己，通过自身的规则将大问题分解成小问题，最后解决问题。

递归的精髓：

递归的精髓一：是找到将大问题转换为小问题的规则。
递归的精髓二：是找到最后的“界限“，可以使得自身的嵌套停止，不然就成为了死循环。
递归的精髓三：我们可以用一条语句来表示规则，也可以用两条语句表示规则，最重要的是后面的语句代表的规则不会改变前面语句代表规则的执行。比如下面汉诺塔的两条语句便互不影响。

举例：

    //求阶乘之和
    //求n!+(n-1)!+.....1!
public static void main(String[] args) {
    System.out.println(func2(2)) ;  //结果为3
    System.out.println(func3(5));   //结果为：5! + 4!+3!+2!+1! = 120+24+6+2+1 ==153
}
  public static int func2(int n){
      int sum = 0;
      if(n==1){
          return 1;
      }else {
        sum = func3(n)+func2(n-1);
      }

      return sum;

  }
//求单个阶乘
    public static int func3(int n){
      int ret =0;
      if(n==1){
          return 1;
      }else {
          ret = n*func3(n-1);
      }
      return ret;
      }

在求阶乘之和时，我们不能找到一个既能求阶乘又能时期相加的规则，
这个问题求阶乘与求阶乘之和本质上是两条规则，所以我们用了两个函数来实现

汉诺塔问题：

这是一个十分经典的问题:
给三根柱子A,B,C，A柱上有一摞从下到上依次增大的盘子，要求将这些盘子转移到C柱上，在转移过程中有几条规则：
（1）一次只能转移一个盘子
（2）在转移的任何时刻，大盘子不能放在小盘子上面
（3）操作过程中盘子可以置于A、B、C任一杆上。

如图：

我们要转移A上这一摞盘子，

1. 首先需要将上面的三个盘子转移至B，我们才能移动最大的盘子到C，那么在此过程中A的盘子原来所在的柱子，我们称为原柱，B是我们要将上面三个盘子转移到的柱子，我们称为目标柱，C柱用来暂时存放盘子，我们称为辅柱，

2. 在将上面的盘子转移到B后，A柱的最大的盘子便可转移到C柱上，

3. 然后再将B柱上的盘子，全部转移至C柱，此时B柱变为原柱，C柱变为目标柱，A柱变为辅柱。

代码实现：

//汉诺塔问题
    public static void func2(int n,char a,char b,char c){
        //n代表盘子的数量，也表示盘子的序号，越小的盘子，序号越小
        if(n==1){
            System.out.printf(" 转移%d号盘子,从%c柱到%c柱\n",n,a,c);
        }else {
            //如果盘子的数量大于1，则现将A柱上面的一摞盘子转移至B柱
            func2(n-1,a,c,b);
            //然后将此时A柱上最大的盘子转移至C柱
            System.out.printf("转移%d号盘子,从%c柱到%c柱\n",n,a,c);
            //然后将B柱上的一摞盘子转移至C柱，A作为辅柱
            func2(n-1,b,a,c);
        }

    }

    public static void main(String[] args) {
      func2(3,'A','B','C');
    }

三 数组

1 数组的定义

定义

//数组的定义：
        //1  定义但不初始化
         int [] arr = new int[5];
         //new关键字是创建一个新的对象，这个在后面的博客中会阐述到。
         //2  定义并且初始化
         int []arr1 = new int[]{1,2,3,4};
        
         int [] arr2 ={1,2,3,4}; //这种方式与上面的没有区别
         //3  先定义，然后再初始化，这是错误的
         int []arr3;
         //arr3 = {1,2,3,4};
         //3  只有在定义时才可以对数组整体进行初始化
         //4 我们也可以采用c语言中定义数组的方式:
         int arr6 [] = {1,5};

java中数组的定义比c语言中的更规范，因为前面是数据类型，后面是变量名，
这样的定义方式很规整！

默认初始值

 for (int x:arr) {
           System.out.println(x);
       };
       for (int x:arr2) { 
       //但是定义未指定数组大小时，
       //数组中没有默认的值，这是因为并没有给本数组
           //分配堆空间，无法赋值
           System.out.println(x);
       }

2 遍历数组的方式

通过for语句

其中arr.length是数组的长度

         int [] arr = new int[5];
            for (int i = 0; i < arr.length; i++) {
           System.out.println(arr[i]);
       }

通过foreach语句

对于foreach语句，在冒号之前是创建的临时变量，冒号之后是数组名,
此语句的作用即是遍历数组的元素，赋值到变量x当中去。

    for (int x:arr) {
           System.out.println(x);
       };
       

 此语句只能输出数组的内容，而不能使用数组的下标！

通过Arrays类

Arrays类中的toString方法可以将数组中的数据转换成字符串形式！

举例：

       System.out.println(Arrays.toString(arr));

3 引用数据类型与基本数据类型的区别

区别1：:

       //系统在为变量分配内存时，均在栈区上分配，
   // 对于基本数据类型，数据就存放在在栈区分配的内存上
  // 对于引用数据类型，栈区的内存中存放的是类似于地址的数据，我们可以看做地址
 // 在真正存放数据的空间是开辟在堆上的，并将此块空间的地址放在栈区空间内。

如图：

区别2 ：

引用数据类型在当参数时，是可以通过修改形参而改变形参的。
但是基本数据类型做不到

   public static void func1(int []array){
           array[0] = 99;
       }

    public static void main(String[] args) {
        int []array = {0,1,2,3,4};
        func1(array);
        System.out.println(Arrays.toString(array));
    }

引用数据类型：

 引用：我们称引用数据类型变量的值为引用，类似于c语言指针，
 一个引用只能指向一个对象。

如图，当我们传参后，形参中的引用被新创建的对象的引用所替代。

null ：当引用类型变量的值为null时，代表这个引用不指向任何对象。

 public static void main(String[] args) {
     int []array = null;
 }

当array1 = array2;代表两个引用指向了同一个对象

public static void main(String[] args) {
     int []array = {1,2,3};
     int []array1 =array;
     System.out.println(Arrays.toString(array));
     System.out.println(Arrays.toString(array1));

 }

4 有关数组方法的使用

二分查找方法

 public static void main(String[] args) {
     int [] arr = {1,2,3,4,5,6,5,};
 int c = Arrays.binarySearch(arr , 6 );
     System.out.println(c);
 }

排序的方法

 public static void main(String[] args) {
     int [] arr = {1,2,3,4,5,6,5,};
    Arrays.sort(arr);
     System.out.println(Arrays.toString(arr));
 }

5 二维数组

二维数组的定义方式：

    //定义的形式
    //1 
        int [][]arr =new int[][]{{1,2,3},{1,2,3,4,5}};
    //2   
              int [][] arr3 = {{1,2,3},{4,5,6}} ;
    // 2           //当定义指定数组大小时，不能够初始化
        int [][] arr1 = new int[2][3];
   // 3        // 不规则定义:只指定行，不指定列，这个规则与c语言中恰好相反
        int [][] arr2 = new int[2][];
        arr2[0] = new int [3];
        arr [1] = new int [5];

二维数组的遍历：

第一种方式：
对于二维数组有几个元素（一维数组）由二维数组名.length判断
每个一维数组有多少元素，arr[i].length判断。

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

   for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }

第二种方式：

  for (int [] tmp:arr) {
            for (int x:tmp) {
                System.out.print(x);
            }

注意：
对于不规则二维数组未初始化时，遍历是会报错的，原因在于我们没有给定有多少列，所以系统会自动为每个一维数组赋值为null。