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){
//代码效果参考：http://www.zidongmutanji.com/bxxx/172082.html
dim.Height＜/span>=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) {
//没有//代码效果参考：http://www.zidongmutanji.com/bxxx/222810.html
调用方法的时候，只有一个实例变量sizeSystem.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);
}
}
输出结果：
