编程语言的三大发展阶段：面向机器语言、面向过程语言、面向对象语言 ；
 
其中面向对象语言主要体现三个特征：封装性、继承、动态 ；
 
类的定义：类声明和类体。基本格式如下：
 
class 类名{
 
   类体
 
}
 
特点：
 
1、类是Java程序的基本要素，一个Java应用程序就是由若干个类所构成；
 
2、类声明的变量称为对象变量，也简称 对象 ；
 
3、class 关键字是用来定义类 ；
 
4、类的目的是抽象出一类事物共有的属性和行为，并用一定的语法格式来描述所抽象出的属性和行为；
 
4、类名必须是合法的Java标识符；
 
Java标识符详细说明：（以及中文标识符的说明）
 
https://blog.csdn.net/LagerSwan/article/details/104081548
 

类的声明：
 
如下所示：
 
class Number {
 
.....
 
}
 
class 数字 {
 
.....
 
}
 
其中 class Number 与 class 数字 称为类的声明，而 Number 和 数字 则为类名 ；
 

类体，即 { } 中的内容：
 
类体的内容由如下两部分构成：
 
变量的声明：用来存储属性的值 ；（体现了对象的属性）
方法的定义：方法可以对类中声明的变量进行操作；（体现了对象的行为）
如下代码演示：
 
public class Class_Test {
	int number = 10;
	double numberd = 11.111;
	double TestDouble() {
		double numbers = 100 ;
		numbers += numberd;
		return numbers;
	}
	public static void main(String[] args) {
		Class_Test test = new Class_Test();
		System.out.println(test.TestDouble());
	}
}
 
在以上代码中，声明了一个类 Class_Test ，两个变量 number 与 numberd ，一个方法 TestDouble() ，一个主方法 main () ;
 

成员变量的定义：
 
一、成员变量的类型：
 
成员变量的类型可以是Java中的任何一种数据类型，包括了基本数据类型：整形、浮点型、逻辑类型、字符类型 ；引用类型中的：数组、对象和接口；   
 
如下代码演示：
 
public class Class_Test {

	public static void main(String[] args) {
		
		//成员变量的说明
		//基本数据类型的成员变量
		int testt = 11 ;
		float testf = 11.111f ;
		double testd = 11.11111 ;
		//引用类型的变量
		int a [] ;
		Class_Test test ;
		
	}
}
 
在以上代码中，成员变量：testt，testf，testd 是基本数据类型的变量；a [ ] ，test是引用类型的变量，a [ ] 为数组的变量，test 为类声明的变量，即类对象；
 
二、成员变量的有效范围：
 
成员变量在整个类内都是有效的，其有效性与它在类体中声明的先后位置是不关的；
 
如下代码演示：   最终输出： 110
 
public class Class_Test {
	
	//成员变量的有效范围：
	int number = 11 ;
	int Int_Test(){
		int int1 = number * digit ;
		return int1;
	}
	int digit = 10 ;

	public static void main(String[] args) {
		//类体的说明
		Class_Test test = new Class_Test();
		System.out.println(test.Int_Test());	
	}
}
 
不建议大家这样编写程序，当代码量多时，对代码的可读性有一定的影响，建议先声明成员变量，再定义方法；
 
三、成员变量的编写风格：
 
建议大家在声明成员变量时，变量的名字使用驼峰规则，即变量名由多个单词组成时，从第二个单词开始的其他单词的首字母大学；如：computerArea 、ClassExceptionShow 
 

方法的使用：
 
在类体中，方法的定义包括两部分：方法头、方法体 ；  一般格式如下：
 
方法头 {
 
   方法体
 
}
 
一、方法头说明
 
方法头由方法的类型、名称、名称后面的 （） 以及 （）里面的参数列表所构成；
 
如下代码演示：
 
//无参数的方法头
double testd (){
    return 11.111;
}

//有参数的方法头, x 和 y 即为参数
double testd (double x,double y){
    return x+y;
}
 
二、方法体说明：
 
方法体即 方法（）后面的 { } 以及 { } 里面的内容；
 
在方法体中声明的变量为局部变量，而不是成员变量，局部变量只在方法体内有效，而且与声明时的前后位置有关；
 
如下代码演示：
 
double testd = 10 ;
double testd (double x,double y){      //参数 x，y是局部变量
   double sum;                         //参数 sum 是局部变量
   sum = x + y ;

   if(sum>x){
       sum += testd ;         //参数 testd 是成员变量（全局变量）
}

    return sum;        //return 语句，返回 sum 的值
}
 
局部变量的介绍：
 
1、局部变量不同与成员变量，局部变量只在方法中有效，而且与其声明的位置顺序有关；
 
2、若局部变量声明在一个复合语句中，那么该局部变量的有效范围只在复合语句中有效；
 
double testd (double x,double y){      //参数 x，y是局部变量
	   double sum;                         //参数 sum 是局部变量
	   sum = x + y ;
	   if(sum != 0){
	       int ints = 1;        // ints 为复合语句中的局部变量
	       sum += ints ;
	}
        double bottom = 1.1;
        bottom += ints ;         //程序报错：ints cannot be resolved to a variable
	    return sum;
	}
 
3、若局部变量声明在一个循环语句中，那么该局部变量的有效范围只在循环语句中有效；和以上复合语句是一样的；
 

总结：成员变量与局部变量的区别
 
1、局部变量不同与成员变量，局部变量只在方法中有效，而成员变量在整个类中都有效；
 
2、局部变量与其声明的位置顺序有关，而成员变量与其声明的位置顺序无关；
 
3、若局部变量的名字和成员变量的名字相同，那么成员变量会被隐藏，即在方法体中成员变量暂时是无效的，如下代码演示：
 
class Test_Variable {
    int x = 10 , y ;
   void tests () {
      int x = 5 ;
      y = x + 10 ; //y的值为 15 ，而不是20，此时成员变量 x = 10 在该方法体中，暂时失效；
   }

}
 
4、当想使用方法中被隐藏的成员变量，可以使用关键字 this 进行调用，如下代码演示：
 
class Test_Variable {
    int x = 10 , y ;
   void tests () {
      int x = 5 ;
      y = this.x + 10 ; //此时 y 的值为 20 ，而不是15，this.x调用的为成员变量 x = 10 ;
   }

}
 
5、成员变量有默认值，而局部变量没有默认值，因此在使用局部变量时，要确保该局部变量是有初始值的，否则程序报错；
 
class Test_Variable {

           int  y ;
	   void tests () {
	      int x;       //报错：The local variable x may not have been initialized
	      y = x + 10 ; 
	   }

}
 
 
 
 
 
 

 
 
好吧，我承认我有赌的成分。我以为我能赌出答案，结果赌输了。
 

 还得利用JVM的知识点进行运算。
 
 


 
文章目录
 
1、考点：
2、局部变量和成员变量的区别
3、具体的测试代码
4、过程分析（重点）
5、补充
 

 


 
 
1、考点：
 
就近原则
变量的分类 
  
成员变量：类变量、实例变量
局部变量
 
非静态代码块的执行：每次执行实例对象都会执行
方法的调用规则：调用一次执行一次
 


 
2、局部变量和成员变量的区别
 
 
 
1、声明位置
 
 
局部变量：方法体{}中、形参、代码块{}中
成员变量：类中方法外 
  
类变量：有static修饰
实例变量：没有static修饰
 
 

 
 
 
2、修饰符
 
 
局部变量：final
成员变量：public、protect、private、final、static、volatile、transient（序列化）
 

 
 
 
3、存储位置：
 
 
局部变量：栈
实例变量：堆
类变量：方法区
 

 
 
 
4、作用域
 
 
局部变量：从声明处开始，到所属的 } 结束
实例变量：在当前类中 “this.” （有时this.可以省略），在其他类中 “对象名.” 访问
类变量：在当前类中 “类名.” （有时类名. 可以省略），在其他类中“类名.” 或 “对象名.” 访问
 

 
 
 
5、生命周期
 
 
局部变量：每一个线程，每一次调用执行行都是新的生命周期
实例变量：随着对象的创建而初始化，随着对象的被回收而消亡，每一个对象的实例化变量是独立的
类变量”随着类的初始化而初始化，随着类的卸载而消亡，该类的所有对象的类变量是共享的
 
补充：
 
堆（Heap）：
 
此内存区域的唯一目的就是存放实例对象，几乎所有的实例对象都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配
 
栈（Stack）：
 
通常说的栈是指虚拟机栈**。虚拟机栈用于存储局部变量表等。局部变量表存放了编译期可知长度的各种基本数据类型（8大基本数据类型）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
 
方法区（Method Area）：
 
用于存储已被虚拟机加载的类信息、常量、静态变量、即使编译器编译后的代码等数据
 


 
 
3、具体的测试代码
 
测试代码：
 
package pers.mobian.questions06;

public class Test01 {
    static int s;//成员变量，类变量
    int i;//成员变量，实例变量
    int j;//成员变量，实例变量

    {
        int i = 1; //局部变量
        i++; //局部变量 如果此处想要成为成员变量，就需要在变量前面添加一个this关键字
        j++; //成员变量
        s++; //成员变量
    }

    public void test(int j) {
        j++; //局部变量 如果此处想要成为成员变量，就需要在变量前面添加一个this关键字
        i++; //成员变量
        s++; //成员变量
    }

    public static void main(String[] args) {
        Test01 test01 = new Test01();
        Test01 test02 = new Test01();
        test01.test(10);
        test01.test(20);
        test02.test(30);
        System.out.println(test01.i + "," + test01.j + "," + test01.s);
        System.out.println(test02.i + "," + test02.j + "," + test02.s);
    }
}

 
执行结果：
 
2,1,5
1,1,5
 


 
 
4、过程分析（重点）
 
 
 
Test01 test01 = new Test01();
 Test01 test02 = new Test01();
 
 
执行这两句以后，对应的信息变化为下图：
 
 
补充：
 
先对该类进行初始化，即会调用对应的clint方法，在方法区中为s开辟一块空间
实例化对象的时候，会调用对应的init方法，其中init方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
非静态实例变量显示赋值代码：i = 0, j = 0
非静态代码块：执行 {} 中的代码块（在栈中开辟一个栈帧），其中代码块中的 i 为局部变量，代码块执行完毕消失。但是 j 为成员变量，所以会进行对应的 +1 操作（就近原则），成员变量 i 结果不变。
对应构造器代码：此处无参构造没有任何效果，所以可以忽略
 
 

 
 
 
test01.test(10)
 test01.test(20)
 test02.test(30)
 
 
执行这三行代码以后内存的分配情况，如下图：
 
 
补充：
 
test01调用对应的test方法的时候，j 是局部变量所以 j 值为11，注意区分此处的 j 和堆内存中的 j 值。
test方法中的 i 值为成员变量，所以会在堆内存中被修改为1
test方法中的 s 值也是成员变量，并且其是static变量，所以 s 变量会在方法区中进行 +1 操作
再次执行test01中的test方法，重复1-3的步骤
执行test02对象中的test方法，i 的 +1 在堆中完成，s 的 +1 操作在方法区中完成，j 的 +1 操作在栈中完成 j = 31（由于 j 变量是局部变量，所以在执行对应的操作以后，失效）
 
 


 
 
5、补充
 
当局部变量与xx变量重名时，如何区分：
 
局部变量与实例变量重名 
  
在实例变量前面提添加 “this.” 关键字
 
局部变量与类变量重名： 
  
在类变量前面加 “类名.”
 

前言
 
c++ 静态成员变量用static 关键字来声明，是整个类的数据成员，其存储不占用某个具体对象的空间，其存储在静态存储区。
 c++ 静态成员函数用static 关键字来声明，用于处理静态成员变量，可以用类名来调用，也可以用对象名来调用。
 
使用静态成员变量的目的：静态成员变量是整个类的数据成员，使用静态成员变量可以实现多个对象共享数据。
 
测试1：
 
#include <iostream>
using namespace std;

class Point{
public:
    Point(int xx,int yy):x(xx),y(yy){count++;}
    Point():Point(0,0){}
    Point(const Point &p);
    ~Point(){count--;}
    void show(){cout<<x<<" "<<y<<endl;}
    static void showcount();  //用static来声明静态成员函数
private:
    int x,y;
    static int count; //用static来声明静态成员变量
};

int Point::count = 0;   //静态成员变量的定义，定义时前面不可以再有static, 且它必须要在类外面来初始化，不能在类内部初始化。静态成员变量在初始化时分配内存。

void Point::showcount() {    //静态成员函数的定义，前面不可以再有static，可以在类内部定义，也可以在类外定义。此例为在类外面进行定义。
    cout<<"count="<<count<<endl;
}

Point::Point(const Point &p){  //复制构造函数
    x = p.x;
    y = p.y;
    count++;
}

Point fun(Point m){ 
    return m;
}

int main(){
    Point::showcount(); //用     类名::函数名      来调用静态成员函数
    Point a(1,2);
    a.show();
    a.showcount();//也可用    对象名.函数名   来调用静态成员函数
    Point b(a);
    b.show();
    b.showcount();
    Point c;
    c.show();
    c.showcount();
    Point d = fun(c);
    d.show();
    d.showcount();
    return 0;
}
 
运行结果：
 $ ./a.out
 count=0
 1 2
 count=1
 1 2
 count=2
 0 0
 count=3
 0 0
 count=4
 

 如图,对象a占用8个字节（成员x，y的空间，count不在里面），对象a是局部对象，存放在栈上0x7fffffffdde0的位置处。
 
 count存放在静态存储区的 0x555555756134，不存储在对象中。count属于整个类，不属于某一个具体的对象。
 静态成员函数也是一样，属于整个类，不属于某一个对象，所以静态成员函数可以用类名来调用，比如：Point::showcount() 。
 
static 成员变量必须在类声明的外部初始化，具体形式为：
 
 type class::name = value;
 
如本例：int Point::count = 0;
 静态成员变量在初始化时不能再加 static，但必须要有数据类型。
 
static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。没有在类外初始化的 static 成员变量不能使用，因为没分配空间。
 
测试2：
 
#include <iostream>
#include <cmath>
using namespace std;

class Point{
public:
    Point(int xx,int yy):x(xx),y(yy){count++;}
    Point():Point(0,0){}
    Point(const Point &p);
    ~Point(){count--;}
    void show(){cout<<x<<" "<<y<<endl;}
    static void showcount();
public:
    static int count;   //此例为public属性
private:
    int x,y;
};

int Point::count = 0;
 
void Point::showcount() {
    cout<<"count="<<count<<endl;
}

Point::Point(const Point &p){
    x = p.x;
    y = p.y;
    count++;
}
int main(){
    Point::showcount();
    Point a(1,2);
    cout<<a.count<<endl;  //通过对象a来访问静态成员变量。若count不是public属性，不能用对象来访问，编译时就会报错
    Point::showcount();
    Point b(3,4);
    Point::showcount();

    return 0;
}
 
用GDB来查看静态成员变量的存储：
 
 可以看到，当b中count变为2，a中count也变为2，即a和b中的count是共享的。查看a.count和b.count的地址，可以发现是同一个地址，即是同一个存储空间。且这个存储空间是全局存储区（静态存储区），不在对象a和对象b的栈（stack）存储区。
 此例中count是public，修改为protected和private,编译报错。
 
protected:
    static int count;
 
 
private:
    static int count;
 

 如上图，也就是说，想通过对象来访问静态成员变量，静态成员变量只能是public属性。这一点和对象去访问普通的成员变量一样。类外面，对象只能访问public成员变量，不能访问protected和private的成员变量。
 
测试3：
 
void Point::showcount() {
    cout<<"count="<<count<<endl;
    cout<<x<<endl; //新增，尝试在静态成员函数中去访问普通的成员变量，编译报错。
}
 

 也即是说，在静态成员函数中，不能去访问普通的成员变量。原因是没有this指针，不知道普通成员变量x放在哪里。
 原因分析：
 编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象之后通过对象来调用，因为它需要当前对象的地址。也即是有了对象，才有对象的this指针，没有对象，就无法调用普通成员函数。由于类没有this指针，所以不能用类名去调用普通成员函数，只能用实际的对象去调用普通成员函数。
 
而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。因为静态成员函数要访问的是静态成员变量（存储在全局存储区，和this指针没毛关系）。
 由于静态成员函数没有 this 指针，不知道指向哪个对象，无法访问对象的成员变量，所以静态成员函数不能访问普通成员变量，只能访问静态成员变量。
 
总结：
 
一个类中可以有一个或多个静态成员变量，所有的对象都共享这些静态成员变量，都可以引用它。注意，是共享，共享，共享，也即是只会占同一份静态存储空间。
static 成员变量和普通 static 变量一样，都在内存分区中的全局数据区分配内存，到程序结束时才释放。这就意味着，static 成员变量不随对象的创建而分配内存，也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存，在对象销毁时释放内存。根本原因是静态成员变量和对象的存储空间不同，是在不同的时期去分配的。
静态成员变量必须初始化，而且只能在类体外进行。例如：
 int Point::count = 0;
 初始化时可以赋初值，也可以不赋值。如果不赋值，那么会被默认初始化为 0。
 全局数据区的变量都有默认的初始值 0，而**动态数据区（堆区、栈区）**变量的默认值是不确定的，一般认为是垃圾值。
静态成员变量既可以通过对象名访问，也可以通过类名访问，但要遵循 private、protected 和 public 关键字的访问权限限制。
 当在类外面通过对象名访问时，静态成员变量属性必须是public，对于不同的对象时，访问的是同一份内存（本质是共享）。
静态成员函数在声明时要加 static，在定义时不能加 static 。静态成员函数只能访问静态成员变量，去访问普通成员变量，编译就报错。

变量名首写字母使用小写，如果由多个单词组成，从第2个单词开始的其他单词的首写字母使用大写。

 
 如果局部变量的名字和成员变量的名字相同， 要想在该方法中使用成员变量，必须使用关键字this
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
   
  
 
 
 
 
 class People {  
     String name = "类体重定义的name";         //类中的成员变量并赋值  
   
     People(){  
     }  
       
     public void speak() {  
         String name = "类体方法中定义的name";       //在方法speak中定义和成员变量名字相同的name并赋值  
         System.out.println(name);  
         System.out.println(this.name);      //通过this来访问类中的成员变量  
           
     }  
 }  
   
   
 public class TestThis {                              //源文件中只能有一个类是public类，并且源文件的名字必须与这个类的名字完全相同，如  
                                                          //果没有public类，那么源文件的名字只要和某个类的名字相同就可以了。  
     public static void main(String[] args) {         
         People myPeople = new People();  
         myPeople.speak();  
     }  
   
 }  
 
 
输出结果：

 

 
 
 
 
 
 
 
成员变量和局部变量的区别
 
 
 
        成员变量：
 
           1、成员变量定义在类中，在整个类中都可以被访问。
 
           2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
 
           3、成员变量有默认初始化值。
 
       局部变量：
 
           1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
 
           2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
 
           3、局部变量没有默认初始化值 
 
       在使用变量时需要遵循的原则为：就近原则
 
       首先在局部范围找，有就使用；接着在成员位置找。
 

 

 
 
 
 
 成员变量和类变量的区别
 
 
 
 
 
 
 
由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。
 
 不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。
 
 
 
 
 
 
 
 
 
  
 
   [java] 
   view plain
    copy 
   
 
   
 
   
  
 
 
 
 
 class MyAdd {  
     int count = 0;          //成员变量计数器  
     static int sum = 0;     //静态变量计数器  
     String name;  
       
   
     MyAdd(String name){  
         this.name = name;  
     }  
       
     public void myAddMethod() {    
         count++;  
         System.out.println(name+"调用成员变量后的值："+count);  
     }  
       
     public void staticAddMethod() {    
         sum++;  
         System.out.println(name+"调用类后变量的值："+sum);  
     }  
       
       
 }  
   
   
 public class TestThis {  
   
     public static void main(String[] args) {  
         MyAdd add1 = new MyAdd("add1");  
         MyAdd add2 = new MyAdd("add2");  
           
         add1.myAddMethod();  
         add2.myAddMethod();  
         add1.myAddMethod();  
         add1.staticAddMethod();  
         add2.staticAddMethod();  
         add1.staticAddMethod();  
     }  
   
 }  
 
 

 
输出结果： 
 
 
 
 
 
 
 
 
 成员变量和类变量的区别：
 
 
    1、两个变量的生命周期不同
 
       成员变量随着对象的创建而存在，随着对象的回收而释放。
 
       静态变量随着类的加载而存在，随着类的消失而消失。
 
    2、调用方式不同
 
       成员变量只能被对象调用。
 
       静态变量可以被对象调用，还可以被类名调用。
 
    3、别名不同
 
       成员变量也称为实例变量。
 
       静态变量也称为类变量。
 
    4、数据存储位置不同
 
       成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
 
       静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。
 

 
 
 
 
 
 
 static：★★★ 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
 
    特点：
 
    1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
 
    2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
 
     3、静态随着类的加载而加载。而且优先于对象存在。
 
  
 
 弊端：
 
    1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
 
    2、静态方法只能访问静态成员，不可以访问非静态成员。
 
       因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
 
    3、静态方法中不能使用this，super关键字。
 
       因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
 
 
  
 
 什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？
 
 成员分两种：
 
    1、成员变量。（数据共享时静态化）
 
       该成员变量的数据是否是所有对象都一样：
 
       如果是，那么该变量需要被静态修饰，因为是共享的数据。 
 
       如果不是，那么就说这是对象的特有数据，要存储到对象中。 
 
    2、成员函数。（方法中没有调用特有数据时就定义成静态）
 
       如果判断成员函数是否需要被静态修饰呢？
 
       只要参考，该函数内是否访问了对象中的特有数据：
 
 
       如果有访问特有数据，那方法不能被静态修饰。
 
       如果没有访问过特有数据，那么这个方法需要被静态修饰。
 
 
 
 
 成员变量和静态变量的区别：
 
    1、成员变量所属于对象。所以也称为实例变量。
 
       静态变量所属于类。所以也称为类变量。
 
    2、成员变量存在于堆内存中。
 
       静态变量存在于方法区中。
 
    3、成员变量随着对象创建而存在。随着对象被回收而消失。
 
       静态变量随着类的加载而存在。随着类的消失而消失。
 
    4、成员变量只能被对象所调用 。
 
       静态变量可以被对象调用，也可以被类名调用。
 
    所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
 
 
 
 
 
 
 
 
 

 成员变量：包括实例变量和类变量，用static修饰的是类变量，不用static修饰的是实例变量，所有类的成员变量可以通过this来引用。
 

 局部变量：包括形参，方法局部变量，代码块局部变量，存在于方法的参数列表和方法定义中以及代码块中。
 

  
 

 1.成员变量可以被public，protect，private，static等修饰符修饰，而局部变量不能被控制修饰符及 static修饰；两者都可以定义成final型。
 

  
 

 2.成员变量存储在堆，局部变量存储在栈。局部变量的作用域仅限于定义它的方法，在该方法的外部无法访问它。成员变量的作用域在整个类内部都是可见的，所有成员方法都可以使用它。如果访问权限允许，还可以在类的外部使用成员变量。
 

  
 

 3.局部变量的生存周期与方法的执行期相同。当方法执行到定义局部变量的语句时，局部变量被创建；执行到它所在的作用域的最后一条语句时，局部变量被销毁。类的成员变量，如果是实例成员变量，它和对象的生存期相同。而静态成员变量的生存期是整个程序运行期。
 

  
 

 4.成员变量在累加载或实例被创建时，系统自动分配内存空间，并在分配空间后自动为成员变量指定初始化值，初始化值为默认值，基本类型的默认值为0，复合类型的默认值为null。（被final修饰且没有static的必须显式赋值），局部变量在定义后必须经过显式初始化后才能使用，系统不会为局部变量执行初始化。
 

  
 

 5.局部变量可以和成员变量 同名，且在使用时，局部变量具有更高的优先级，直接使用同名访问，访问的是局部变量，如需要访问成员变量可以用this.变量名访问
 

 
 
 

 
 
 
 
 
 先看下面两段程序：
 
 
 程序一：
 public class Variable
 {
 int i;
 void test()
 {
    int j=8;
    if(j==i)
     System.out.println("相等");
    else
     System.out.println("不相等");
 }
 public static void main(String[] args)
 {
    Variable v=new Variable();
    v.test();
 }
 }
 
 
 
 程序二：
 public class Variable
 {
    void test()
 {
    int i;
    int j=8;
    if(j==i)
     System.out.println("相等");
    else
     System.out.println("不相等");
 }
 public static void main(String[] args)
 {
    Variable v=new Variable();
    v.test();
 }
 }
 
 
 
 ----------------------------------------------------------------------------------------------------------
 
 
 第一个程序很正常，编译时不会出错。第二个程序编译时会提示如下错误：
 
 
 D:\Program\java\test>javac Variable.java
 Variable.java:9: 可能尚未初始化变量 i
                 if(j==i)
                       ^
 1 错误
 
 
 之所以会出现这样的错误是因为：成员变量有默认值，（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值
 
 
 ===========================================================
 
 
 类体分为两部分。变量定义部分所定义的变量被称为类的成员变量，在方法体中定义的变量和方法的参数都被称为局部变量
 
 
 java中成员变量和局部变量的区别
 
 
 
  
 
   1.成员变量可以被public，protect，private，static等修饰符修饰，而局部变量不能被控制修饰符及static修饰；两者都可以定义成final型
  
 
  
 
   2.成员变量存储在堆，局部变量存储在栈
  
 
  
 
   3.存在时间不同
  
 
  
 
   4.成员变量有默认值，（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值
 -------------------------------------------------------------------------------------------------------------
  
   
 
    顾名思意了
 什么是局部，方法内部，块内部都是局部，执行指令退出那个局部，局部变量自动清除
 
 比如方法中，不用说
 块中
 {
 　 int i=0; //这是一个局部变量，它的作用范围就在其中　
 }
 
 成员变量就会涉及到谁的成员，类的成员？实例的成员？
 
 class A{
 int i=0; //实例的成员
 static j=1;//类的成员
 }
 
 static 的差别，是否依赖于实例而存在
 ----------------------------------------------------------------------------------------------------------
  
    
 成员变量：作为类的成员而存在，直接存在于类中。
 
    
 局部变量：作为方法或语句块的成员而存在，存在于方法的参数列表和方法定义中。
 
    
 局部变量在使用前必须被程序员主动的初始化，和此形成对比，系统中的成员变量则会被系统提供一个默认的初始值。所以在语法上，类的成员变量能够定义后直接使用，而局部变量在定义后先要赋初值，然后才能使用。
 
    
  
 
    
 所有类的成员变量可以通过this来引用。成员变量又分成俩中类型：实例变量和静态变量。静态变量在定义时要使用static关键字。