1. 成员方法使用细节 208
//成员方法使用细节
public class Test26
{
public static void main(String[] args)
{
A a = new A();
a.print(2);
a.sayOk();
a.m1();
}
}
class A
{
//同一类中的方法调用：直接调用
public void print(int n)
{
System.out.println("你好世界");
}
public void sayOk()
{
print(10);//直接调用print方法
}
//跨类中的方法A类调用B类中的方法：需要通过对姓名调用
public void m1()
{
//创建一个B类对象，然后在调用方法即可
System.out.println("m1方法被调用");
B b = new B();
b.h1();
System.out.println("m1继续执行");
}
}
class B
{
public void h1()
{
System.out.println("中国");
}
}
2. 成员方法练习 209
2.1 编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean
//编写类 AA ，有一个方法：判断一个数是奇数 odd 还是偶数, 返回 boolean
public class Test26
{
public static void main(String[] args)
{
AA a = new AA();
if(a.isOdd(4))
{
System.out.println("是偶数");
}
else
{
System.out.println("是奇数");
}
}
}
class AA
{
//思路
//1. 方法的返回类型 boolean
//2. 方法的名字 isOdd
//3. 方法的形参 (int num)
//4. 方法体 , 判断
public boolean isOdd(int num)
{
// if(num%2==0)
// {
// return true;//偶数
// }
// else
// {
// return false;//奇数
// }
// //简化
// return num%2==0?true:false;
//再简化
return num%2==0;
}
}
2.2 根据行、列、字符打印 对应行数和列数的字符，比如行：4，列：4，字符#,则打印相应的效果
//根据行、列、字符打印 对应行数和列数的字符，比如
//行：4，列：4，字符#,则打印相应的效果
public class Test26
{
public static void main(String[] args)
{
AA a = new AA();
a.print(4,4,'#');
}
}
class AA
{
//思路
//1. 方法的返回类型 void
//2. 方法的名字 print
//3. 方法的形参 (int row, int col, char c)
//4. 方法体 , 循环
public void print(int row,int col,char c)
{
for(int i=0;i<row;i++)//行
{
for(int j=0;j<col;j++)//打印列
{
System.out.print(c);
}
System.out.println();//换行
}
}
}
3. 成员方法传参机制 210
3.1 基本数据类型的传参机制
3.1.1 基本数据类型，传递的是值，形参的任何改变不会影响实参
3.1.2 判断输出 210
public class Test26
{
public static void main(String[] args)
{
AA aa = new AA();
int a=10;
int b=20;
aa.swap(a,b);
System.out.println("a="+a+"b="+b);//10 20
}
}
class AA
{
public void swap(int a,int b)
{
System.out.println("交换前："+a+" "+b);//10 20
//交换
int tmp =a;
a=b;
b=tmp;
System.out.println("交换后："+a+" "+b);//20 10
}
}
3.2 引用数据类型的传参机制 211
3.2.1 引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
3.2.2 看案例
B 类中编写一个方法 test1，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化
public class Test26
{
public static void main(String[] args)
{
int arr[] = {1,2,3};
B b = new B();
b.test1(arr);//调用方法
System.out.println("\nmain的 arr 数组");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");//200 2 3
}
System.out.println();
}
}
class B
{
public void test1(int arr[])
{
arr[0]=200;
System.out.println("test1的 arr 数组");
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i]+" ");//200 2 3
}
}
}
B 类中编写一个方法 test2，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变 化？会变化.
public class Test26
{
public static void main(String[] args)
{
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test2(p);//调用方法
System.out.println("main中的p="+p.age);//10000
}
}
class Person
{
String name;
int age;
}
class B
{
public void test2(Person p)
{
p.age=10000;
}
}
4. 成员传参机制练习 212
4.1 将p=null，判断输出
public class Test27
{
public static void main(String[] args)
{
B b = new B();
Person p = new Person();
p.name = "jack";
p.age = 10;
b.test2(p);//调用方法
//如果test2执行p=null，那么结果是10
System.out.println("main中的p="+p.age);//10
}
}
class Person
{
String name;
int age;
}
class B
{
public void test2(Person p)
{
p=null;////注意是p置空是断掉了test2中的p与Person对象的联系，并不会影响main中的p与Person对象的联系
}
}
4.2 编写类 MyTools 类，编写一个方法可以打印二维数组的数据。
public class Test27
{
public static void main(String[] args)
{
int arr[][]={{1,2,3},{4,5,6},{7,8,9}};
Tool t = new Tool();
t.print(arr);
}
}
class Tool
{
public void print(int arr[][])
{
for(int i=0;i<arr.length;i++)
{
for(int j=0;j<arr[i].length;j++)
{
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
4.3 编写一个方法 copyPerson，可以复制一个 Person 对象，返回复制的对象。克隆对象， 注意要求得到新对象和原来的 对象是两个独立的对象，只是他们的属性相同 213
public class Test27
{
public static void main(String[] args)
{
Person p = new Person();
p.name = "米兰";
p.age = 100;
//创建tools
MyTools tools = new MyTools();
Person p2 = tools.copyPerson(p);
//到此 p 和 p2 是 Person 对象，但是是两个独立的对象，属性相同
System.out.println("p的属性 age="+p.age+" 名字="+p.name);
System.out.println("p2的属性 age="+p2.age+" 名字="+p2.name);
//这里提示： 可以同 对象比较看看是否为同一个对象
System.out.println(p==p2);//false
}
}
class Person
{
String name;
int age;
}
class MyTools
{
//编写方法的思路
//1. 方法的返回类型 Person
//2. 方法的名字 copyPerson
//3. 方法的形参 (Person p)
//4. 方法体, 创建一个新对象，并复制属性，返回即可
public Person copyPerson(Person p)
{
Person p2 = new Person();//创建一个新对象
p2.name = p.name;//把原来对象的名字赋给 p2.name
p2.age = p.age;//把原来对象的年龄赋给 p2.age
return p2;
}
}
5. 方法递归调用 215
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变 得简洁
5.1 例1 判断输出
public class Test27
{
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);
}
}
5.2 例2 阶乘
public class Test27
{
public static void main(String[] args)
{
T t1 = new T();
int res = t1.factorial(5);
System.out.println("res="+res);
}
}
class T
{
public int factorial(int n)
{
if(n==1)
{
return 1;
}
else
{
return factorial(n-1)*n;//factorial阶乘的意思
}
}
}
