Java再谈方法

1.3再谈方法

1.3.1 什么是方法（函数）

①方法是类或对象行为特征的抽象，也称为函数。

②Java里的方法不能独立存在，所有的方法必须定义在类里。

修饰符 返回值类型 方法名（参数类型 形参1，参数类型 形参2，….）｛

                                          程序代码

                                          return 返回值;

｝

形式参数：在方法被调用时用于接收外部传入的数据的变量。

参数类型：就是该形式参数的数据类型。

返回值：方法在执行完毕后返还给调用它的程序的数据。

返回值类型：方法要返回的结果的数据类型。

实参：调用方法时实际传给函数形式参数的数据。

思考：如何理解方法返回值类型为void的情况 ?

1.3.2 方法的调用

方法只有被调用才会被执行；

方法调用的过程分析：

 

 

注  意：

①没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

②定义方法时，方法的结果应该返回给调用者，交由调用者处理。

③方法中只能调用方法，不可以在方法内部定义方法。

输入语句：

import java.util.Scanner;//不是自己创建的，要导入包

//实例化Scanner类的对象，通过此对象.nextXxx()调用，完成相应的功能。

Scanner s = new Scanner(System.in);

int i = s.nextInt();

1.3.3 方法的重载（overload）

要求：

①同一个类中

②方法名必须相同

③方法的参数列表不同（个数、类型或顺序不同）

 

注意：方法的重载与方法的返回值类型没有关系！

 

【eclipse快捷键】

1.单行注释：Ctrl +/，再次取消。

2.多行注释：Ctrl+shift +/，Ctrl+shift +\(反斜杠)取消。

3.格式化：Ctrl+shift+F

1.3.4 可变个数的形参的方法

格式：

对于方法的形参： 数据类型 ... 形参名

①可变个数的形参的方法与同名的方法之间构成重载

②可变个数的形参在调用时，个数从0开始，到无穷多个都可以。

③使用可变多个形参的方法与方法的形参使用数组是一致的。

④若方法中存在可变个数的形参，那么一定要声明在方法形参的最后。

⑤在一个方法中，最多声明一个可变个数的形参。

//如下四个方法构成重载

       //在类中一旦定义了重载的可变个数的形参的方法以后，如下的两个方法可以省略

//     public void sayHello(){

//            System.out.println("hello world!");

//     }

//     public void sayHello(String str1){

//            System.out.println("hello " + str1);

//     }

       //可变个数的形参的方法

       public void sayHello(String ... args){

              for(int i = 0;i < args.length;i++){

                     System.out.println(args[i] + "$");

              }

              //System.out.println("=====");

       }

      

       public void sayHello(int i,String ... args){

       //public void sayHello(String ... args,int i){

              System.out.println(i);

             

              for(int j = 0;j < args.length;j++){

                     System.out.println(args[j] + "$");

              }

       }

      

       public void sayHello1(String[] args){

              for(int i = 0;i < args.length;i++){

                     System.out.println(args[i]);

              }

       }

       //可变个数形参的使用的例子

//     public int getSum(int i,int j){

//            return i + j;

//     }

//     public int getSum(int i,int j,int k){

//            return i + j + k;

//     }

       public int getSum(int ... args){

              int sum = 0;

              for(int i = 0;i < args.length;i++){

                     sum += args[i];

              }

              return sum;

       }

1.3.5 Java内存的主要划分

好书推荐：深入java虚拟机第二版（重点第五章）

 

 

 

 

 

//对象没有更多的引用指向，则变成垃圾.

public class OOTest03{

       public static void main(String[] args){

              //u1是引用，保存内存地址指向堆中的对象。

              User u1 = new User();

              //程序执行到此处，u1不再指向堆中的对象。

       //对象变成了垃圾。

              u1 = null;

              //使用一个空的引用去访问成员，会出现什么问题？

              //System.out.println(u1.name); //java.lang.NullPointerException (空指针异常)

 

              Star s = new Star();

              s = null;

              s.sing(); //java.lang.NullPointerException

       }

}

class Star{

       //成员方法

       public void sing(){

              System.out.println("Sing a song!");

       }

}

1.3.6 Java的值传递机制

方法的值的传递：

①形参：方法声明时，方法小括号内的参数

②实参：调用方法时，实际传入的参数的值

规则：java中的参数传递机制：值传递机制

①形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量

②形参是引用数据类型的：将实参的引用类型变量的值（对应的堆空间的对象实体的首地址值）传递给形参的引用类型变量。

以下程序传递基本数据类型：

public class OOTest04{

       public static void m1(int i){

              i++;

              System.out.println("m1--->" + i); //11

       }

       public static void main(String[] args){ //入口

              int i = 10; //局部变量

              m1(i); //调用

              System.out.println("main--->" + i); //10

       }

}

 

 

以下程序传递引用数据类型：

public class OOTest05{

       public static void m1(Animal a){

              a.age++;

              System.out.println("m1--->" + a.age); //11

       }

       //入口

       public static void main(String[] args){

              //1.创建Animal对象

              Animal a = new Animal(10);

             

              m1(a);

             

              System.out.println("main--->" + a.age); //11

       }

}

//动物

class Animal{

      

       //Field

       int age;

      

       //Constructor

       Animal(int _age){

              age = _age;

       }

}

 

 

【例题1】

public static void main(String[] args) {

       TestArgsTransfer tt = new TestArgsTransfer();

       int i = 10;

       int j = 5;

       System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

//            //交换变量i与j的值

//            int temp = i;

//            i = j;

//            j = temp;

       tt.swap(i, j);//将i的值传递给m，j的值传递给n

       System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

}

//定义一个方法，交换两个变量的值

public void swap(int m,int n){

       int temp = m;

       m = n;

       n = temp;

       System.out.println("m:" + m + " n:" + n);

}

使用swap方法前后内存结构：

 

 

 

 

【例题2】

public class TestArgsTransfer1 {

       public static void main(String[] args) {

              TestArgsTransfer1 tt = new TestArgsTransfer1();

              DataSwap ds = new DataSwap();

              System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

              tt.swap(ds);

              System.out.println(ds);

              System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

       }

       //交换元素的值

       public void swap(DataSwap d){

              int temp = d.i;

              d.i = d.j;

              d.j = temp;

              System.out.println(d);//打印引用变量d的值

       }

}

class DataSwap{

       int i = 10;

       int j = 5;

}

 

 

【例题3】

class Value {

int i = 15;

}

class Test {

public static void main(String argv[]) {

Test t = new Test();

t.first();

}

public void first() {

int i = 5;

Value v = new Value();

v.i = 25;

second(v, i);

System.out.println(v.i);

}

public void second(Value v, int i) {

i = 0;

v.i = 20;

Value val = new Value();

v = val;

System.out.println(v.i + " " + i);

}

}