1. constructor;构造函数。• 1

    在创建对象的时候,对象成员可以由构造函数方法进行初始化。

    1. new对象时,都是用构造方法进行实例化的;
    2. 例如;Test test = new Test("a");
    3. //Test("a");其中这个就是构造函数,“a”为构造方法的形参;• 1
    4. • 2
    5. • 3
    1. 构造方法的方法名必须与类名一样。
    2. 构造方法没有返回类型,也不能定义为void,在方法名前面不声明方法类型。
    3. 构造方法不能作用是完成对象的初始化工作,他能够把定义对象时的参数传递给对象的域。
    4. 构造方法不能由编程人员调用,而要系统调用。
    5. 构造方法可以重载,以参数的个数,类型,或排序顺序区分。• 1
    6. • 2
    7. • 3
    8. • 4
    9. • 5

    具体用法,代码实现。
    1;单个构造函数方法;’
    Java中类的构造方法 - 图1
    Java中类的构造方法 - 图2
    Java中类的构造方法 - 图3
    2;多个构造函数方法
    (例子为;带参数与不带参数)
    Java中类的构造方法 - 图4
    Java中类的构造方法 - 图5
    Java中类的构造方法 - 图6
    3;关于继承类的构造方法的调用;
    先看事例;
    Java中类的构造方法 - 图7
    Java中类的构造方法 - 图8
    Java中类的构造方法 - 图9
    Java中类的构造方法 - 图10
    Java中类的构造方法 - 图11
    我第一次看到结果的时候好惊讶的,怎么都调用了哈。看了知识点才知道。
    在Subtine的主方法中只调用子类构造方法,实例化子类对象并且在子类构造方法中,没有调用父类的构造方法的任何语句。但是在实例化对象时,它相应的调用了父类构造方法,在结果中还可以看到调用构造方法的顺序,首先是顶级,再继续往下直达本身类。也就是说实例化子类的时候,要首先实例化父类对象,然后在实例化子类对象,所以在子类构造方法调用父类构造方法前,父类已经实例化了。
    拓展一下。

    1. package text_4_1;
    2. public class Parent {
    3. Parent(int a){//就是将无参数构造方法改成有参数的。
    4. System.out.println("调用父类Parent构造方法" + a);
    5. }
    6. }
    7. package text_4_1;
    8. public class Subparent extends Parent{
    9. Subparent(){
    10. System.out.println("调用子类Subparent的构造方法");
    11. }
    12. }
    13. package text_4_1;
    14. public class Subtine extends Subparent{
    15. Subtine(){
    16. System.out.println("调用子类Subtine构造方法");
    17. }
    18. }
    19. package text_4_1;
    20. public class Main {
    21. public static void main(String[] args){
    22. Subtine subtine = new Subtine();
    23. }
    24. }
    25. • 1
    26. • 2
    27. • 3
    28. • 4
    29. • 5
    30. • 6
    31. • 7
    32. • 8
    33. • 9
    34. • 10
    35. • 11
    36. • 12
    37. • 13
    38. • 14
    39. • 15
    40. • 16
    41. • 17
    42. • 18
    43. • 19
    44. • 20
    45. • 21
    46. • 22
    47. • 23
    48. • 24
    49. • 25
    50. • 26
    51. • 27
    52. • 28
    53. • 29
    54. • 30
    55. • 31
    56. • 32
    57. • 33

    这样的代码将会报错;//就是将父类Parent类无参数构造方法改成有参数的。

    1. Implicit super constructor Parent() is undefined. Must explicitly invoke another constructor
    2. //隐式的超级构造函数()是未定义的。必须显式地调用另一个构造函数 • 1
    3. • 2

    意思就是在子类调用构造函数时,必须先调用父类构造函数,因为无参数的构造函数,编译器会自动调用,也就是第一种情况不会报错。但是有参数的,就必须要利用Super的方法来调用。如果不进行调用那么将会报错。

    1. 将Subparent类改成。
    2. package text_4_1;
    3. public class Subparent extends Parent{
    4. Subparent(){
    5. super(5);//调用了其父类就不会报错了。
    6. System.out.println("调用子类Subparent的构造方法");
    7. }
    8. }
    9. //备注一下,调用父类构造方法就是;super();//就ok了。
    10. • 1
    11. • 2
    12. • 3
    13. • 4
    14. • 5
    15. • 6
    16. • 7
    17. • 8
    18. • 9
    19. • 10
    20. • 11

    还补充一点,关于构造方法的可扩展性;
    查看过源码的应该都发现过jdk的编码人员会在一个类中建立多个构造方法;然而他的作用就是提高可扩展性;
    Java中类的构造方法 - 图12
    这么多构造方法,他们之间并且还有联系;通过this()来调用自己类的其他构造方法,来减少代码的复制,增大程序的可读性;
    Java中类的构造方法 - 图13
    至于怎么来进行封装;举个例子;
    Java中类的构造方法 - 图14
    Java中类的构造方法 - 图15
    构造方法的可扩展性就表示在这里;
    可以多多个构造方法;根据不同的参数决定调用哪个;带来很大的可扩展性
    刚试了一下notepad++;然而直接爆出中文乱码,搞了好久才搞清楚;
    Java中类的构造方法 - 图16
    原因是;国标码和ANSI之间的不兼容;
    Java中类的构造方法 - 图17
    因为刚学,有什么不足的后期补上。
    望路过的大神,指点一二。