java中的oop（二）、方法、对象数组、重载、参数.

public class Person {
    /*成员变量存储在堆中*/
    String name;
    int age;

    public void sleep() {
        String hour = "18小时"; //局部变量；存储在栈中；
        System.out.println("he is sleepping!");
    }

    public void setAge(int age) {   //局部变量--形式参数；

    }
    public int getInt() {
        return 1;
    }

    public String getName() {
        return name;
    }
}

public class Students {
    public static void main(String[] args) {
        Person lily = new Person();
        lily.age = 15;
        lily.name = "lily";
        System.out.println("lily" + lily.age);
    }
}

方法

public class Method {
    public static void main(String[] args) {
        Person p1 = new Person();
        int int1 = p1.getInt();
        System.out.println(int1);
    }
}

方法：（函数、面向过程）

抽象出一个公共方法，减少冗余；

1、声明：

权限修饰符 [其他修饰符] 返回值类型 方法名(形参列表) 【throw 异常类型】 {
    方法体；
}
方法头（）{
    方法体；
}

2、权限修饰符：

private、缺省、protected、public;

3、返回值类型：void/

(1)其他类型需配合return使用；

4、方法名

(1)

5、变量列表：

(1)局部变量、可以是多个；

(2)格式：（类型1 形参1， 类型2 形参2）

6、一个方法中可以调用另一个方法；

7、方法内不能定义方法；

关键字 return;

1、结束一个方法；

2、结束一个方法，并返回一个值（结果）；

对象数组

Public class student {
    String name;
}
Student[] studentArr = new Student[10];
for (int i = 0; i < studentArr.length; i++) {
    studentArr[i].name = "name" + i;
    studentArr[i].age = i;
}

重载

方法名一样，参数不同；

类似很多工具类里面的同名不同参的方法；

1、定义

(1)同一个类中，多个同名方法，参数列表不同；

2、两同一不同

(1)同类、同方法

(2)参数不同：个数不同，类型不同；顺序不同；

(3)注意：与返回值类型等其他的无关；

/*both methods have same erasure*/
public void add(String str){

}
public String add(String str) {

}

3、同一个类中不允许两个同样的方法；

(1)同名不同参数，不是同样的方法；

(2)编译器认为是两个方法；

Int[] arr = new int[]{1,2,3};
Arr; //0xaavv// 地址值；
Char[] arr2 = new char[] {‘a’, ’b’, ’c’}
Sout(arr2);// abc;// 因为sout方法重载了char数组；

public class Overload {
    public static void main(String[] args) {
        Overload overl = new Overload();
        overl.add("");
        overl.add(1,2);
        overl.add((double)1,2);
        overl.add(1,2,3);
    }
    public void add(int i, int j){

    }
    public double add(double i, double j){
        return 1.1;
    }
    public  void add(int i, int j, int k){

    }
    public void add(String str){

    }
    /*both methods have same erasure*/
//    public String add(String str) {
//
//    }
    /**
     * =======
     */
}

可变个数形参方法 见代码Args_20230718_；

说明：在调用方法时，参数个数可以为0/1/2/3/4.。。。
链接

public class Args2_20230718 {
    public static void main(String[] args) {
        Args2_20230718 args2 = new Args2_20230718();
        args2.link("_");
        args2.link("_", "healthy", "zhang");
    }
    void link(String str, String... strs) {
        String res = "";
        for (int i = 0; i < strs.length; i++) {
           res = res + strs[i] + str;
        }
        System.out.println(res);
    }
}

同一个类中，也可以构成重载；

特例：数组类型的不可以和可变形参重载；
可变个数的形参必须是最后一个参数；

参数传递

值传递机制：

基础数据类型，值传递

引用数据类型，传递的是地址值；
对象类型这样写，传递的也是地址值；

Order order1 = new Order();
Order order2 = order1;

可变参数个数方法：（js中的剩余参数）

public class ValueTransfer {
    public static void main(String[] args) {
//        基础类型的局部变量；
        int m = 1;
        int n = 1;
        m++;
        System.out.println(m + "," + n);
        /*引用类型的局部变量*/
        int[] arr1 = new int[]{1,2,3,4,5};
        int[] arr2 = arr1;  //传递地址值；
        arr2[0] = 10;
        System.out.println(arr1[0] + "," + arr2[0]);
        System.out.println("=====对象类型======");
        /*对象类型*/
        Order order1 = new Order();
        System.out.println(order1.orderId);
        order1.orderId = 1;
        System.out.println(order1.orderId);
        System.out.println("=====order2======");
        Order order2 = new Order();
        order1.orderId = 1;
        System.out.println(order2.orderId);
        order2.orderId = 2;
        System.out.println(order2.orderId);
        System.out.println("=====order3======");
        Order order3 = order2;      //传递的也是地址值；
        System.out.println(order3.orderId);
        order3.orderId = 222;
        System.out.println(order3.orderId);
        System.out.println(order2.orderId);
    }
}

class  Order{
    int orderId;
}

public class ValueTransfer2 {
    public static void main(String[] args) {
        ValueTransfer2 transfer2 = new ValueTransfer2();
        /*基础数据类型，值传递；*/
        int m = 1;
        transfer2.add(m);
        System.out.println(m);  //1；
        /*引用类型传递地址值*/
        int[] arr = new int[] {1,2,3};
        transfer2.add(arr);
        System.out.println(arr[0]); //2；
        System.out.println("=====对象类型======");
        Order2 order2 = new Order2();
        /*引用类型传递地址值*/
        System.out.println(order2.id);  //0;
        transfer2.add(order2);
        System.out.println(order2.id);  //1;
    }

    public void add(int i) {
        i++;
    }
    public void add(int[] arr) {
        arr[0]++;
    }
    public void add(Order2 order2) {
        order2.id++;
    }
}

class Order2{
    int id;
}

public class Person {
    public static void main(String[] args) {
        Animal ani = new Animal();
        ani.setLegs(1);
//        System.out.println(ani.legs); 设置为private之后不可这样调用；
        System.out.println(ani.getLegs());//设置为private之后需要这样调用；
    }
}
class Animal{
    String name;

    /*私有化*/
    private int legs;
    public void setLegs(int l) {
        if(legs >= 0) {
            legs = l;
//            this.legs = l;
        }
    }
    public int getLegs() {
        return legs;
    }
    public void eat() {
        System.out.println("eat");
    }
}

public class Args {
    public static void main(String[] args) {
        Args arg = new Args();
        arg.getInt();
        arg.getInt(1);
        arg.getInt(2, 1);
//        arg.getInt(1,2, 1,4);
    }
    /*可变个数的形参方法*/
    public void getInt(int ... nums){
        System.out.println(11111);
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]);
        }
    }
    /*可变个数的形参必须是最后一个参数；*/
    public void getInt(int i, int ... nums) {
        System.out.println(4444444);
    }
//    public void getInt(int[] nums) {};//'getInt(int[])' is already defined in 'com.healthy.zhang.overload20230717.Args'
    public void getInt(int i, int j) {
        System.out.println(2222);
    }
    public void getInt(int i) {
        System.out.println(3333);
    }


}

递归方法

直接递归：直接自己调用自己；
间接递归：A調B；B调c，C调A；
隐式循环；

递归占用内存较多，比循环要慢；如果能用循环不用递归；

public class Recursion {
    public static void main(String[] args) {
        int n = 10;
        int r = recur(n);
        System.out.println(r);
    }
    static int recur(int n) {
        if(n<=1) {
            return n * 1;
        }
        return n * recur(n-1);
    }
}