SCJP之赋值
1：基本变量赋值与另一个基本变量
public class Test { public static void main(String[] args) { int a=10; int b=a; b=30; System.out.println("a="+a); System.out.println("b="+b); } }
输出结果：
将数字10的位模式赋予int容器的变量a.然后把a内的位模式传入变量b。相当于把a复制一下，然后粘贴给b。所以这两个值没有任何关系了。修改其中一个，另一个没有影响。
2：变量的作用域：
class Layout { //静态变量 static int s=343; //实例变量 int x; { x=7; //初始块变量。属于局部变量 int x2=5; } Layout(){ x+=8; //是一个构造函数变量，属于局部变量 int x3=6; } void doStuff(){ //局部变量 int y=0; //Z是一个块变量 for(int z=0;z<4;z++){ y+=z+x; } } }
对于变量，我们分为4种基本作用域
1）：静态变量：生命周期最长。在加载类的时候就创建了。只要类在JVM中保持加载状态，就会一直存在。
2）：实例变量：短一些。在创建新实例的时候存在。直到实例被删除的时候消亡。
3）：局部变量：只要方法在栈上。就会存活下去。
4）：块变量：在执行的时候，才存在。
作用域的几种错误表现：
1）：试图从静态上下文（通常是main()方法）访问一个实例变量。
public class Test { int i; public static void main(String[] args) { i++; //Cannot make a static reference to the non-static field i } }
解析：因为实例变量 i 还没有创建，相当于还没有出生。所以不能调用。
2）：试图从嵌套方法访问局部变量。
public class Test { void go(){ int i=4; i++; } void go2(){ //i cannot be resolved to a variable i--; } }
解析：因为局部变量 i 出了go()方法就死亡了。
3：变量默认值
public class Test { int j; public static void main(String[] args) { Test t=new Test(); System.out.println(t.j); t.go(); } void go(){ int i=9; System.out.println(i); } }
//当局部变量没有显示的赋予值的话，编译器不通过的。
public class Test {
int j;
public static void main(String[] args) {
Test t=new Test();
System.out.println(t.j);
t.go();
}
void go(){
int i;
System.out.println(i); //这样调用是错误的。因为不知道局部变量i是什么。
}
}
实例变量：因为可以隐士的赋予0.所以可以直接调用。
对象实例变量默认赋予null.所以使用前保证该引用不是Null即可。
对于编译器来说：null是一个值。不可以在null引用上使用点运算符。因为它的另一端没有任何对象。null值：指引用变量没有引用堆上任何对象。与空的String(" ")是不同的。
局部变量：不知道是什么值。所以不可以调用。所以局部变量总是在使用前进行显示初始化。可以不在同一行代码中。但是一定要初始化。局部变量可以初始化为null
数组元素总是，总是，总是被赋予默认值。无论数组在哪里被声明或者实例化。
4：对象引用。将一个引用变量赋予另一个引用变量
public class Foo { public int i; public int j; public int getI() { return i; } public void setI(int i) { this.i = i; } public int getJ() { return j; } public void setJ(int j) { this.j = j; } Foo(){ } Foo(int i,int j){ this.i=i; this.j=j; System.out.println(i+"||"+j); } }
如果没有 this.i=i; this.j=j; 使用的时候：
Foo f=new Foo(4,5);
System.out.println(f.i); 输出结果就是0
public class Test {
public static void main(String[] args) {
Foo f=new Foo(4,5);
System.out.println("初始的Foo对象中的变量 i f.i="+f.i);
Foo f2=f;
f2.i=30;
System.out.println("将引用变量f赋予f2后 f2.i="+f2.i);
System.out.println("将引用变量f赋予f2后 f.i="+f.i + " after change to f2");
}
}
输出结果：
解析：将一个引用变量赋予另一个引用变量。这两个引用变量将拥有相同的位模式。该位模式引用堆上的一个具体对象。当f赋予f2后，f和f2拥有相同的值。但是只有一个Foo对象。因为这两个引用都是指向Foo对象的。所以不论谁进行修改，都是进行Foo对象的修改。
对象引用赋值方式的一种例外：String对象。因为String对象是特殊处理的。String对象是不可变的。
public class Test { public static void main(String[] args) { String i="java"; System.out.println("i="+i); String j=i; System.out.println("j="+j); j="HelloWorld"; System.out.println("修改后的j="+j+"修改后的i="+i); } }
输出结果：
修改后的j输出HelloWorld是因为是两个String对象。与以前的那个String对象不是同一个对象。
5：向方法传递变量
将对象变量传递到方法的时候，传递的是对象引用。而不是对象本身。根本没有传递实际的引用变量。而是该引用的一个副本。变量副本意味着获得该变量内的位副本，因此，当传递引用变量时，是在传递表示如何获得特定对象的位副本。换句话说，调用方法和被调用方法现在都具有该引用完全相同的副本，因此二者都将引用堆上完全相同的对象。（不是副本，是实打实的对象）
public class ReferenceTest { public static void main(String[] args) { Dimension d=new Dimension(5,10); ReferenceTest rt=new ReferenceTest(); System.out.println("使用方法modif()前 d.height="+d.height); rt.modify(d); System.out.println("使用方法modif()后 d.height="+d.height); } void modify(Dimension dim){ dim.height=dim.height+1; System.out.println("dim="+dim.height); } }
结果：
解析：Dimension对象作为参数传入到modify()方法中。因为传入的是副本。对象引用d和对象引用dim都是指向Dimension对象的。所以dim修改了Dimension对象。d引用Dimension.值也进行改变。
6：Java是按值进行传递的吗？ 其实是传递一个变量的副本
如果是基本变量，是按值进行传递的
public class ReferenceTest { public static void main(String[] args) { ReferenceTest rt=new ReferenceTest(); rt.modify(10); } void modify(int i){ i=3; System.out.println("i="+i); } }
输出结果：
如果是对象类型。就不是按值传递。
7：变量隐藏 （就是实例变量和局部变量冲突）
有两种方式：1）：直接声明一个相同名称的局部变量。
2）：作为变元的一部分声明一个相同名称的局部变量。
public class Test {
static int size=7;
static void changeIt(int size){
size =size+200;
System.out.println("size in changeIt is="+size);
}
public static void main(String[] args) {
//没有调用方法的时候，只有一个实例变量size
System.out.println("size="+size);
//调用方法，局部变量优先。
changeIt(size);
//调用完方法后，局部变量死亡，size没有进行修改。
System.out.println("size in changeIt now is="+size);
}
}
class Bar{
int barNum=28;
}
class Foo{
Bar myBar=new Bar();
void changeIt(Bar myBar){
myBar.barNum=99;
System.out.println("myBar.barNum in changeIt a is"+myBar.barNum);
myBar.barNum=199;
System.out.println("隐藏对象引用后myBar.barNum="+myBar.barNum);
myBar=new Bar();
myBar.barNum=420;
System.out.println("myBar.barNum in changeIt b is"+myBar.barNum);
}
}
public class Test {
public static void main(String[] args) {
Foo f=new Foo();
//还没有调用方法，只有一个变量，实例变量barNum;
System.out.println(f.myBar.barNum);
//调用方法后。局部变量把实例变量替换掉。
f.changeIt(f.myBar);
//调用方法后第一个局部变量进行修改。对象也跟着修改。为什么没有修改成420，因为不是一个对象
System.out.println(f.myBar.barNum);
}
}
输出结果：
