学了Java 也有段时间了，现在连 成员变量，局部变量，类，方法，函数，还不能确定那个是，有没有高手能用一段程序给有层次的说明一下，
谢谢

1. class Day06
   
2. {
   
3.         static int i=2;//随着类的加载而加载。加载到方法区中的静态区中。
   
4.         int j=9;//定义了一个属性，也就是一个成员变量，也叫实例变量。当对象存在时，该变量存在于堆内存的对象中。
   
5. 
   
6.         static{//静态代码块。随着类的加载而执行。
   
7.            System.out.println("静态代码块...i="+i);
   
8.         }
   
9.        
   
10.         Day06(int a){//带一个int参数的构造函数。
    
11.                 this();//调用了本类中空参数的构造函数。
    
12.            System.out.println("有参的构造函数...i="+i+",j="+j);
    
13.         }
    
14. 
    
15.         { //构造代码块，定义在类中的代码块，用于给所有对象进行初始化动作的代码块。
    
16.            System.out.println("构造代码块...i="+i+",j="+j);
    
17.         }
    
18. 
    
19.         static void show(){//静态函数。函数中没有访问非静态的成员。
    
20.             System.out.println("静态show方法...i="+i);
    
21.         }
    
22. 
    
23.         Day06(){// 空参数的构造函数。
    
24.            System.out.println("无参的构造函数..."+",j="+j);
    
25.         }
    
26. }
    
27. 
    
28. class Test
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32. //                Day06 d = new Day06(1);//通过Day06.class类文件创建了对象。
    
33.                 //int a = Day06.i;
    
34.                 System.out.println("----");
    
35.                 new Day06();
    
36. 
    
37. 
    
38.                 show();
    
39.                
    
40.         }
    
41.         public static void show()
    
42.                 {}
    
43. 
    
44. 
    
45. }

复制代码

把这个先慢慢看懂

楼主我给你写了个小程序，差不多就是这样的意思。
你记住成员变量时类体里面定义的，局部变量时方法体里面定义的，
方法就是函数，

类就是：
Class ???{
成员变量 和 这个类的方法
}

先记住这些吧，最直观的了。

1. /*学了Java 也有段时间了，
   
2. *现在连 成员变量，局部变量，类，方法，函数，
   
3. *还不能确定那个是，有没有高手能用一段程序给有层次的说明一下，
   
4. */
   
5. public class Test{   //开始定义Test类
   
6.         
   
7.         public static void main(String[] args){
   
8.                
   
9.                
   
10.                 Person someOne = new Person(20);
    
11.                
    
12.                 method(someOne);
    
13.                
    
14.         }
    
15.         
    
16.         static void method(Person person){   //method()就是方法，平时所说的函数，其实就是方法了
    
17.                 int age = 20;        //这个age是局部变量，它是在方法体里面定义的
    
18.                 if(person.getAge()==age){
    
19.                         System.out.println("这个人是Tom.");
    
20.                 }
    
21.         }
    
22.         
    
23. }
    
24. 
    
25. class Person{  //开始定义Person类
    
26.         
    
27.         String name;    //name和age就是Person这个类的成员变量
    
28.         int age;        //在Person这个类体里面定义的
    
29.         
    
30.         public Person(int age) {
    
31.                 super();
    
32.                 this.age = age;
    
33.         }
    
34.         
    
35.         public String getName() {
    
36.                 return name;
    
37.         }
    
38.         public void setName(String name) {
    
39.                 this.name = name;
    
40.         }
    
41.         public int getAge() {
    
42.                 return age;
    
43.         }
    
44.         public void setAge(int age) {
    
45.                 this.age = age;
    
46.         }
    
47.         
    
48.         
    
49. }

复制代码

1. class Person
   
2. {
   
3.         //以下定义了两个私有的成员变量name，age，和公有的成员变量height
   
4.         private String name;
   
5.         private int age;
   
6.     double height;
   
7.         //java中函数就是方法的意思，但是习惯叫方法
   
8.         //满足以以下格式的都是方法 方法有方法名，参数，返回值
   
9.         Person(String name,int age,double height)
   
10.         {
    
11.                 this.name=name;
    
12.                 this.age=age;
    
13.                 this.height=height;
    
14.         }
    
15.         //局部变量 就是在代码块中定义的变量：如方法的参数表如下name，还有就是getAge方法中的s变量
    
16.         //局部变量就是程序执行完方法后，局部变量的内存就会被释放
    
17.         public void setName(String name)
    
18.         {
    
19.                 this.name=name;
    
20.         }
    
21.         public String getName()
    
22.         {
    
23.                 return name;
    
24.         }
    
25.         public int getAge( )
    
26.         {
    
27.                 int s=0;
    
28.                 return age+s;
    
29.         }
    
30.         public double getHeight()
    
31.         {
    
32.                 return height;
    
33.         }
    
34.         public String toString( )
    
35.         {
    
36.       return"名字:"+getName()+"年龄:"+getAge()+"身高:"+getHeight()+"米";
    
37.         }
    
38.         public void run()
    
39.         {
    
40.           System.out.println("我会跑哦！！！")
    
41.         }
    
42. }
    
43. public class PersonDemo
    
44. {
    
45.         public static void main(String[]agrs)
    
46.         {
    
47.         Person cai=new Person("张三",30,1.70);
    
48.                 cai.run();
    
49.         System.out.println(cai);
    
50. 
    
51.         }
    
52. }
    
53. //Person就是一个类，类就是把任何事物的属性和行为抽取出来，如名字，年龄，身高就是属性
    
54. //人有哪些行为，会说会跑等，以上就是定义了会跑的行为方法
    

复制代码

建议贴主 好好看看课本的知识，这些课本上都有 很简单

class IAmClass {// 嗯哼，我前边是class，你知道【科学家——袁隆平】，那么我就是【类——我是类】
        public static int a;// a：我是class的一份子，我还是变量，所以我叫成员变量。
　　　　　　　　　　　　//我是静态的，你可以通过IAmClass.a直接找到我

        IAmClass() {  // IAmClass(){}：俺后面有小括号，俺是函数，俺跟类同名，所以俺是构造函数，俺可以返回这个类的对象。
        }


        void function() {// function(){}：俺后面跟的有小括号，俺是函数。俺是void型，俺不会返给你东西的！
                                         // 俺小括号里啥都没，所以俺叫无参方法，无参函数。
                for (int i = 0; i < 10; i++) {
                        System.out.println("i = " + i);
                }        // i：俺是i，俺是局部变量，for外边的看不见俺，for一旦寿终正寝俺也得跟着陪葬。苦逼啊！短命啊！
        }


        String functionStr(String str)// functionStr：俺后面有小括号，俺是函数，俺是String类型的。　　　　　　　　//俺给你返回字符串，当然，俺也可以给你返回个NULL// 另外俺还有参数，俺是不是无参函数。
        {                                                         
                return str + str;           // str：俺是一枚字符串，俺只能存在于functionStr方法里，functionStr一旦寿终正寝，俺也不能独活于世。
        }
}






希望对你有所帮助。


总结一下吧。类：class 后跟的就是类名。
成员变量：直接在类内部定义的变量，就是成员变量，它们是类的成员
局部变量：定义在局部，也只存在于局部，存在于一段代码之间，这段代码可能是个函数，可能是个if、for、switch、while……可能是try……可能是catch、finally……
　　但是有个共同点，局部变量外边套了一层大括号{}
方法、函数：方法函数在java里都一个意思，最大的特点就是后面跟的有小括号（）



话说黑马这文本编辑器还真是不习惯，若是感觉有帮助，还是复制到编辑器、IDE里面排版好

局部变量可以在方法里面定义也可以在局部代码块里面定义。他和方法一样只要局部代码块和方法执行完，变量就从内存中给释放了。

成员变量，局部变量，类，方法，函数

方法跟函数式一回事
下面是例子
class Single//Single 创建一个类
{
        private int num;//num 成员变量
        public  void setNum(int a)//a 局部变量 ，函数setNum为方法
        {
                num=a;
        }
        public int getNum()//getNum()为方法
        {
                return num;
        }
        private Single(){}//构造函数
        private static Single s=new Single();//定义一个类的对象
        public static Single getInstance()//返回类对象的方法
        {
                return s;
        }
}

李东梁 发表于 2014-3-26 22:35
把这个先慢慢看懂

谢谢学习 了

caijunsong 发表于 2014-3-26 22:40
建议贴主 好好看看课本的知识，这些课本上都有 很简单

现在看懂了，谢谢

残梦共飞雪 发表于 2014-3-26 22:47
class IAmClass {// 嗯哼，我前边是class，你知道【科学家——袁隆平】，那么我就是【类——我是类】
      ...

谢谢，说的很生动，太有才了，

杨殿生 发表于 2014-3-27 18:03
成员变量，局部变量，类，方法，函数

方法跟函数式一回事

现在懂了，谢谢:handshake