Day10-Java

Java方法

何为方法

• System.out.println() 是什么

  • System
    • 是java.lang包下的一个final 类，提供了系统级的功能（标准输入 / 输出、环境变量访问等）。
  • out
    • 是System类里的静态成员变量，类型为PrintStream，代表 “标准输出流”，默认关联控制台。
  • println()
    • 是PrintStream类的一个方法，作用是把内容输出到控制台，输出完成后自动换行。

• Java方法是语句的集合，它们在一起执行一个功能

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

• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句快递集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样有利于后期的扩展

package com.Kong.method;

public class Demo01 {
    public static void main(String[] args) {
        //实际参数：调用方法时实际传给方法的数据
        // int sum = add(1, 1);
        //System.out.println(sum);
        test();
    }

    //加法
    //形式参数，用来定义作用的
    public static int add(int a, int b) {
        return a + b;
    }

    public static void test() {
        int count = 0;
        for (int i = 0; i <= 1000; i += 5) {
            System.out.print(i + "\t");
            count++;
            if (count % 3 == 0) {
                System.out.println();
                //System.out.print("\n");
            }
        }
    }
}

方法的定义

• Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

• 方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

  • 修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

访问控制修饰符	访问范围	通俗理解
public	所有类都能访问（跨包、跨项目都可以）	完全公开
protected	同一个包内的类 + 不同包的子类可以访问	给 “家人和邻居” 开放
（默认 / 不写）	只有同一个包内的类可以访问	仅限 “邻居” 使用
private	只有当前类内部可以访问	完全私密，仅自己可见

非访问修饰符	作用	典型场景
static	修饰的内容属于 “类本身”，不依赖对象实例	静态方法（如 main）、静态变量、静态工具类
final	修饰的内容 “不可变”：类：不能被继承方法：不能被重写变量：只能赋值一次	常量定义、防止类被篡改
abstract	修饰的类 / 方法不完整：类：不能实例化，只能被继承方法：没有方法体，必须被子类实现	抽象类、模板方法设计
synchronized	修饰方法 / 代码块，保证同一时间只有一个线程执行	多线程安全场景
volatile	修饰变量，禁止编译器优化，保证多线程间的变量可见性	多线程并发编程
transient	修饰成员变量，序列化时不保存该变量的值	不需要持久化的敏感数据
native	修饰方法，表示方法的实现由其他语言（如 C/C++）完成	调用系统底层 API

• 返回值类型：方法可能会返回值，returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void

返回值类型分类	包含类型	作用说明	写法示例
无返回值	void	方法做完事，不返回任何数据	void test()
基本类型	8 种：byte、short、int、longfloat、double、char、boolean	返回单个基础数值	int sum() boolean check()
引用类型	String、自定义类、数组、接口	返回对象 / 字符串 / 数组	String getName() Student getStu()

• 方法名：是方法的实际名称，方法名和参数表共同构成方法签名
• 参数类型：参数像是一个占位符。当方法被调用的时候，传递值给参数，这个值被称为实参或者变量，参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  • 形式参数：在方法被调用时用于接受外界输入的数据。
  • 实参：调用方法时实际传给方法的数据。
• 方法体：方法体包含具体的语句，定义该方法的功能。

修饰符 返回值类型 方法名(参数类型 参数名){
    …
    方法体
    …
    return 返回值;
}

package com.Kong.method;

public class Demo02 {
    public static void main(String[] args) {
        double max1=CompareSize(1.2, 6);
        //System.out.println(max1);
        double max2=CompareSize(6, 3.6);
        //System.out.println(max2);
        double max3=CompareSize(max1, max2);
        System.out.println(max3);
        double sum=max1+max2+max3;
        System.out.println(sum);
    }

    //比大小
    public static double CompareSize(double a, double b) {
        if (a > b) {
            System.out.println(a + " is greater than " + b);
            return a;
        }
        if (a < b) {
            System.out.println(a + " is less than " + b);
            return b;
        } else {
            System.out.println(a + " is equal to " + b);
            return a;
        }
    }
}

方法调用

• 调用方法：对象名.方法名(实参列表)
• Java支持两种调用方法的方式，根据方法是否返回值来选择
• 当方法返回一个值的时候，方法调用通常被当作一个值。eg：

int larger = max(30,40);

• 如果方法返回的值为void，方法的调用一定是一条语句。

System.out.println("Hello,Kongmi!");

• 拓展：值传递(Java)和引用传递
  • 值传递：方法调用时，会把实参的一个副本传给方法里的形参。
    • 方法里修改的是 “副本”，不会影响方法外面的原始变量。
    • 这是 Java 唯一的参数传递方式。
  • 引用传递：方法调用时，直接把实参的内存地址传给形参，形参和实参指向同一个内存空间。
    • 方法里修改形参，会直接修改外面的原始变量。
    • Java 不支持这种方式。

方法的重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 方法的重载规则：
  • 方法名称必须相同
  • 参数列表必须不同(个数不同，类型不同或者参数排列顺序不同等)
  • 方法的返回类型不做要求
  • 仅仅返回类型不同不足以成为方法的重载
• 实现理论：
  • 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错

命令行传参

• 有时候你希望运行一个程序时候再传递给它消息，这要靠传递命令行参数给main（）函数实现

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

可变参数

• JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号
• 一个方法中只能指定一个可变参量，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

package com.Kong.method;

public class Demo04 {
    public static void main(String[] args) {
        //Demo04 demo04 = new Demo04();
        //demo04.test(1,2,3,4,5,6,7,8);
        printMax(221,22,57,97,553.1);
        printMax(new double[]{0,1,2,3,4});
    }
    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        // 找最大值
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}