变量
成员变量和局部变量
public class LenChange02 {
public static void ergodic(String name, String... arr){
int a = 0;
System.out.println(a);
// name = "你好";
int tag = 0;
for(int i = 0; i < arr.length; i++){
System.out.println(name);
String arrTmp = arr[i];
if("邓超".equals(arrTmp)){
name = i + "";
tag = 1;
System.out.println(name);
}
System.out.println(arrTmp);
System.out.println(name);
}
if(tag == 0){
System.out.println("数组的元素没有等于 邓超");
}else if(tag ==1){
System.out.println("符合条件的索引值等于" + name);
System.out.println(name);
}else{
System.out.println(name);
System.out.println("else 前面的if 和所有的else if都不匹配，则会执行else模块");
}
System.out.println(name);
}
// name = "";
}
即，在Java中，根据定义变量位置的不同，可以将变量分为2大类：成员变量和局部变量。
例如，代码中变量tag就是一个成员变量，成员变量就是咱们之前说的属性；例子中，定义在方法中的tag就是一个局部变量，局部变量值得是在一个方法内定义的变量。不管是成员变量，还是局部变量，都需要遵守相同的命名规则：从语法角度来看，只要是一个合法的标识符就可以了，但是从程序可读性角度来看，应该是有意义的字母连缀而成，其中第一个单词首字母小写，后面每个单词首字母大写
成员变量被分为类属性和实例属性两种，定义一个属性时不使用static修饰的就是实例属性，使用static修饰的就是类属性。其中，类属性从这个类的准备阶段起开始存在，执行系统完全销毁这个类，类属性的作用域与这个类的生存范围相同；而实例属性则从这个类的实例被创建开始存在，知道系统完全销毁这个实例，实例属性的作用域与对应实例的生存范围相同。
正是基于这个原因，把类属性和实例属性统称为成员变量，其中类属性可以理解为类成员变量，它作为类的一个成员，与类共存亡；实例属性则可理解为实例成员变量，它作为实例的一个成员，与实例共存亡。
只要类存在，程序就可以访问该留的类属性，在程序中访问类属性的语法 是这样：
类.类属性
只要实例存在，程序就可以访问该实例的实例属性，在程序中访问实例属性的语法 是这样：
实例.实例属性
当然，类属性也可以让类的实例来访问，通过示例访问类属性的语法 是这样：
实例.类属性
但是这个示例访问的并不是这个实例的属性，依然是访问它对应的类属性。
public class GoodBoy {
public String name;
public int age;
public static boolean isGoodness;
}
public class GoodBoyTest {
public static void main(String[] args){
System.out.println("类GoodBoy的类属性isGoodness的值为" +
GoodBoy.isGoodness);
GoodBoy gb01 = new GoodBoy();
System.out.println("实例gb01的实例属性name为" + gb01.name + "，实例"
+ "属性age为" + gb01.age +"，类属性isGoodness为" +gb01.isGoodness);
// gb01
gb01.name ="杨颖";
gb01.age = 26;
gb01.isGoodness = true;
// GoodBoy.isGoodness = true;
System.out.println("实例gb01的实例属性name为" + gb01.name + "，实例"
+ "属性age为" + gb01.age +"，类属性isGoodness为" +gb01.isGoodness);
GoodBoy gb02 = new GoodBoy();
System.out.println("实例gb02的实例属性name为" + gb02.name + "，实例"
+ "属性age为" + gb02.age +"，类属性isGoodness为" +gb02.isGoodness);
}
}
成员变量可以被显示初始化，只要为一个类定义了类属性或实例属性，则系统会在这个类的准备阶段或创建这个类的实例时进行默认初始化，成员变量默认初始化时赋值规则与数组动态初始化时数组元素的赋值规则相同。
如果通过一个实例修改了类属性的值，由于这个类属性并不属于该实例，而是属于他对对应的类。因此，修改的依然是类的类属性，与通过该类来修改类属性的结果完全相同，这会导致该类的其他实例来访问这个类属性的时候也将获得这个被修改过的值。
局部变量根据定义形式的不同，分为3种：形参、方法局部变量、代码块局部变量。
第一种局部变量，形参。形参，即在声明方法形参列表时定义的变量，形参的作用域在整个方法内有效。
方法局部变量，指在方法体内定义的局部变量，它的作用域是从定义该变量的地方生效，到该方法结束时失效。
代码块局部变量，指在代码块中定义的局部变量，这个局部变量的作用域从定义该变量的地方生效，到该代码块结束时失效。
在一个类中或者一个方法中，一般会定义多个变量，这些变量的命名规则相同。那么这些变量的名称是否可以相同呢？
public class VariableTest {
// ------------------以下 变量 都是 成员变量 亦称 属性----------- 类的 成员 ------------------
// 对象变量 实例变量 属于实例的/对象 成员变量
private String name = "baby"; // 显示 赋 初始值 也可以不 赋 初始值
// private int name = 3;
// 类变量 类属性 属于类 成员变量
private static double prices = 36.23;// 显示 赋 初始值 也可以不 赋 初始值
// // 对象变量 实例变量 属于实例的/对象 成员变量
private int age; // 没有显示的 赋值
// ------------------以上 变量 都是 成员变量------------------------------------------
//-----------------方法 是 类的成员--------------------------
// getPrices 是 实例方法 是属于 某一个对象的方法。如果被static修饰了，那么
// 他就属于类方法，就属于 类
public int getPrices(int num){// num 是局部变量 形参
// 局部变量a 建议程序员习惯显示为局部变量赋初始值
int a = 1;
if(num >=3){
a = 6;
num += a;//num = num + a
}
return num;
}
// strName 是 实例方法 是属于 某一个对象的方法
public void strName(){
String name = "安卓软件工程师";//name 是 局部变量
// 局部变量name 与 上面的成员变量name 同名了。
// 局部变量 会 覆盖 成员变量
System.out.println("局部变量 name="+name);
// 如果你就想条用成员变量 name， this.name 对象.name
System.out.println("实例的成员变量那么="+ this.name);
// 一个类中，常见3种成员， 属性 方法 构造器 （相互调用）
// 在这里，可以通过 直接调用成员prices 类.prices 对象.prices
System.out.println(prices);
System.out.println(this.prices);
System.out.println(VariableTest.prices);//
}
public static void main(String[] args){
int prices = 3;// 局部变量
System.out.println(prices);//这里 调用时 局部变量 值为 3
// 调用类属性 可以通过 类名.类属性 调用
System.out.println(VariableTest.prices);//这里 调用时 成员变量 值为36.23
//----------------下面两个 对象调用方法 是一样的------------------
// 对象.实例方法 (创建对象 和 对象调用实例方法 写在一起了)
int num = new VariableTest().getPrices(prices);
// 对象.实例方法 (创建对象 和 对象调用实例方法 分开写了)
VariableTest vb = new VariableTest();
int num02 =vb.getPrices(prices);
//----------------上面两个 对象调用方法 是一样的------------------
// 因为 方法getPrices 没有被static修饰，getPrices 是实例方法，故
// 不能通过 类.方法 形式来调用
// int num03 = VariableTest.getPrices(prices);
// this
// static修饰的方法 只能访问 static修饰的成员
// int num02 = getPrices(prices);
// int num04 = this.getPrices(prices);
new VariableTest().strName();
// 调用实例属性 name 和 age，通过 对象. name 对象.age
VariableTest vt = new VariableTest();
System.out.println(vt.name);
System.out.println(vt.age);
// 这里 不能直接调用 没有被static修饰的成员 实例属性name 和age
// 原因是 static修饰的方法 只能访问 static修饰的成员
// System.out.println(name);// 错
// System.out.println(age);// 错
// System.out.println(this.name);// 错
// System.out.println(this.age);// 错
}
}
局部变量将会覆盖同名的成员变量，不过依然可以在方法中显示指定 类名 、对象和this作为调用者来访问被覆盖的成员变量，这将让咱们的编程更加自如。不过大部分时间，咱们还是应该尽量避免这种局部变量和成员变量同名的情形。
总结：当系统加载类或创建该类的实例时，系统会自动为成员变量分配内存空间，并在分配内存空间后，自动为成员变量指定初始值。
局部变量定义之后，必须经过显示初始化后才能使用，系统不会自动为局部变量初始化。这意味着定义局部变量后，系统并没有为这个局部变量分配内存空间，直到程序为这个局部变量赋初始值时，系统才会为局部变量分配内存，并将初始值保存到这块内存中。
与成员变量不同，局部变量不属于任何类或实例，因此它总是保存在其所在方法的栈内存中。栈内存中的变量无须系统垃圾回收，栈内存中的变量往往是随方法或代码块的运行结束而结束的。因此，局部变量的作用域是从初始化该变量开始，直到该方法或该该代码块运行完成而结束。因为局部变量只保存基本类型的值或者对象的引用，因此局部变量所占内存区通常比较小。
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
