1、匿名对象的使用

我们创建的对象，没有显示的赋值给一个变量名。即为匿名对象。
特征：匿名对象只能调用一次。

/* 
 * 三、匿名对象的使用
 * 3.使用:如下
 */
public class InstanceTest {
    public static void main(String[] args) {
        Phone p = new Phone();
//        p = null;
        System.out.println(p);
        p.sendEmail();
        p.playGame();
        //匿名对象
//        new Phone().sendEmail();
//        new Phone().playGame();
        new Phone().price = 1999;
        new Phone().showPrice();    //0.0
        //*******************************
        PhoneMall mall = new PhoneMall();
//        mall.show(p);
        //匿名对象的使用
        mall.show(new Phone());    
    }
}
class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}
class Phone{
    double price;    //价格
    public void sendEmail(){
        System.out.println("发邮件");
    }
    public void playGame(){
        System.out.println("打游戏");
    }
    public void showPrice(){
        System.out.println("手机价格为:" + price);
    }
}

2、方法的重载(overload)

定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”:同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
判断是否重载
与方法的返回值类型、权限修饰符、形参变量名、方法体都无关。
在通过对象调用方法时，如何确定某一个指定的方法：
方法名—-》参数列表

3、可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

可变个数形参的方法

• jdk 5.0新增的内容

• 具体使用：

  • 可变个数形参的格式：数据类型 … 变量名
  • 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
  • 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
  • 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
  • 可变个数形参在方法中的形参中,必须声明在末尾。

  • 可变个数形参在方法中的形参中，最多只能声明一个可变形参。 ```java public class MethodArgs {

    public static void main(String[] args) { MethodArgs test = new MethodArgs(); test.show(12); // test.show(“hell0”); // test.show(“hello”,”world”); // test.show();

    test.show(new String[] { “AA”, “BB”, “CC” }); }

    public void show(int i) {

    }

    // public void show(String s){ // System.out.println(“show(String)”); // } public void show(String… strs) { System.out.println(“show(String …strs)”);

    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);
    }
}
// 此方法与上一方法不可共存
// public void show(String[] strs){
//
// }
public void show(int i, String... strs) {
}
//The variable argument type String of the method show must be the last parameter

// public void show(String… strs,int i,) { // // } }

<a name="LATaL"></a>
# 4、方法参数的值传递机制(重点！！！)
关于变量的赋值<br />如果变量是基本数据类型，此时赋值的是变量所保存的数据值。<br />如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。<br />  
```java
public class ValueTransferTest {
    public static void main(String[] args) {
        System.out.println("**********基本数据类型：***********");
        int m = 10;
        int n = m;
        System.out.println("m = " + m + ", n = " + n);
        n = 20;
        System.out.println("m = " + m + ", n = " + n);
        System.out.println("***********引用数据类型:********");
        Order o1 = new Order();
        o1.orderId = 1001;
        Order o2 = o1;    //赋值后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
        o2.orderId = 1002;
        System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
    }
}
class Order{
    int orderId;
}

1、针对基本数据类型

方法的形参的传递机制：值传递
形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
值传递机制：
如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。

public class ValueTransferTest1 {
    public static void main(String[] args) {
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ", n = " + n);
        //交换两个变量的值的操作
//        int temp = m;
//        m = n;
//        n = temp;
        ValueTransferTest1 test = new ValueTransferTest1();
        test.swap(m, n);
        System.out.println("m = " + m + ", n = " + n);
    }
    public void swap(int m,int n){
        int temp = m;
        m = n;
        n = temp;
    }
}

2、针对引用数据类型

如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。

public class ValueTransferTest2 {
    public static void main(String[] args) {
        Data data = new Data();
        data.m = 10;
        data.n = 20;
        System.out.println("m = " + data.m + ", n = " + data.n);
        //交换m和n的值
//        int temp = data.m;
//        data.m = data.n;
//        data.n = temp;
        ValueTransferTest2 test = new ValueTransferTest2();
        test.swap(data);
        System.out.println("m = " + data.m + ", n = " + data.n);
    }
    public void swap(Data data){
        int temp = data.m;
        data.m = data.n;
        data.n = temp;
    }
}
class Data{
    int m;
    int n;
}