个人中心
gpt4 book ai didi

Java构造函数通透理解篇

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 29 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java构造函数通透理解篇由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、什么是构造函数

Java构造函数，也叫构造方法，是JAVA中一种特殊的函数。与函数名相同，无返回值.

作用：一般用来初始化成员属性和成员方法的，即new对象产生后，就调用了对象的属性和方法.

在现实生活中，很多事物一出现，就天生具有某些属性和行为。比如人一出生，就有年龄、身高、体重、就会哭；汽车一出产，就有颜色、有外观、可以运行等.

这些，我们就可以将这些天然的属性和行为定义在构造函数中，当new实例化对象时，也就具有这些属性和方法，不用再去重新定义，从而加快编程效率.

构造函数是对象一建立就运行，给对象初始化，就包括属性，执行方法中的语句.

而一般函数是对象调用才执行，用 ".方法名" 的方式，给对象添加功能.

一个对象建立，构造函数只运行一次.

而一般函数可以被该对象调用多次.

2、构造函数的特点

1、函数名与类名相同 。

2、不用定义返回值类型。（不同于void类型返回值，void是没有具体返回值类型；构造函数是连类型都没有） 。

3、不可以写return语句。（返回值类型都没有，故不需要return语句） 。

注：一般函数不能调用构造函数，只有构造函数才能调用构造函数.

3、示例

1、无参构造函数类中只定义一个方法。构造器总是伴随着new操作一起调用. 。

new对象时，就调用与之对应的构造函数，执行这个方法。不必写“.方法名”.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package javastudy;
 
public class ConfunDemo {
     public static void main(String[] args) {
         //输出Hello World。new对象一建立，就会调用对应的构造函数Confun()，并执行其中的println语句。
         Confun c1= new Confun();           
        
     }
}
class Confun{       
     Confun(){       
         //定义构造函数，输出Hello World
         System.out.println( "Hellow World" );
     }
}

输出:

Hellow World 。

2、有参构造函数，在new对象时，将实参值传给private变量，相当于完成setter功能.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package javastudy;
 
public class ConfunDemo3 {
     public static void main(String[] args){
         //实例化对象时，new Person()里直接调用Person构造函数并转转实参，相当于setter功能
         Person z = new Person( "aerchi" , 18 );
         z.show();
     }
}
 
class Person{
     private String name;
     private int age;
     //有参数构造函数，实现给private成员变量传参数值的功能
     public Person(String n, int m){
         name=n;
         age=m;       
     }
     //getter                                     
     //实例化对象时，完成了sett功能后，需要getter，获取实参值。
     public String getName(){
         return name;
     }
     public int getAge(){
         return age;
     }
 
     //获取private值后，并打印输出
     public void show(){
         System.out.println(name+ "\n" +age);
     }
}

输出:

aerchi 18 。

以上代码，我们也可以将show()方法中的输出语句直接放在构造函数中，new对象时，即可直接输出值，如下 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package javastudy;
 
public class ConfunDemo3 {
     public static void main(String[] args){
         //实例化对象时，new Person()里直接调用Person构造函数并转转实参，同时执行输出语句
         Person z= new Person( "aerchi" , 18 );
     }
}
 
class Person{
     private String name;
     private int age;
     //有参数构造函数，实现给private成员变量传参数值的功能，同时直接输出值
     public Person(String n, int m){ 
         name = n;
         age = m;
         System.out.println(name+ "\n" +age);
     }
}

输出:

aerchi 18 。

或 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class ConFun
{
     public static void main(String[] args){
         Person a= new Person( 18 , "aerchi" );
         System.out.println(a.getAge() + ", " + a.getName());
     }
}
 
class Person
{
     private int age;
     private String name;
     public Person( int x,String y){
         age=x;
         name=y;
     }
     public int getAge(){
         return age;
     }
     public String getName(){       
         return name;
     }
}

3、一个对象建立后，构造函数仅只运行一次.

如果想给对象的值再赋新的值，就要使用set和get方法，此时是当做一般函数使用 。

如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package javastudy;
 
public class ConfunDemo4 {
     public static void main(String[] args) {
             PersonDemo s= new PersonDemo( "张三" , 18 );  //new对象时，即调用对应的构造函数，并传值。同时，不能new同一个对象多次，否则会报错。
             s.setName( "李四" );                       //对象建立后，想变更值时，就要用set/get方法，重新设置新的值
             s.setName( "王二麻子" );    //并可调用对象多次。
             s.print();
     }
}
class PersonDemo{
     private String name;
     private int age;
     PersonDemo(String n, int m){       //建立有参构造函数，用于给两个private变量name、age赋值，同时输出值
         name=n;
         age=m;
         System.out.println( "姓名：" +name+ "\n" + "年龄：" +age);
     }
     public void setName(String x){     //set方法，用于再次给name赋值
         name=x;       
     }
     public String getName(){          //get方法，用于获取name的赋值
         return name;
     }
     public void print(){
         System.out.println(name);
     }
}

输出结果:

姓名：张三 年龄：18 王二麻子 。

4、默认构造函数

当一个类中没有定义构造函数时，系统会给该类中加一个默认的空参数的构造函数，方便该类初始化。只是该空构造函数是隐藏不见的.

如下，Person(){}这个默认构造函数是隐藏不显示的.

?
1
2
3
4
class Person
{ 
     //Person(){}
}

当在该类中自定义了构造函数，默认构造函数就没有了.

如果仍要构造函数，需要在类中手动添加.

5、构造函数的重载

构造函数也是函数的一种，同样具备函数的重载（Overloding）特性.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Person
{ 
     private String name;
     private int age;
 
     Person()
     {
         System.out.println( "A:name=" +name+ ", age=" +age);
     }
 
     Person(String n)
     {
         name = n;
         System.out.println( "B:name=" +name+ ", age=" +age);
     }
 
     Person(String n, int a)
     { 
         name=n;
         age=a;
         System.out.println( "C:name=" +name+ ", age=" +age);
     }
 
}
 
class PersonDemo2
{
     public static void main(String[] args)
     {
         Person p1= new Person();
         Person p2= new Person( "aerchi" );
         Person p3= new Person( "aerchi" , 18 );
     }
}

输出结果:

A:name=null, age=0 B:name=aerchi, age=0 C:name=aerchi, age=18 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class Person
{ 
     private String name;
     private int age;
 
     Person()
     {
         System.out.println( "A:name=" +name+ ", age=" +age);
         cry();
     }
 
     Person(String n)
     {
         name = n;
         System.out.println( "B:name=" +name+ ", age=" +age);
         cry();
     }
 
     Person(String n, int a)
     { 
         name=n;
         age=a;
         System.out.println( "C:name=" +name+ ", age=" +age);
         cry();
     }
     void cry()
     {
         System.out.println( "Haha ..............." );
     }
 
}
 
class PersonDemo2
{
     public static void main(String[] args)
     {
         Person p1= new Person();
         Person p2= new Person( "aerchi" );
         Person p3= new Person( "aerchi" , 18 );
     }
}

输出结果:

A:name=null, age=0 Haha ............... B:name=aerchi, age=0 Haha ............... C:name=aerchi, age=18 Haha ............... 。

6、构造函数的使用

1、子类所有的 构造函数 默认调用父类的无参构造函数（构造函数不会被继承，只是被子类调用而已），父类参数是private的，无法直接访问。需要在父类中使用get方法来调用私有变量值.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package javastudy;
 
public class ConfunDemo5 {
     public static void main(String[] args) {
         Pupil z= new Pupil();
         z.show();
     }
}
class Student{                //父类Student
     private String name;
     private int height;
     public Student()
     {
         this .name= "" ;
         this .height= 0 ;
     }
     public String getName(){
         return name;
     }
     public int getHeight(){
         return height;
     }
}
class Pupil extends Student{    //子类Pupil
     private int score;
     public Pupil(){                //无参构造函数Pupil()直接继承了父类中的无参构造函数Student()，但是父类中的name、height是private的
         score= 0 ;
     }
     public void show(){
         System.out.print( "姓名：" +getName()+ "\n身高：" +getHeight()+ "\n分数：" +score);  //输出时，直接用get方法名。
     }
}

2、使用super调用父类的构造函数 。

super 必须写在方法的首行 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package javastudy;
 
public class ConfunDemo5 {
     public static void main(String[] args) {
         Pupil z= new Pupil( "王二麻子" , 100 , 200 );
         z.show();
        
         Pupil w= new Pupil();
         w.show();
     }
}
class Student{                //父类Student
     public String name;
     public int height;
     public Student()
     {
         this .name= "" ;
         this .height= 0 ;
     }
     public Student(String n, int m)
     {
         name=n;
         height=m;
     }
}
class Pupil extends Student{    //子类Pupil
     private int score;
     public Pupil(){               
         super ( "刘德花" , 501 );    //使用super调用父类Student(String n,int m)方法，同时传递实际数值。super必须写在方法的首行。如果这里写super()，则调用的是父类中的Student()方法。
         score= 0 ;
     }
     public Pupil(String x, int y, int z){        //
         super (x,y);              //使用super调用父类Student(String n,int m)方法,其中super中的参数名称必须与构造函数中的参数名称一致。
         score=z;
     }
     public void show(){
         System.out.println( "姓名：" +name+ "\n身高：" +height+ "\n分数：" +score);
     }
}

输出:

姓名：王二麻子 身高：100 分数：200 姓名：刘德花 身高：501 分数：0 。

打杂人 。

到此这篇关于Java构造函数通透理解篇的文章就介绍到这了,更多相关Java构造函数内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/aerchi/article/details/90759744 。

最后此篇关于Java构造函数通透理解篇的文章就讲到这里了,如果你想了解更多关于Java构造函数通透理解篇的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

29 4 0
文章推荐： 英雄联盟手游资产等级是什么意思 英雄联盟手游资产等级怎么提升
文章推荐： Springmvc工程跳转controller无效的解决
文章推荐： Python正则表达式匹配数字和小数的方法
文章推荐： Java的三种代理模式简述
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com