Java方法笔记

Java方法详解

目录
  • Java方法详解
    • Java流程控制
      • 方法
        • 方法的定义
        • 方法调用：
        • 值传递和引用传递
      • 方法的重载
      • 命令行传参
      • 可变参数
      • 递归
      • 杂碎的知识点
      • 用户交互Scanner
    • Java数组
      • 数组声明有两种方式
      • Java内存分析：
      • 三种初始化
      • 数组的使用
      • 二维数组
      • Arrays调用
      • 稀疏数组

Java流程控制

方法

例如System.out.println().

这就是类.对象.方法

public class Demo{
    
    //实际参数
    public static void main(String[] args) {
        int s = add(2,3);
        System.out.println(s);
        System.out.println(add(3,5));
    }
    
    //形式参数
    public static int add(int a,int b){//转换成static变量，全局可用
        int i = a + b;
        return i;
    }
}

方法的定义

修饰符 返回值类型 方法名（参数类型 参数名）{
    ...
    方法体
    ...
    return 返回值;
}

方法：

包含一个方法头和一个方法体。

  • 修饰符：可选，告诉编译器如何调用该方法，定义了访问类型。
  • 返回值类型：void没有返回值。
  • 方法名：驼峰命名。
  • 参数类型：占位符，当方法被调用时，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型、顺序和参数的个数。参数的可选的，方法可以不包含任何参数。
  • 方法体：具体方法功能实现的语句。

程序中遇见return即结束方法。

方法调用：

  1. 调用方法：对象名.方法名（实参列表）

  2. Java的两种调用方法：

    • 当方法返回一个值的时候，方法调用通常被当作一个值：
    int larger = max(30,40);//这就是定义了一个值
    • 当方法返回值为void，方法调用是一条语句：
    System.out.println("Hello world!");//println方法是void类型，这就是一条语句

值传递和引用传递

值传递和引用传递的区别：

值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

引用传递：(形式参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象(或数组)，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数

方法的重载

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

  2. 方法重载的规则：

    • 方法名称必须相同。
    • 参数列表必须不同（个数、类型、参数排列顺序）
    • 方法的返回类型可以相同也可以不同
    • 仅仅返回类型不同不足以成为方法的重载

  3. 实现理论：

    方法名字相同的时候，编译器会根据调用方法的参数个数，参数类型等逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

//我是源代码
public class Demo{

    private static int a;
    private static int b;

    public static void main(String[] args) {
        int Max = max(2,3);
        System.out.println(Max);
        System.out.println("Hello world!");
    }

    public static int max(int a, int b) {
        Demo.a = a;
        Demo.b = b;

        int result = 0;

        if (a > b) {
         result = a;
        }
        else
        result =b;

        int i = result;
        return i;
    }
}

在IDEA下边，有个Terminal，这个是命令行，可以打开然后编译。

但是编译会出现说路径出错，

得这样：

image-20211120181650627

接下来是命令行：

命令行打开：点击文件右键，选择show in explore ，然后再文件夹路径最前端输入cmd+空格，然后回车进入命令行。

image-20211120181402676

需要注意的点是，执行程序时，要回到src目录，无论在什么包下边，都要回去。接着执行的时候，输入文件路径。

首先先编译javac 文件名.java，生成文件名.class文件，接着java 文件名，就可以输出结果

可变参数

  1. 也叫不定项参数
  2. JDK1.5开始，Java支持传递同类型的可变参数给一个方法
  3. 在方法声明中，在指定参数类型后加一个省略号（...）
  4. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public class Demo{
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.test(1,2,5,8,4,6);
    }

    //参数...变量，只能放在最后，类似数组输出
    public void test(int x,double...i){
        System.out.println(i[0]);//2.0
        System.out.println(i[1]);//5.0
        System.out.println(i[2]);//8.0
        System.out.println(i[3]);//4.0
        System.out.println(i[4]);//6.0
    }
}

递归

递归结构包含两个部分：

  1. 递归头（递归出口）：什么时候不调用自己。没有头将进入死循环。
  2. 递归体：什么时候需要调用自身方法。

自己调用自己，但是只适合基数小的计算，大的计算要避免递归。

杂碎的知识点

  1. 在比较字符串是否相等的时候，不用“==”，用.equals。

  2. class文件，反编译，可查看（放到目录下通过Idea查看）

  3. 100.for=for (int i = 0; i < 100; i++) {}(偷懒)

  4. println 输出会换行 print输出不会换行 '\t'=tab键

  5. 增强for循环

    public class Demo{
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};

        for (int i = 0; i < 5; i++) System.out.println(numbers[i]);
        
        for(int x:numbers) System.out.println(x);
        }

    }
//这两个for循环是一样的，下边只是为了偷懒

用户交互Scanner

import java.util.Scanner;

public class Demo{
    public static void main(String[] args) {

        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next的方式接收：");

        //判断用户里是否还有输入的字符串
        if(scanner.hasNext()){

            /* 用next形式接收，定义一个str，引用scanner类的next */
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }


        Scanner scanner_1 = new Scanner(System.in);
        System.out.println("使用nextLine的方式接收：");


        if(scanner_1.hasNextLine()){
            String str_1 = scanner_1.nextLine();
            System.out.println("输出的内容为："+str_1);
        }

        //凡是属于IO流的类如果不关闭就会一直占用资源
        scanner.close();
    }
}
/*
使用next的方式接收：
hello world
输出的内容为：hello
使用nextLine的方式接收：
hello world
输出的内容为：hello world
*/
  1. next():
    • 一定要读取到有效字符后才可以结束输入
    • 对于输入有效字符之前遇到的空白，next()方法会自动将其去掉
    • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
    • next()不能得到带有空格的字符串
  2. nextLine():
    • 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
    • 可以获得空白

Java数组

public class Demo {
    public static void main(String[] args) {
        
        //变量类型 变量的名字 = 变量的值
        int [] nums;//声明一个数组
        
        //内存初始化，创建一个数组
        nums = new int[3];

        //数组赋值，还有其他方法
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        
        int sum = 0;
        //array.length,表示数组的长度函数
        for (int i = 0; i < nums.length; i++) {

            sum += nums[i];
        }
        System.out.println(sum);//6
    }
}

数组声明有两种方式

dataType[] arrayRefVar; //java用这个，首选

dataType arrayRefVar[]; //C与C++方法

  1. 数组中的元素可以是任何数据类型，包括基本类型和引用类型

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

    Java内存分析：

  • 堆：
    • 存放new的对象和数组 （数组new的时候，比如上边的nums = new int[10];）
    • 可以被所有的线程共享，不会存放别的对象引用
  • 栈：
    • 存放基本变量类型（会包含这个基本类型的具体数值）(在定义的时候，比如上边的int[] nums;)
    • 引用对象的变量 （会存放这个引用在堆里面的具体地址）
  • 方法区：
    • 可以被所有的线程共享
    • 包含了所有的class和static的变量

三种初始化

public class Demo {
    public static void main(String[] args) {
        
        //静态初始化：创建+赋值，不可变
        int[] nums = {0,1,2,3,4,5};
        
        //在这有创建一个Man类，这属于引用类型的静态初始化
        Man[] mans = {new Man(),new Man()};
        
        //动态初始化:包含默认初始化
        int[] b = new int[10];
        b[0] = 1;
    }
}
  • 默认初始化
    • 数组也是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的使用

  • 数组函数的命名及其调用

    public class Demo {
    public static void main(String[] args) {
        int[] arrays = {0,1,2,3};

        //JDK1.5,没有下标，适合输出
        for (int array : arrays) {
            System.out.println(arrays);
        }
        printArrays(add(arrays));
    }
    public static int[] add(int[] arrays){
        int [] add = new int[arrays.length];
        for(int i=0, j = add.length-1;i < add.length;i++,j--){
            add[j] = arrays[i];
        }
        return add;
    }

    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

二维数组

public class Demo {
    public static void main(String[] args) {
        int[][] arrays = {{1,2},{2,3},{3,4}};

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

Arrays调用

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
       int[] a= {1,2,3,4,5,6,7};

        System.out.println(Arrays.toString(a));
    }
}
//[1,2,3,4,5,6,7]

稀疏数组

  • 当一个数组中大部分元素为0.或者为同一值的数组时，可以使用稀疏数组来保存该数组。
  • 稀疏数组的处理方式：
    • 记录数组一共有几行几列，有多少个不同值
    • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        int[][] a = new int[11][11];
        a[1][2]=1;
        a[2][3]=2;

        System.out.println("输出原始数组：");

        for (int[] ints : a) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //稀疏数组
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j] != 0)
                    sum++;
            }
        }

        int[][] b = new int[sum+1][3];

        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;

        int cout = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if(a[i][j] != 0){
                    cout++;
                    b[cout][0] = i;
                    b[cout][1] = j;
                    b[cout][2] = a[i][j];
                }

            }
        }

        System.out.println("输出稀疏数组");

        for (int[] ints : b) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //还原，读取稀疏数组
        int[][] c = new int[b[0][0]][b[0][1]];

        for (int i = 1; i < b.length; i++) {
            c[b[i][0]][b[i][1]] = b[i][2];
        }

        System.out.println("输出还原数组：");

        for (int[] ints : c) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

/*
这是一个长宽为11的棋盘，其中，棋盘的[1.2]位置为白棋，记作1,[2，3]为黑棋，记作2
*/
Java语言的基础学习

相关

标签