JavaSE学习笔记-方法+数组（3）

目录

1.方法的定义：

2.方法的重载

3.命令行传递参数

4.可变长参数

5.递归：

6.数组

7.冒泡排序

---

1.方法的定义：

        java的方法是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

修饰符、返回值类型、方法名、参数类型、方法体.

  修饰符 返回值类型 方法名（参数类型 参数名）{

                 .........................

                方法体

                .......................................

                reutrn 返回值;

        }

2.方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

重载规则：

                方法名必须相同

                参数必须不同（个数不同，类型不同，排列类型顺序不同等）

                方法的返回类型可以相同也可以不同

                仅仅返回类型不同不足以成为方法的重载

3.命令行传递参数

package com.yves.method;

public class Demo01 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]"+args[i]);
        }
    }
}

//以下内容为cmd命令行操作内容：

/*
C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src\com\yves\method>javac Demo01.java

C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src\com\yves\method>java Demo01.class
Error: Could not find or load main class Demo01.class
错误：找不到或无法加载主类
(因为demo中 package com.yves.method; 所以应回退到src目录下执行java 命令即可成功)

C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src\com\yves\method>cd ..

C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src\com\yves>cd ..

C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src\com>cd ..

C:\Users\cl90767\Desktop\MyProject\JavaSE\Base\src>java com.yves.method.Demo01 this is parameter
args[0]this
args[1]is
args[2]parameter
 */

4.可变长参数

        在方法声明中，在指定参数类型后添加一个省略号

        一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何一个普通参数都必须在他之前声明。

public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        demo02.test(1,2,3,4,5); 
    }
   
    public void test(int... h){
        for (int j = 0; j < h.length; j++) {
            System.out.println(h[j]);
        }
    }
}
结果：
1
2
3
4
5

5.递归：

         递归结构包括两个部分：

                递归头：什么时候不调用自身方法，如果没有头将陷入死循环.

                递归体：什么时候调用自身方法

package com.yves.method;

//利用递归计算阶乘
public class Demo03 {
    public static void main(String[] args) {
        System.out.println(test(5));
    }

    public static int test(int n){
        if(n==1){
            return 1;
        }
        int tol = n * test(n - 1);
        return tol;
    }
}
结果：
120

6.数组

       四个基本特点：

                长度确定：  一旦创建，大小不可改变

                元素必须是相同类型，不允许出现混合类型

                数组可以被定为任意类型，包括基本类型和引用类型（一旦定义为某一类型必须遵守第二条特点 ，其中元素必须为相同类型）

                数组变量属引用类型，数组也可以看成是对象，每个元素相当于该对象的成员变量。数组本身就是对象，java是在堆中的，因此无论数组保存原始类型还是其它对象类型，数组对象本身是在堆中的。

package com.yves.ArrayDemo;

public class Demo01 {
    
    public static void main(String[] args) {
        
        //静态初始化  创建+赋值  在堆中开辟一个内存空间划分为五份 并为每一份赋值
        int[] a = {1,2,3,4,5};
        System.out.println(a[0]);//结果： 1 2 3 4 5
        
        //动态初始化：  在堆中开辟一个内存空间划分为10份 默认值为0  可以后为其赋值
        int[] b = new int[10];
        b[0] = 1;
        b[1] = 2;
        for (int i = 0; i <10; i++) {
            System.out.println(b[i]);  //结果： 1 2 0 0 0 0 0 0 0 0
        }
        
        /*
        内存分析：
            int[] c = null;    会向栈中压入数组对象c 此时堆内为空没有分配内存
            c = new int[10];    在堆中开辟一个内存空间并将其划分为十份
         */
        int[] c = null;
        c = new int[10];
        
    }
    
}

注：

一：在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因

      在方法中声明的变量可以是基本类型的变量，也可以是引用类型的变量。

         （1）当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在方法栈中

         （2）当声明的是引用变量时，所声明的变量（该变量实际上是在方法中存储的是内存地址值）是放在方法的栈中，该变量所指向的对象是放在堆类存中的。

   二：在类中声明的变量是成员变量，也叫全局变量，放在堆中的（因为全局变量不会随着某个方法执行结束而销毁）。

       同样在类中声明的变量即可是基本类型的变量 也可是引用类型的变量

       （1）当声明的是基本类型的变量其变量名及其值放在堆内存中的

       （2）引用类型时，其声明的变量仍然会存储一个内存地址值，该内存地址值指向所引用的对象。引用变量名和对应的对象都存储在堆中

7.冒泡排序

package com.yves.ArrayDemo;

import java.util.Arrays;

public class Sort {
    public static void main(String[] args) {
        int[] a = {1,95,54,21,36,55,44,66,33,20};
        System.out.println(Arrays.toString(new Sort().sort(a)));
    }

    public int[] sort(int[] a){
        int temp =0;
        for (int i = 0; i < a.length-1; i++) {
            //设置一个标识位 
            boolean flag = false;
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    System.out.println(temp);
                    temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                    flag = true;
                }
            }
            //如果标识位为false  即当前数组从前向后依次比较 没有发生交换  -->数组已经有序 直接跳出循环（节省时间优化算法）
            if(flag==false){
                break;
            }
        }
        return a;
    }
}