五（三）、方法

 一、方法：类应该具有的功能；比如 Math.random();Arrays.sort();....

　　public void eat() {

　　　　System.out.println("人可以吃饭");

　　}

　　public void talk(String lanuage) {

　　　　System.out.println("人可以说话，使用"+lanuage+"语言。");

　　}

　　public String getName(){}

 

1.1方法的声明：

　　权限修饰符 返回值类型 方法名（形参列表）{

　　　　方法体

　　　　};

　　1.1.1 权限修饰符 private public 缺省 protected

　　1.1.2 返回值类型 有返回值、没有返回值；

　　　　①若有返回值，在声明时需要指定返回值类型，在方法中使用return 返回指定类型的变量or常量

　　　　②若方法没有返回值，则方法声明时使用void来表示，通常没有返回值的方法中，就不用return返回；如果只用 只能 "return;"表示结束此方法；

　　1.1.3 我们定义方法该不该有返回值？凭经验；

　　1.1.4方法名 属于标识符；需要遵循标识符规范；

　　1.1.5 形参列表：方法可以声明0个 1个或者多个形参；格式：数据类型1 形参1，数据类型2 形参二；

　　1.1.6 方法体：方法功能的体现；

二、再谈方法

　　1.方法的重载：在同一个类中，允许存在一个以上的同名方法，只用他们的参数个数或者参数类型不同即可。“两同一不同”
同类，同方法名；参数列表不同；参数个数不同，参数类型不同；
重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。调用时感觉方法参数列表的不同来区分；
举例；Arrays.sort,/binerySearch();
判断是否是重载：跟方法的修饰符、返回值类型，形参变量名，方法体都没有关系；、
在通过对象调用方法时，如何确定指定方法？1.方法名，2.参数列表
　　2.可变个数的形参，
a.格式：数据类型 ...变量名
b.当调用可变个数形参方法时，传入的参数个数可以使 0个，1个，2个。。。
c.可变个数形参方法与本类方法名相同，形参不同的方法之间构成重载；但是调用确定参数的方法
d.可变个数形参的方法与本来方法相同，形参了下也相同的数组之间不构成重载，也就是说，二者不能共存。
e.可变个数形参在方法的形参中，必须声明在末尾；
f.可变个数形参在方法的形参中,最多只能声明一个可变形参；   

public static void main(String[] args) {
        Day9Method10 day9Method10 = new Day9Method10();
        //重载
        day9Method10.getSum(1,2);//默认调用 getSum(int i, int j)若getSum(int i, int j)注释掉，则调用getSum(double i, double j)
        day9Method10.show(0, "A","B");
        day9Method10.show(0, "A");//优先调用确定参数的方法
    }

    public void getSum(int i, int j) {

    }

    public void getSum(double i, double j) {

    }

    public void getSum(String i, String j) {

    }
    
    //可变个数的形参 str参数个数可变
    public void show(int a,String ...str) {
        System.out.println("可变参数："+str);
        for(int i=0;i<str.length;i++) {
            System.out.println(str[i]);
        }
    }
    public void show(int a,String str) {
        System.out.println(str);
        
    }

 三、关于变量的赋值

1.如果变量是基本数据类型，此时赋值的是变量所保存的数据值；
2.如果变量是引用数据类型，此时赋值的是所保存的数据的地址值

 四、方法形参的值传递机制

  1.形参：方法定义时声明的小括号里面的参数；
   实参：方法调用时，（实际传递给形参的数据）
  2.值传递机制；
          a.如果参数是基本数据类型，此时实参赋值给形参的是，实参真实存储的数据值
          b.如果参数是引用数据类型，此时实参赋值给形参的是，实参的地址值；

public static void main(String[] args) {
        System.out.println("****************基本数据类型************************");
        int m = 10;
        int n = m;
        System.out.println("m = "+m+",n = "+n);//m = 10,n = 10
        n = 20;
        System.out.println("m = "+m+",n = "+n);//m = 10,n = 20
        
        System.out.println("****************引用数据类型************************"); 
        Order  o1 = new Order();
        o1.orderId = 1001;
        Order o2 = o1;
        System.out.println("o1.orderId = "+o1.orderId+",o2.OrderId = "+o2.orderId);//o1.orderId = 1001,o2.OrderId = 1001
        o2.orderId = 1002;
        System.out.println("o1.orderId = "+o1.orderId+",o2.OrderId = "+o2.orderId);//o1.orderId = 1002,o2.OrderId = 1002
        
        //交换两个变量的值
        Day9ValueTransfer15  day9ValueTransfer15 = new Day9ValueTransfer15();
        System.out.println("m = "+m+",n = "+n);
        day9ValueTransfer15.swap(m, n);
        System.out.println("m = "+m+",n = "+n);
        Data  data = new Data();
        data.m = 10;
        data.n = data.m;
        data.n = 20;
        System.out.println("m = "+data.m+",n = "+data.n);
        day9ValueTransfer15.swap1(data);
        System.out.println("m = "+data.m+",n = "+data.n);
    }
    
    //交换两个变量的值
    public void swap(int m,int n) {
        int temp = m;
        m = n;
        n = temp;
    }
    
    //交换两个变量的值
        public void swap1(Data data) {
            int temp = data.m;
            data.m = data.n;
            data.n = temp;
        }
}
class Order{
    int  orderId;
    
}

class Data{
    int m;
    int n;
}

基本数据类型，传递的是数据值，所以n = m，改变n的值，不会影响m的值

引用数据类型，传递的是地址值，所以”******************引用数据类型*************“，更改orderId会影响两对象相应的值；

具体请查看内存解析的详解：堆内存 和 栈内存的简单理解

这里String的值传递也是一个比较好面试题，可以好好看看https://www.cnblogs.com/lixiuming521125/p/14404125.html#_label4

 

补充题目：为什么for(Integer item: arr)不可以改变基本类型对象数组的值，却可以改变引用类型对象数组（比如for(Person item :arr)）的值呢?（这里的引用类型对象不包括String）

@Test
    public void testFor() {
        Integer[] intArr = new Integer[]{1,2,3,4};
        for(int i = 0;i<intArr.length;i++) {
            intArr[i] = intArr[i]+i;
        }
        System.out.println("***********普通for循环***********");
        for(int i = 0;i<intArr.length;i++) {
            System.out.print(intArr[i]);
        }
        System.out.println("");
    }
    
    @Test
    public void testFor1() {
        Integer[] intArr = new Integer[]{1,2,3,4};
        int count = 0;
        for(int i :intArr) {
            i= i+count;
            count++;
        }
        System.out.println("***********增强for循环更改基本类型数组的值***********");
        for(int i = 0;i<intArr.length;i++) {
            System.out.print(intArr[i]);
        }
        System.out.println("");
    }

    @Test
    public void testFor2() {
        Person person1 = new Person();
        Person person2 = new Person();
        person1.setName("tom");
        person1.setAge(10);
        person2.setName("jerry");
        person2.setAge(10);
        Person[] intArr = new Person[] {person1,person2};
        for(Person item :intArr) {
            item.setAge(11);
        }
        System.out.println("***********增强for循环更改引用类型数组的值***********");
        for(int i = 0;i<intArr.length;i++) {
            System.out.print(intArr[i]);
        }
        System.out.println("");
    }

结果为：

***********普通for循环***********
1357
***********增强for循环更改基本类型数组的值***********
1234
***********增强for循环更改引用类型数组的值***********
Person [age=11, name=tom]Person [age=11, name=jerry]

附上Person :

public class Person {

    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
    
    
}