成员方法使用细节和练习

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阶乘的意思
    }
  }
}