class  PersonTest
{
        public static void main(String[] args)
        {
                Person_1 a=new Person();
                Person_2 a=new Person();
        }
}

class Person_1
{                   //这里有一个默认构造函数，下面的两行定义了成员变量，
        int age=22;       当生成一个实体的时候，实体会初始化这些，这与下面的person_2
                               中的构造函数有什么区别？

        String name="lishi";
}

class Person_2
{
        Person()       //对生成的实体同样进行初始化与上面的有什么不同？
        {
                int age=22;
                String name="lisi";
        }

}
求解释！

楼主的代码，还有错误，不过这个可

1.       
   
2.                 Person_1 a=new Person_1();
   
3.                 Person_2 b=new Person_2();

复制代码

以理解

同学这个程序里面有很多小错误，得注意一下，用红色标出

class  PersonTest
{
        public static void main(String[] args)
        {
                Person_1 a=new Person_1();
                Person_2 b=new Person_2();
        }
}

class Person_1
{                   //这里有一个默认构造函数，下面的两行定义了成员变量，
        int age=22;       //当生成一个实体的时候，实体会初始化这些，这与下面的person_2
                              // 中的构造函数有什么区别？

        String name="lishi";
}

class Person_2
{
        Person_2()       //对生成的实体同样进行初始化与上面的有什么不同？
        {
                int age=22;
                String name="lisi";
        }

}

Person_1里面有个默认的构造函数，当建立它的对象时候，要使用它里面的属性需要对象去调用。
Person_2里面有个自定义的构造函数，建立对象的时候，这些构造函数中的属性在对象初始化时候就存在于对象当中了。

1. <div class="blockcode"><blockquote>/*楼主的问题其实还主要是变量作用范围的问题，
   
2. 当我们把变量定义的构造函数中的时候，那么该变量的作用范围就局限在该构造函数中，对于给类和该类的对象是无法使用调用的
   
3. 当我们把变量定义在类中构造函数外的时候，那么该变量的作用范围就属于该类的，在该类中都可以使用，也就是该类的对象和该类都可以
   
4. 调用使用该变量。
   
5. 下面代码用以验证我的说法，
   
6. 希望对楼主有帮助。
   
7. 
   
8. */
   
9. 
   
10. class  PersonTest
    
11. {
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 Person_1 a=new Person_1();
    
15.                                 //下面可以通过编译运行，因为变量age和name个作用范围为整个person_1类。因此该类的对象和给类可以调用该变量。
    
16.                                 System.out.println(a.age+"  "+a.name);
    
17.                 Person_2 b=new Person_2();
    
18.                                 //下面这句话会编译失败的，因为我们把变量age和name定义在构造函数内部，则这两个变量的使用范围仅限于构造函数Person_2()的局部变量。
    
19.                                 System.out.println(b.age+"  "+b.name);
    
20.         }
    
21. }
    
22. 
    
23. class Person_1
    
24. {                   //这里有一个默认构造函数，下面的两行定义了成员变量，
    
25.         int age=22;       //当生成一个实体的时候，实体会初始化这些，这与下面的person_2
    
26.                              //中的构造函数有什么区别？
    
27.         String name="lishi";
    
28. }
    
29. 
    
30. class Person_2
    
31. {
    
32.         Person_2()       //对生成的实体同样进行初始化与上面的有什么不同？
    
33.         {
    
34.                 int age=22;
    
35.                 String name="lisi";
    
36.         }
    
37. 
    
38. }

复制代码

王震阳 发表于 2012-10-13 16:21

不好意思，由于匆忙代码出现了许多错误。在这里的确涉及到了成员变量与局部变量的区别，
而我的这两个不同对象的生成还是有些区别的：person_1中的成员变量的初始化，使得今后每当生成一个实体，其属性都是相同的，而person_2中这种构造函数的方法，会根据具体的情形去初始化属性，不知道的我的理解对不对，说的有些乱。

刘 佳 发表于 2012-10-13 16:09
同学这个程序里面有很多小错误，得注意一下，用红色标出

class  PersonTest

哈哈哈，的确有好多错误，当时也没好好看就急着贴了出来，下次注意！！


Person_1里面有个默认的构造函数，当建立它的对象时候，要使用它里面的属性需要对象去调用。此时在生成对象的时候属性的初始化也存在了对象中了，他们两个用什么区别吗？
Person_2里面有个自定义的构造函数，建立对象的时候，这些构造函数中的属性在对象初始化时候就存在于对象当中了。此时要使用它里面的成员变量也需要对象调用吧? 您说的这两点在这两个类中有什么区别吗？


构造奇函数的内存是在堆中开辟的吗？

class  PersonTest
{
        public static void main(String[] args)
        {
                Person_1 a=new Person_1();
                Person_2 b=new Person_2();
        }
}

class Person_1
{                        //(1)
        int age=22;      
        String name="lishi";
}

class Person_2
{
        Person_2()       //(2)
        {
                int age=22;
                String name="lisi";
        }

}

(1)默认构造函数Person_1(){},你定义的age name都相当于对象的属性，在初始化时会比构造函数先执行；
(2)这个是你自己定义了构造函数，并初始化了两个变量；

效果其实差不多，要硬说这俩有什么区别，我觉得就是一个执行顺序的问题，这个可以参考毕老师的教学视频

“黑马程序员_毕向东_Java基础视频教程第06天-07-面向对象(对象的初始化过程)”，希望可以帮到你。

先得理解什么是初始化。。初始化就是对象一建立就存在的东西，是定义在构造函数里的。 建立一个对象，就会调用到相应的构造函数对其进行初始化。

我的理解是这样的，可能说不太清楚，不知道你能不能理解。当你建立Person_1和Person_2的对象时候，在堆内存中开辟空间，这个空间里都有 int age=22； String name="lisi";这些属性。 但是， Person_1的对象在使用age和name这些属性时，必须用对象调用。 Person_2的对象是初始化时这些属性就定义在这个对象里，不必调用，这些属性本来就是它的一部分。

1. package com.itcast.practise;
   
2. 
   
3. public class Demo2 {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.        Person1 p1 = new Person1();
    
11.        System.out.println("Person1中的age值："+p1.age);
    
12.        Person2 P2 = new Person2();
    
13.       
    
14.         }
    
15. 
    
16. }
    
17. class Person1{
    
18.         int age = 20;  //在此age变量在整个Person1类中有效
    
19. }
    
20. class Person2{
    
21.         Person2(){
    
22.                 //在此age变量只在Person2的构造函数中有效
    
23.                 int age = 20;  //只是构造函数定义的临时变量，在此类中无任何意义 ,你要分清楚变量的作用域
    
24.         }
    
25.        
    
26. }
    

复制代码

我想知道构造函数中加入临时变量有何意义。

构造函数是对对象的属性初始化。
将age ,name 放于构造函数中声明，那对象还有声明属性？

class  PersonTest
{
        public static void main(String[] args)
        {
                Person_1 a=new Person_1();
                Person_2 b=new Person_2();
        }
}

class Person_1
{                   //这里有一个默认构造函数，下面的两行定义了成员变量，
        int age=22;       //当生成一个实体的时候，实体会初始化这些，这与下面的person_2
                              // 中的构造函数有什么区别？

        String name="lishi";
}
/*
        我的理解是Person_1中，默认构造函数，初始化成员变量age=0;name=nll;
        在Person_2中，自定义构造函数，初始化成员变量age=22;name="lisi";
        有不同理解的同学一起讨论哈。
*/
class Person_2
{
        Person_2()       //对生成的实体同样进行初始化与上面的有什么不同？
        {
                int age=22;
                String name="lisi";
        }

}


//试着写了个和lz类似的。
class PersonTest
{
        public static void main (String[] args)
        {
                Person p1 = new Person();
                Person p2 = new Person(22,"lisi");
        }
}
class Person
{
        private int age ;
        private String name ;
        Person()
        {}
        Person(int age,String name)
        {
               
                this.age = age;
                this.name = name;
        }
        void function_1()
        {
       
        }
        void function_2()
        {
       
        }
}