java学习笔记 （方法,命令行传参，可变参数）（五）

方法

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或者对象中
• 方法在程序中创建，在其他地方被引用
• 一个方法只完成一个功能

一个方法包含 方法头，方法体

形式参数，形参，定义用的
实际参数，实参，实际传递的

加static 相当于类变量

值传递，引用传递？

方法重载

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

方法重载的规则

• 方法名必须相同
• 参数列表必须不同
• 方法的返回类型可以相同也可以不相同
• 仅仅返回类型不同不足以为方法的重载

package com.hongyuan.base2;

public class Demo01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(max(a,b));
        float c = 20f;
        float d = 18f;
        System.out.println(max(c,d));

        // 100.for 快捷键
        for (int i = 0; i < 100; i++) {
            
        }
    }

    public static int max(int a,int b){
        return a > b ? a : b;
    }
    public static double max(double a,double b){
        return a > b ? a : b;
    }
}

命令行传参

需要复习

可变参数

代码实践

数组

package com.hongyuan.base2;

public class arry {
    public static void main(String[] args) {
        // 声明一个数组
        int[] num;
        int num2[];

        // 创建一个数组
        num = new int[10];

        /*
        通用数组声明创建
        dataType[] arrayRefVar = new dataType[arraySize];
         */
        for (int i = 0; i < 10; i++) {
            num[i] = i + 9;
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(num[i]);
        }
        System.out.println(num[5]);
        System.out.println(num.length);
    }
}

增强型循环

 for (int x:num){
            System.out.println("增强型循环 - " + x);
        }

双变量循环

int[] b = new int[20];
            for (int i = 0,j = a.length - 1; i < 20; i++,j--) {
                b[j] = a[i];
            }

数组

• 堆中存放数组的值
• 栈中存放数组的声明
• 静态初始化

int[] a= {0,0,0}

• 动态初始化

int[] a = new int[10];

多维数组

        int[][] c = new int[10][10];

Arrays类

package com.hongyuan.base2;

import java.util.Arrays;

public class studyArrays {
    public static void main(String[] args) {
        int[] a = new int[10];
        int[] b = {1,2,2,4,5,6,11,122,32,32,1,154};
        System.out.println(b);
        System.out.println("====================");
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        Arrays.fill(a,888);
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(b,154));
        // 比较
        System.out.println(Arrays.equals(a,b));

    }
}
···

# 冒泡排序

package com.hongyuan.base2;

import java.util.Arrays;

public class sort {
public static void main(String[] args) {
int[] b = {1,2,2,4,5,6,11,122,32,32,1,154};
System.out.println(Arrays.toString(sort(b)));

}
public static int[] sort(int[] a){
    int t = 0;
    boolean flag = false;
    for (int i = 0; i < a.length - 1; i++) {
        for (int j = 0; j < a.length - 1; j++) {
            if (a[j]<a[j+1]){
                t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
                flag =true;
            }
        }
        if (flag==false){
            break;
        }
        System.out.println(i);
    }
    return a;
}

}

# 转义符
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210622142743466.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIwMjg0OTg=,size_16,color_FFFFFF,t_70)