目录
一、成员方法
(一)方法的快速入门
在某些情况下，我们需要定义成员方法(简称方法)。比如人类：除了有一些属性外(年龄、姓名...)，还有一些行为，比如：说话、跑步、唱歌...这些都要用成员方法才能完成。
方法代码示例：
public class Method01 {
public static void main(String[] args) {
//方法使用
//1. 方法写好后，如果不去调用(使用)，不会输出
//2. 先创建对象 ,然后调用方法即可
Person p1 = new Person();
//调用getSum方法，同时num1=10, num2=20
//把 方法 getSum 返回的值，赋给 变量 returnRes
int returnRes = p1.getSum(10, 20);
System.out.println("getSum方法返回的值=" + returnRes);
}
}
class Person {
String name;
int age;
//方法(成员方法)
//添加getSum成员方法,可以计算两个数的和
//1. public 表示方法是公开的
//2. int :表示方法执行后，返回一个 int 值
//3. getSum 方法名
//4. (int num1, int num2) 形参列表，2个形参，可以接收用户传入的两个数
//5. return res; 表示把 res 的值， 返回
public int getSum(int num1, int num2) {
int res = num1 + num2;
return res;
}
}(二)方法的调用机制(重要)
下图是JVM内存中，方法的调用机制分析图：
成员方法的好处：提高代码的复用性；可以将实现的细节封装起来，然后供其他用户来调用即可。
(三)方法的定义
访问修饰符 返回数据类型 方法名(形参列表){
语句;
return 返回值;
}
- 形参列表：表示成员方法输出，例如上面的getSum(int num1,int num2)
- 返回数据类型：表示成员方法输出，void表示没有返回值
- 方法体：表示为了实现某一功能代码块
- return语句不是必须的：当有返回数据类型时，必须要有return语句
(四)注意事项和使用细节
1.访问修饰符(作用是控制方法的使用范围)
如果不写默认访问，有4种：public、protected、默认、private
2.返回的数据类型
- 一个方法最多有一个返回值，要想返回多个值，就可以返回一个数组；
- 返回类型可以为任意类型，包含基本数据类型或引用数据类型(数组，对象)；
- 如果方法要求有返回数据类型，则方法体中，最后的执行语句必须为return 值;而且要求返回值类型必须和return的值类型一致或兼容；
- 如果方法返回值类型是void，则方法体中可以没有return语句，或者只写return；
3.方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可，比如得到两个数的和getSum这种，开发中按照规范来命名。
4.形参列表
- 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1,int n2)
- 参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(int[][] map)
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数！
- 方法定义时的参数类型为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参；形参和实参的类型要一致或兼容、个数、顺序必须一致！
5.方法体
方法体中写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是方法体里面不能再定义方法！即：方法不能嵌套定义。
6.方法调用细节说明
1)同一个类中的方法调用：直接调用即可
public class MethodDetail { public static void main(String[] args) { A a = new A(); a.sayOK(); // print()方法被调用 n=10 // 继续执行sayOK()~~~ } } class A { public void print(int n) { System.out.println("print()方法被调用 n=" + n); } public void sayOK(){ // sayOK可以直接调用同类中其他成员方法 print(10); System.out.println("继续执行sayOK()~~~"); } }2)跨类中的方法A类调用B类方法：需要通过对象名调用。比如 对象名.方法名(参数);
public class MethodDetail { public static void main(String[] args) { A a = new A(); a.m1(); } } class B { public void hi() { System.out.println("B类中的hi()方法被执行"); } } class A { // 在A类中访问B类的方法 public void m1() { System.out.println("m1()方法被调用"); // 先创建B对象 B b = new B(); // 然后再调用方法 b.hi(); System.out.println("m1()方法继续执行"); } }3)特别说明：跨类的方法调用和方法的访问修饰符相关。
(五)传参机制
1.基本数据类型的传参机制
基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参！
因为多个方法的调用会在栈中开辟各自独立的空间，基本数据类型不是引用，不同的方法中的变化不会互相影响。
public class MethodParameter01 {
public static void main(String[] args) {
AB ab = new AB();
int a = 10;
int b = 20;
ab.swap(a, b); //调用swap
System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20
}
}
class AB {
public void swap(int a,int b){
System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了 a 和 b的交换
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}上述代码内存图：
2.引用数据类型的传参机制
引用数据类型传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参!
2.1方法传参传入数组
public class TestDemo1 {
public static void main(String[] args) {
AAB aab = new AAB();
int[] arr = {1, 2, 3};
aab.test100(arr);
System.out.println("main的arr输出：" + Arrays.toString(arr));
// test100的arr输出：[200, 2, 3]
// main的arr输出：[200, 2, 3]
}
}
class AAB {
// test100方法，接收一个数组，在方法中修改数组
public void test100(int[] arr) {
arr[0] = 200;
System.out.println("test100的arr输出：" + Arrays.toString(arr));
}
}
2.2方法传参传入对象
public class TestDemo1 {
public static void main(String[] args) {
AAB aab = new AAB();
Person p = new Person();
p.name = "jack";
p.age = 10;
aab.test200(p);
System.out.println("main 的p.age=" + p.age); // 10000
}
}
class Person {
String name;
int age;
}
class AAB {
public void test200(Person p) {
p.age = 10000;// 修改对象属性
}
}
2.3传参后对象=null
public class TestDemo1 {
public static void main(String[] args) {
AAB aab = new AAB();
Person p = new Person();
p.name = "jack";
p.age = 10;
aab.test200(p);
System.out.println("main 的p.age=" + p.age); // 10
}
}
class Person {
String name;
int age;
}
class AAB {
public void test200(Person p) {
// p.age = 10000;// 修改对象属性
p = null;
}
}
2.4传参后创建新的对象
public class TestDemo1 {
public static void main(String[] args) {
AAB aab = new AAB();
Person p = new Person();
p.name = "jack";
p.age = 10;
aab.test200(p);
System.out.println("main 的p.age=" + p.age); // 10
}
}
class Person {
String name;
int age;
}
class AAB {
public void test200(Person p) {
// p.age = 10000;// 修改对象属性
// p = null;
p = new Person();
p.name = "tom";
p.age = 99;
}
}
(六)对象的克隆
对象的克隆：编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象
注意：要求得到新对象和原来的对象，是两个独立的对象，只是他们的属性相同编写方法的思路：
1.方法的返回值类型：Person
2.方法的名字：copyPerson
3.方法的形参：(Person p)
4.方法体，创建一个新对象，并复制属性，返回即可
代码如下：
public class TestDemo1 {
public static void main(String[] args) {
AAB aab = new AAB();
Person p = new Person();
p.name = "alice";
p.age = 12;
Person p2 = aab.copyPerson(p);
System.out.println("p的hashCode：" + p.hashCode() +
" 姓名=" + p.name + " 年龄=" + p.age);
// p的hashCode：1163157884 姓名=alice 年龄=12
System.out.println("p2的hashCode：" + p2.hashCode() +
" 姓名=" + p2.name + " 年龄=" + p2.age);
// p2的hashCode：1956725890 姓名=alice 年龄=12
System.out.println(p == p2); // false
}
}
class Person {
String name;
int age;
}
class AAB {
public Person copyPerson(Person p) {
Person p2 = new Person();
p2.name = p.name;
p2.age = p.age;
return p2;
}
}
(七)方法的递归调用
1.方法的递归执行机制
递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于解决复杂问题，同时可以让代码变得简洁。方法的递归就是，栈不断地开辟后，直到遇到返回条件，才会一个个关闭。
给出一段代码，画出内存图：
public class Recursion01 {
public static void main(String[] args) {
T t1 = new T();
t1.test(4);
}
}
class T {
public void test(int n) {
if (n > 2) {
test(n - 1);
}
System.out.println("n=" + n);
}
}
上面的结果输出：
当添加else分支后，只会输出2，因为其他的方法没有打印部分，只有当n=2的时候才会打印：
public void test(int n) {
if (n > 2) {
test(n - 1);
} else {
System.out.println("n=" + n);
}
}2.使用递归的重要规则
- 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的，不会相互影响，比如n变量
- 如果方法中使用的是引用类型变量(比如数组、对象)，就会共享该引用类型的数据
- 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError
- 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
3.方法递归经典题目
3.1计算n的阶乘
public class Recursion01 {
public static void main(String[] args) {
T t1 = new T();
int result = t1.factorial(5);
System.out.println(result);
}
}
class T {
public int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}
}
}计算n的阶乘内存图：
3.2斐波那契数列
请使用递归的方式求出斐波那契数1,1,2,3,5,8,13...给你一个整数n，求出它的值是多
思路分析
1. 当n = 1 斐波那契数 是1
2. 当n = 2 斐波那契数 是1
3. 当n >= 3 斐波那契数 是前两个数的和
4. 这里就是一个递归的思路
public class TestDemo1 {
public static void main(String[] args) {
T t = new T();
System.out.println(t.fibonacci(7)); // 13
}
}
class T {
public int fibonacci(int n) {
if (n >= 1) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}else {
System.out.println("您的输入有误!");
return -1;
}
}
}3.3猴子吃桃问题
猴子吃桃问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天，想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？
思路分析——逆推
1. day = 10 时 有 1个桃子
2. day = 9 时 有 (day10 + 1) * 2 = 4
3. day = 8 时 有 (day9 + 1) * 2 = 10
4. 规律就是 前一天的桃子 = (后一天的桃子 + 1) *2 ==> 后一天的桃子 = day + 1
5. 递归
public class TestDemo1 {
public static void main(String[] args) {
// demo1();
T t = new T();
System.out.println(t.peach(1)); // 1534
}
private static void demo1() {
// 已知第10天剩下1个桃子
int peachesOnTenthDay = 1;
// 逆向推算到第一天
for (int i = 9; i >= 1; i--) {
// 每一天的桃子数量是前一天的桃子数量加1的两倍
peachesOnTenthDay = (peachesOnTenthDay + 1) * 2;
}
// 输出第一天摘的桃子数量
System.out.println("第一天猴子共摘了 " + peachesOnTenthDay + " 个桃子。");
}
}
class T {
public int peach(int day) {
if (day == 10) {
return 1;
} else if (day >= 1 && day <= 9) {
return (peach(day + 1) + 1) * 2;
} else {
System.out.println("day在1-10");
return -1;
}
}
}3.4汉诺塔
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子， 在一根柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一 根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
public class TestDemo1 {
public static void main(String[] args) {
T t = new T();
t.tower(3, 'A', 'B', 'C');
}
}
class T {
//num 表示要移动的个数, a, b, c 分别表示A塔，B 塔, C 塔
public void tower(int num, char a, char b, char c) {
// 如果只有一个盘num == 1
if (num == 1) {
// 把a移动到c即可
System.out.println(a + "->" + c);
} else {
//如果有多个盘，可以看成两个 , 最下面的和上面的所有盘(num-1)
//(1)先移动上面所有的盘到 b, 借助 c
tower(num - 1, a, c, b);
//(2)把最下面的这个盘，移动到 c
System.out.println(a + "->" + c);
//(3)再把b塔的所有盘，移动到c ,借助a
tower(num - 1, b, a, c);
}
}
}以3个圆盘为例，结果：
(八)方法的重载(OverLoad)
Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。重载减轻了起名和记名的麻烦。
注意事项和使用细节：
- 方法名：必须相同
- 形参列表：必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求
- 返回类型：无要求
方法重载示例：
public class OverLoad01 {
public static void main(String[] args) {
// System.out.println(100);
// System.out.println("hello,world");
// System.out.println('h');
// System.out.println(1.1);
// System.out.println(true);
//
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1, 2));
System.out.println(mc.calculate(1.1, 2));
System.out.println(mc.calculate(1, 2.1));
}
}
class MyCalculator {
//下面的四个 calculate方法构成了重载
//两个整数的和
public int calculate(int n1, int n2) {
System.out.println("calculate(int n1, int n2) 被调用");
return n1 + n2;
}
//没有构成方法重载, 仍然是错误的，因为是方法的重复定义
// public void calculate(int n1, int n2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// int res = n1 + n2;
// }
// 没有构成方法重载，也是方法的重复定义
// public int calculate(int a1, int a2) {
// System.out.println("calculate(int n1, int n2) 被调用");
// return a1 + a2;
// }
//一个整数，一个double的和
public double calculate(int n1, double n2) {
return n1 + n2;
}
//一个double ,一个int的和
public double calculate(double n1, int n2) {
System.out.println("calculate(double n1, int n2) 被调用..");
return n1 + n2;
}
//三个int的和
public int calculate(int n1, int n2,int n3) {
return n1 + n2 + n2;
}
}(九)可变参数
注意事项和使用细节
- 可变参数的实参可以为0个或任意多个。
- 可变参数的实参可以为数组
- 可变参数的本质就是数组
- 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
- 一个形参列表中只能出现一个可变参数
public class TestDemo1 {
public static void main(String[] args) {
T t = new T();
int[] arr = {1, 2, 3};
t.sum(arr); // 传入数组
t.sum(1, 5, 9); // 传入多个参数
}
}
class T {
// 参数列表可变
public void sum(int... nums) {
int n = 0;
for (int i = 0; i < nums.length; i++) {
n += nums[i];
}
System.out.println("接收的参数个数=" + nums.length);
System.out.println("和为：" + n);
}
}public class TestDemo1 {
public static void main(String[] args) {
T t = new T();
String res = t.showScore("张三", 85.6, 90.5, 60);
System.out.println(res);
// 张三的3门课程总分为：236.1
}
}
class T {
// 参数列表可变
public String showScore(String name, double... num) {
double sum = 0;
for (double score : num) {
sum += score;
}
return name + "的" + num.length + "门课程总分为：" + sum;
}
}二、作用域
(一)基本使用
- 在Java编程中，主要的变量就是属性(成员变量)和局部变量。
- 局部变量一般是指在成员方法中定义的变量。
- 全局变量：属性，作用域为整个类体；局部变量：除了属性之外的其他变量，作用域为定义它的代码块中。
- 全局变量(属性)可以不赋值，直接使用，因为有默认值；局部变量必须赋值后，才能使用，因为没有默认值。
- 细节: 属性可以加修饰符(public protected private..)；局部变量不能加修饰符。
(二)注意事项和细节使用
- 属性和局部变量可以重名，访问时遵循就近原则。
- 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
- 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁；局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
- 全局变量/属性：可以被本类使用，或其他类使用(通过对象调用)；局部变量：只能在本类中对应的方法中使用。
- 全部变量/属性可以加修饰符；局部变量不可以加修饰符。
(三)跨类访问对象属性的2种方式
public class TestDemo1 {
public static void main(String[] args) {
T t = new T();
t.test(); // 第1种跨类访问对象属性的方式
Person p = new Person();
t.test2(p);// 第2种跨类访问对象属性的方式
}
}
class T {
// 参数列表可变
public void test() {
Person p1 = new Person();
System.out.println(p1.name);
}
public void test2(Person p) {
System.out.println(p.name);
}
}
class Person {
String name = "jack";
public void say() {
String name = "king"; // 属性和局部变量可以重名，访问时遵循就近原则
System.out.println("say() name=" + name);
}
}
扫一扫
1351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
