类和对象（二）

给对象引用变量赋值

对象变量的赋值和我们的直觉期望不同，例如：

Box box1=new Box();
Box b2=b1;

这种情况下b1,b2将引用同样的对象，将b1值赋给b2并没有分配任何内存或对原对象做任何部分的拷贝，所以，接下来的例子中，对b1的赋值仅仅使b1脱离初始对象，而没有影响对象或者b2 ,

Box box1=new Box();
Box b2=b1;
b1=null;

这里b1被设置为空，但是b2仍然指向原来的对象，所以，当你将一个对象引用赋给另一个对象引用时，你并没有创建该对象的一个拷贝，而是仅仅对引用的拷贝。

方法

类通常由两个部分构成：实例变量和方法，方法的通用格式是：

方法返回的数据类型  方法名（自变量列表）{ 方法体  }
void tiji(){
System.out.println(chang*kuan*gao);
}

方法返回的数据类型可以是任何合法有效的数据类型，包括你创建的类的类型，如果该方法不返回任何值，则它的返回值必须为void，方法名除了被当前作用域中的其他项使用的标识符以外，方法名可以是任何合法的标识符，自变量列表是一系列类型和标识符对，用逗号分开，自变量本质上是变量，它接收方法被调用时传递给方法的参数值，如果方法没有自变量，那么自变量列表就为空，
如为Box添加一个方法：

package study;
//类和对象
 class Box{
     double chang;
     double kuan;
     double gao;
     void Tiji(){
         System.out.println("体积是： ");
         System.out.println(chang*kuan*gao);
     }
 }
 class BoxDemo{
     public static void main(String[] args) {
            Box mybox=new Box();
            Box mybox1=new Box();
            double tiji;
            mybox.chang=10;
            mybox.kuan=8;
            mybox.gao=7;
            mybox1.chang=12;
            mybox1.kuan=8;
            mybox1.gao=3;
            mybox1.Tiji();
            mybox1.Tiji();
 }
 }

在这个方法中要注意：实例变量chang,kuan,gao被直接引用 ，并没有在他们的前面加对象名或点号运算符，这是因为当一个方法使用由它的类定义的实例变量时，它可以直接这样做，而不必使用显式的对象引用和点号运算符，而当一个实例变量不是被该实例变量所在的类的部分代码访问时，它必须通过该对象加点运算符来访问，

把对象作为参数

package study;
//类和对象
 class Hezi{
     double chang;
     double kuan;
     double gao;
     Hezi(Hezi lzq){
         chang=lzq.chang;
         kuan=lzq.kuan;
         gao=lzq.gao;
     }
     Hezi(double c,double k,double g){
         chang=c;
         kuan=k;
         gao=g;
    }
     Hezi(){
         chang=-1;
         kuan=-1;
         gao=-1;
     }
     Hezi(double len){
         chang=kuan=gao=len;
     }
     double tiji(){
         return chang*kuan*gao;
     }
 }
 class BoxDemo{
     public static void main(String[] args) {
            Hezi mybox1=new Hezi(10,20,15);
            Hezi mybox2=new Hezi();
            Hezi mybox3=new Hezi(7);
            Hezi mybox4=new Hezi(mybox1);//对象做参数
            double tj;
            tj=mybox1.tiji();
            System.out.println("mybox1时："+tj);
            tj=mybox2.tiji();
            System.out.println("mybox2时："+tj);
            tj=mybox3.tiji();
            System.out.println("mybox3时："+tj);
            tj=mybox4.tiji();
            System.out.println("mybox4时："+tj);
 }
 }

参数时如何传递的

1.按值传递

package study;
class Test{
    void Lzq(int i,int j){
        i*=2;
        j/=2;
    }
}
public class TestDemo6 {

    public static void main(String[] args) {
        Test pwd=new Test();
        int a=15;
        int b=20;
        System.out.println("未进入方法Lzq之前：a="+a+"，b="+b);
        pwd.Lzq(a, b);
        System.out.println("进入方法Lzq之后：a="+a+"，b="+b);
    }

}

这种方法将一个参数值复制成为子程序的正式参数，这样，对子程序的参数的改变不影响调用它的参数，在例子中，Lzq（）内部发生的操作不影响调用中的a,b的值，它们的值在本例中没有变为30和10，（变的是i和j）,

2.引用调用

package study;
class Test{
    int a,b;
    Test(int i,int j){
        a=i;
        b=j;
    } 
    void lzq(Test pwd){
        pwd.a*=2;
        pwd.b/=2;
    }
}
public class TestDemo6 {

    public static void main(String[] args) {
        Test pwd=new Test(15,20);
        System.out.println("未进入方法lzq之前："+pwd.a+","+pwd.b);
        pwd.lzq(pwd);
        System.out.println("进入方法lzq之后："+pwd.a+","+pwd.b);

    }

}

在这种方法中，参数的引用（而不是参数值）被传递给子程序参数，在子程序中，该引用用来访问调用中指定的实际参数，这样对子程序参数的改变将会影响调用子程序的参数，当一个简单类型传递给一个方法时，使用按值传递，对象传递则按引用传递

返回对象

方法能够返回任何类型的数据，包括你创建的类的类型，例如在下面的程序中，lzq()方法返回一个对象，在该对象中的值a比调用对象中的a大10.

package study;
class Ttou{
    int a;
    Ttou(int i){
        a=i;
    }
    Ttou lzq(){
        Ttou pwd=new Ttou(a+10);
        return pwd;
    }
}
public class Test {
  public static void main(String[] args) {
        Ttou s1=new Ttou(5);
        Ttou s2;
        s2=s1.lzq();
        System.out.println("s1= "+s1.a);
        System.out.println("s2= "+s2.a);
        s2=s2.lzq();
        System.out.println("新的s2= "+s2.a);
    }

}