构造方法、有参构造方法和构造代码块的概念、作用、区别及实际应用。求详解！！！有具体代码示例更佳。。。

构造方法是给对象的特有属性初始化的，有参数无参数仅仅是根据你建立对象时传的值不同，进行相对应的初始化。构造代码块儿则是给这一类对象统一初始化的。

构造方法(函数)
       
1.构造方法的作用是初始化对象
                类名 引用名=new 构造方法();
2.构造方法的格式
        1.构造方法的名字必须与类名相同。
        2.构造方法不能有修饰符(权限除外 public private )
        3.构造方法没有返回值类型 void也没有。
3.构造方法的注意事项
                1.如果一个类没构造方法，那么当它加载时， jvm会为其分配一个默认的空的无参构造方法
                  但是如果我们手动去创建了一个构造方法，那么默认的就不会在创建。

                2.构造方法是用来创建对象的，我们程序员不能手动调用构造方法。

                3.构造方法也可以重载。好处是可以通过多种途径去实例化类的对象。
                class Demo1
{
        public static void main(String[] args)
        {
                Teacher t=new Teacher(); //当我们创建一个对象时，构造方法就被执行了。

       
               
                Teacher tt=new Teacher("tom");

                System.out.println(tt.name);
       
        }
}


class Teacher
{
        String name;
        //构造方法
        Teacher(){
                System.out.println("这是Teaher类的构造方法");
        }

        Teacher(String n){
                name=n;
        }
}

构造方法带参数的目的:是可以在创建对象的过程中就对对象的属性进行赋值操作。
       
局部代码块与构造代码块
       
        { 代码块  }

        局部代码块:声明在方法内的代码块
        构造代码块:声明在类中的。

        作用:
        局部代码块:限定变量的生命周期.

        构造代码块:它是只要构造方法执行，它就会执行，并且优先与构造方法执行.
        它的作用：可以将所有构造方法内都要执行的内容抽取出来放入到构造代码块中。
        /*
        局部代码块:限定变量的生命周期.

        构造代码块:它是只要构造方法执行，它就会执行，并且优先与构造方法执行.
        它的作用：可以将所有构造方法内都要执行的内容抽取出来放入到构造代码块中。


*/
class Demo2
{


        Demo4(){
                System.out.println("构造方法");
        }

        Demo4(int i){
                System.out.println("有参构造方法");
        }

                //构造代码块
        {
                System.out.println("构造代码块");
        }
        public static void main(String[] args)
        {
                Demo4 d1=new Demo4(10);
               
                Demo4 d2=new Demo4();
                /*
                //局部代码块
                {
                        int i=10;
                       
                        System.out.println(i);
               
                }
                */
       
        }
}

1. /*假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
   
2. 姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
   
3. 奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
   
4. 法进行属性访问。
   
5. 员工类：name id pay
   
6. 经理类：继承了员工，并有自己特有的bonus。
   
7. */
   
8. class Employee
   
9. {
   
10. private String name;
    
11. private String id;
    
12. private double pay;
    
13. Employee(String name,String id,double pay)
    
14. {
    
15. this.name = name;
    
16. this.id = id;
    
17. this.pay = pay;
    
18. }
    
19. public abstract void work();//抽象方法
    
20. }
    
21. class Manager extends Employee
    
22. {
    
23. private int bonus;
    
24. Manager(String name,String id,double pay,int bonus)
    
25. {
    
26. super(name,id,pay);
    
27. this.bonus = bonus;
    
28. }
    
29. public void work()
    
30. {
    
31. System.out.println("manager work");
    
32. }
    
33. }
    
34. class Pro extends Employee
    
35. {
    
36. Pro(String name,String id,double pay)//Manager m = new Manager("wp"+"as"+1.10+1)开始传值
    
37. {
    
38. super(name,id,pay);
    
39. }
    
40. public void work()
    
41. {
    
42. System.out.println("pro work");
    
43. }
    
44. }
    
45. class AbstractTest
    
46. {
    
47. public static void main(String[] args)
    
48. {
    
49. Manager m = new Manager("wp"+"as"+1.10+1)
    
50. m.work();
    
51. }
    
52. }
    
53. 
    
54. 
    
55. 
    
56. 
    

复制代码

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。file:///C:/Documents%20and%20Settings/wangpeng/桌面

构造函数:

特点：
1.函数名与类名相同,,,函数名是固定的
2.不用定义返回值类型,,和void不是一回事,void是一种返回值类型,代表着没有具体结果返回的情况,而构造函数是根本不需要定义返回值类型
3.不可以写return语句,,返回值类型都没有,那么函数里面就不需要return语句了构造函数当中是不可能出现return语句的,你不写系统也不给你加retrun
4.对象一建立就会调用与之对应的构造函数。
5.一个对象建立，构造函数只运行一次。


构造函数的作用：可以用于给对象进行初始化。也就是说当我们在堆内存中产生对象的时候这个对象他需要一个初始化动作

构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数,为什么自动加一个,是为了方便于该类进行初始化,否则对象是建立不出来的,因为对象没有办法初始化,
当在类中自定义了构造函数后，默认的构造函数就没有了。也就是说这类里面我自己定义了对对象的初始化方式的话那么系统就不在帮你加一个构造函数了


什么时候定义构造函数呢？
当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中。

注意;构造函数在进行定义的时候是否需要未知内容参与运算,需要就定义参数,,比如人一初始化就得有姓名,姓名是未知的,你初始化以后往里面传就可以了

构造函数代码:
class Person
{
       private String name;
        Person()                                 //无参构造函数
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }
        /**/
        Person(String n)                    //有参构造函数
        {
                name = n;
                System.out.println("B: name="+name);
               
        }
}





构造代码块:

class Person
{
        private String name;
        private int age;

        Person()
        {
                System.out.println("A: name="+name+",,age="+age);
               
        }

        Person(String n,int a)
        {
                name = n;
                age = a;
                System.out.println("C: name="+name+",,age="+age);

        }

        /*
        构造代码块。
        作用：给对象进行初始化。
        对象一建立就运行，而且优先于构造函数执行。无论创建哪个对象时都得首先执行构造代码块,然后再执行对应的构造函数
        和构造函数的区别：
        构造代码块是给所有对象进行统一初始化，
        而构造函数是给对应的对象初始化。

        构造代码快中定义的是不同对象共性的初始化内容。比如每个构造函数里都有cry()方法,,,可以单独提取出来放到构造代码块里

        构造代码块也是一种初始化方式,,,

        */
        {                             //这就是个构造代码块
               
                cry();
        }

        public void cry()
        {
               
                System.out.println("cry......");
        }
}

class  PersonDemo2
{
        public static void main(String[] args)
        {
                Person p1 = new Person();

                Person p2 = new Person("lisi");
       
               
        }
}


结论:

p1,p2都能运行.当建立这个p1对象的时候时先执行构造代码块,再执行Person()无参构造函数,然后建立p2对象的时候,这个对象就到Person(String n)构造函数来初始化,步骤也是先执行构造代码块再执行Person(String n),,,构造函数是给不同的对象进行分别初始化的,无论创建哪个对象都得首先执行构造代码块,,执行顺序都是先执行构造代码块再执行构造函数,无论调用哪个构造函数都得先执行构造代码块