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);}
}
