构造方法 订阅
构造方法是一种特殊的方法,它是一个与类同名的方法。对象的创建就是通过构造方法来完成,其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。 展开全文
构造方法是一种特殊的方法,它是一个与类同名的方法。对象的创建就是通过构造方法来完成,其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
信息
类    别
编程方法
特    点
与类同名且没有返回值类型的方法
作    用
对象的创建
中文名
构造方法
外文名
Construction method
构造方法定义
在Java中,任何变量在被使用前都必须先设置初值,如无显式赋值,则编译器会为其进行隐性赋值。Java提供了为类的成员变量赋初值的专门方法。
收起全文
精华内容
下载资源
问答
  • 构造方法
    千次阅读
    2019-07-31 01:51:07

    1. 前言

    我们知道,在 Java 中一个类可以声明一个或多个构造方法。而在 Kotlin 中,也是类似的,但是略有不同,区分了主构造方法和次构造方法。
    本文将介绍主构造方法和次构造方法的使用,以及它们之间的区别和联系。

    2. 正文

    2.1 主构造方法

    主构造方法就是主要而简洁的初始化类的方法,它是在类体外部声明的,是类头的一部分:它在类名的后面并有可选的参数,例子如下:

    class User constructor(_nickname: String) { // 带一个参数的主构造方法
        val nickname: String
        init { // 初始化代码块
            nickname = _nickname
        }
    }
    

    这个例子用到了两个 Kotlin 关键字:constructorinit。现在做一下说明:constructor 关键字用来开始一个主构造方法和从构造方法的声明。init 关键字用来引入一个初始化语句块。初始化语句块包含在类被创建时执行的代码,并与主构造方法一起使用。
    因为主构造方法不能包含初始化代码,所以需要使用初始化语句块。
    上面的例子可以写成下面这样:

    class User(_nickname: String) {
        val nickname = _nickname // 不使用初始化代码块,用参数来初始化属性
    }
    

    这里没有把初始化代码放在初始化语句块中,而是用参数来初始化属性。去掉了 constructor 关键字,因为这里主构造方法没有注解或可见性修饰符。
    上面的例子可以进一步简化:

    class User(val nickname: String) // "val" 表示相应的属性会用构造方法的参数来初始化
    

    到这儿,已经是最简洁的写法了。
    Ps:

    1. 在一个类中,可以声明多个初始化语句块,那么初始化语句块和属性初始化器的执行顺序是什么样的?

      class InitOrder(name: String) {
      	val firstProperty = "First property: $name".also { println(it) }
      	init {
          	println("First initializer block that prints $name")
      	}
      	val secondProperty = "Second property: $name".also { println(it) }
      	init {
          	println("Second initializer block that prints $name")
      	}
      }
      fun main(args: Array<String>) {
      	InitOrder("patient")
      }
      /*
      * 打印结果:
      * First property: patient
      * First initializer block that prints patient
      * Second property: patient
      * Second initializer block that prints patient
      */
      

      从上面的例子可以看出,打印顺序就是它们出现在代码中的顺序。并且,也可以知道主构造器中的参数不仅可以用在初始化代码块中,也可以用在属性初始化器中。

      1. 主构造器中的参数可以声明为 val 或者 var
      2. 如果主构造器有注解或者可见性修饰符,那么 constructor 这个关键字就是必需的。注解或修饰符位于 constructor 关键字前面。
      class Customer private constructor(name: String)
      
      class CustomView @JvmOverloads constructor(
      	context: Context,
      	attrs: AttributeSet? = null,
      	defaultStyleAttr: Int = 0
      ) : View(context, attrs, defaultStyleAttr)
      
      1. 可以像函数参数一样为构造方法参数声明一个默认值。需要注意的是,如果所有的构造方法参数都有默认值,编译器会生成一个额外的不带参数的构造方法来使用所有的默认值。看下面的例子:
      class User5(
      	val nickname: String = "wzc",
      	val isSubscribed: Boolean = true
      )
      
      fun main(args: Array<String>) {
      	val wzc = User5() // 这个就是额外生成的不带参数的构造方法,但使用了所有的默认值
      	println("nickname=${wzc.nickname},isSubscribed=${wzc.isSubscribed}")
      	val john = User5("John")
      	println("nickname=${john.nickname},isSubscribed=${john.isSubscribed}")
      
      	val peter = User5("Peter", false)
       	println("nickname=${peter.nickname},isSubscribed=${peter.isSubscribed}")
      
      	val may = User5("May", isSubscribed = false)
      	println("nickname=${may.nickname},isSubscribed=${may.isSubscribed}")
      
      	val tiger = User5(isSubscribed = false, nickname = "Tiger")
      	println("nickname=${tiger.nickname},isSubscribed=${tiger.isSubscribed}")
      }
      /*
      nickname=wzc,isSubscribed=true
      nickname=John,isSubscribed=true
      nickname=Peter,isSubscribed=false
      nickname=May,isSubscribed=false
      nickname=Tiger,isSubscribed=false
      */
      
      1. 如果你的类具有一个父类,主构造方法同样需要初始化父类。
      open class User6(val nickname: String)
      
      class TwitterUser(nickname: String) : User6(nickname)
      
      fun main(args: Array<String>) {
      	val twitterUser = TwitterUser("alex")
      	println(twitterUser.nickname)
      }
      
      1. 如果一个非抽象类没有声明任何的构造方法(主构造方法或从构造方法),那么它就会有一个生成的不带任何参数的主构造方法。这个构造方法的可见性是 public 的。private 主构造方法,那么这个类外部的代码不能实例化它。这点在单例模式中会用到。
      2. 在主构造方法中使用参数默认值和参数命名,而不是使用多个从构造方法来重载和提供参数的默认值。
      3. 主构造方法里的参数带 valvar,与不带 valvar 的区别是什么?
      class Dog(_name: String) {
      	val name = _name
      	fun show() {
          	// println(_name) // 编译错误:不能引用到 _name
      	}
      }
      class Cat(_name: String) {
      	val name: String
      
      	init {
          	name = _name
      	}
      }
      class Fish(val name: String) {
      	fun show() {
          	println(name)
      	}
      }
      

      可以看到带 valvar,可以在方法中直接使用;而不带的,只能用于属性初始化,或者初始化代码块,而不能用于方法中。

    2.2 从构造方法

    从构造方法使用 constructor 关键字引出。可以声明任意多个从构造方法。
    例子:
    没有主构造方法,有两个从构造方法的例子

    class MyBehavior : CoordinatorLayout.Behavior<View> {
        constructor() : super()
        constructor(context: Context, attrs: AttributeSet) : super(context, attrs)
    }
    

    如果类有一个主构造方法,那么每一个次构造方法都需要委托给主构造方法;

    class User constructor(name: String) {
        var name: String
        init {
            println("init")
            this.name = name
        }
    
        constructor(): this("unknown") {
            println("second")
        }
    }
    
    fun main(args: Array<String>) {
        val user = User()
        println(user.name)
    }
    /*
    打印结果:
    init
    second
    unknown
    */
    

    从打印结果可以看出,主构造方法是首先执行的。

    如果类没有主构造方法,那么每个从构造方法必须初始化基类或者委托给另一个这样做了的构造方法。
    从构造方法和初始化代码块的执行顺序:

    class Constructors {
        init {
            println("Init block")
        }
    
        constructor(i: Int) {
            println("Second constructor")
        }
    }
    
    fun main(args: Array<String>) {
        Constructors(1)
    }
    
    /*
    Init block
    Second constructor
    */
    

    从构造方法的主要使用场景:Java 的互操作性;当你使用不同的参数列表,以多种方法创建类的实例时,使用不同的参数列表。

    3. 最后

    简单总结一下:

    • 一个类至多可以声明一个主构造方法,但一个类可以声明任意多个从构造方法。
    • 主构造方法的 constructor 关键字可以省略,但从构造方法的 constructor 关键字不可以省略。
    • 主构造方法不可以包含初始化代码块,但从构造方法可以包含初始化代码块。

    那么最后再说一下:主构造方法和从构造方法,怎么选用呢?
    优先考虑使用主构造方法;如果主构造方法不能解决,再去考虑从构造方法。

    参考

    • https://kotlinlang.org/docs/reference/classes.html#constructors;
    • 《Kotlin 实战》
    更多相关内容
  • java中怎样用巧用构造函数初始化成员变量,在类于对象中有关this的那几个用法,你真的懂了吗?不再复习一下吗

    Hello,各位铁汁们!我是小🐟儿哈!今天我又来更新我的Java基础学习博客了。

    本篇主要内容概述:

    1、🍚如何用构造方法初始化对象

    2、🍚为啥要有this这个关键字

    3、🍚this.属性名访问成员变量、成员方法

    4、🍚this.方法名 || this.()的用法

    目录

    初识构造方法 

    构造方法的使用 

    初识this 

    this.xx的用法

    this()用于构造函数的调用


    初识构造方法 

    我们上篇讲了java中类的创建,那么让我们来实战演练一下:创建一个学生类,里面有学生的基本信息,包括姓名、性别、年龄、学号,你可能会写出这样的代码:

    class Student {
        String name;
        String gender;
        int age;
        long studentID;
    }
    public class TestDemo2 {
        public static void main(String[] args) {
            Student stu1 = new Student();
            stu1.name = "张三";                  // 给stu1对象的各个成员变量赋值
            stu1.gender = "男";
            stu1.age = 19;
            stu1.studentID = 231245431;
            // 打印输出
            System.out.println("姓名:" + stu1.name + " 性别:" + stu1.gender + " 年龄:" + stu1.age + " 学号:" + stu1.studentID);
        }
    }

     🍑但你在写的时候,是不是感觉给对象的成员变量一个一个的赋值太繁琐,能不能一下子就把值赋好呢?还真能,用Java中的构造方法就能做到这一点

    那么快来看看什么是构造方法吧!

    🍑构造方法是类的一种特殊方法,用来初始化类的一个新的对象,在创建对象(new 运算符)之后自动调用,Java中的每个类都有一个默认的构造方法,并且可以有一个以上的构造方法。

    Java 构造方法有以下特点:

    • 方法名必须与类名相同
    • 可以有 0 个、1 个或多个参数
    • 没有任何返回值,包括 void
    • 默认返回类型就是对象类型本身
    • 只能与 new 运算符结合使用


    🔔值得注意的是,如果为构造方法定义了返回值类型或使用 void 声明构造方法没有返回值,编译时不会出错,但 Java 会把这个所谓的构造方法当成普通方法来处理

    🍑下面就是一个构造方法的使用例子

    class Student {
        String name;   //学生类的属性
        int age;
        public void eat() {
            System.out.println(name + "在吃饭");   // 学生类的行为(方法)
        }
        public Student() {
            System.out.println("这是自定义的一个不带参数的构造方法");
        }
    }
    public class TestDemo3 {
        public static void main(String[] args) {
            Student student1 = new Student();
        }
    }
    

    看到输出结果,你是不是感到:咦?不对啊,我的main方法里明明就只是实例化了一个对象啊😮!我没输出啊,为啥还会输出构造方法中的内容啊

      Student student1 = new Student();

    🍑原因就是:当类的对象被创建时,该构造方法将被自动调用

    🍑其实我们在用new关键字实例化对象时 , 程序一定干了这两件事(但可能不只有这两步)

    1. 📝在堆区分配对象需要的内存
    2. 📝调用合适的构造方法

    🍑看到这,你可能又有问题了,我们之前实例化对象的时候明明没定义构造方法呀!怎么能说实例化对象时程序一定调用构造方法呢?

    😊是这样的,当一个类中没有提供任何构造方法,系统默认提供一个无参数的构造方法,就像这样

    Student() {
    }
    

    🔔 但如果类中显式地定义了一个或多个构造方法,则系统不再提供默认构造方法。
     

    在一个类中,与类名相同的方法就是构造方法。每个类可以具有多个构造方法,但要求它们各自包含不同的方法参数,比如这样:

    Student() {
        System.out.println("这是自定义的一个没有参数的构造方法");
    }
    Student(String name) {
        this.name = name;
        System.out.println("这是自定义的带有一个参数的构造方法");
    }

    • 🌻 该示例就定义了两个构造方法,分别是无参构造方法和有参构造方法。
    • 🌻如果在一个类中定义多个具有不同参数的同名方法,称作方法的重载。
    • 🌻这两个构造方法的名称都与类名相同,均为Student。在实例化该类时可以调用不同的构造方法进行初始化。


    构造方法的使用 

     那么,就让我们来看一下,调用构造方法是怎样解决上面那个麻烦的问题的,嘻嘻😎

    class Student {
        String name;
        String gender;
        int age;
        long studentID;
        // 该构造方法可由IDEA自动生成
        public Student(String name, String gender, int age, long studentID) {  
            this.name = name;
            this.gender = gender;
            this.age = age;
            this.studentID = studentID;
        }
    }
    public class TestDemo2 {
        public static void main(String[] args) {
            Student stu1 = new Student("张三", "男", 19, 231245431);
            System.out.println("姓名:" + stu1.name + " 性别:" + stu1.gender + " 年龄:" + stu1.age + " 学号:" + stu1.studentID);
        }
    }

     🍑怎么样,是不是一下子就把值赋好,哈哈😉,并且类中的构造方法的定义还不用自己写,在IDEA有相应的快捷键可以自动生成,就像这样:

    在IDEA里点击鼠标右键,弹出窗口-->在窗口中选择Generate-->点进去后选择Constructo-->按住ctrl键的同时点击鼠标,把那几个参数全选上,点击OK😎

    嘻嘻,是不是IDEA帮你自动生成了🥰,方便吧


    初识this 

     不过,构造方法中的this.name是什么意思啊,以前不都是 "对象名.成员变量" 吗,来接下来,我们慢慢说这个this到底是什么东东🤔

    首先,咱先来看一段代码😉

    class Date {
        int year;
        int month;
        int day;
        // 通过构造函数传参来赋值
        public Date(int year, int month, int day) {
            year = year;
            month = month;
            day = day;
        }
    
        public void printDate() {
            System.out.println(year + "/" + month + "/" + day);
        }
    }
    
    public class TestDemo2 {
        public static void main(String[] args) {
            Date date1 = new Date(2022, 4, 2);
            date1.printDate();
        }
    }
    

    这段代码有什么问题吗?细心的同学可能以经发现了 :在Date类中,传入构造方法的参数名称和Date的成员变量名字相同🤔,那么在Date类中的构造方法中就会出现一个问题:

    public Date(int year, int month, int day) {
            // 那函数体中到底是谁给谁赋值?成员变量给成员变量?参数给参数?参数给成员变量?
            // 成员变量给参数?估计自己都搞不清楚了
            year = year;            // 当传入的参数相同是怎么办!
            month = month;
            day = day;
    }

    大家觉得在上面的main方法中会输出什么?是2022/4/2吗😉? 

    让我们一起来看看吧?

    😮输出竟然是0/0/0,好像我们根本没给year,month,day赋值似的? 

    其实当构造方法的参数与类所定义的属性同名时,对于方法中的year = year,虚拟机不清楚在这里year到底是传过来的参数还是对象的成员变量,那么为了让虚拟机知道我们是把参数2022赋值给当前对象的成员变量year,我们就需要借助java中this这个关键字:

    class Date {
        int year;
        int month;
        int day;
        // 添加了this关键字的构造函数
        public Date(int year, int month, int day) {
            this.year = year;
            this.month = month;
            this.day = day;
        }
    
        public void printDate() {
            System.out.println(year + "/" + month + "/" + day);
        }
    }
    
    public class TestDemo2 {
        public static void main(String[] args) {
            Date date1 = new Date(2022, 4, 2);
            date1.printDate();
        }
    }
    

     

     💡那为什么用this.name = name 赋值就好了呢?


    this.xx的用法

    🏀按照官方正规的解释,this关键字的意义被解释为“指向当前对象的引用”,比如在上述代码中当前所实例化的对象是date1,那么this其实就指向date1,是date1的一个引用(也可以理解为是date1的一个别名)那么this.xxx其实就代表了date1.xxx😎

    🏀所以在执行”this.name=name;”这条语句的时候,虚拟机就会把参数year的值”2022”赋值给对象date1的year成员变量。也就是说在这条赋值语句中,”=”左边的”this.year”表示对象date1的year成员变量,而”=”右边的year表示传给我们构造方法的参数

    🏀讲到这里,有的小伙伴可能会问:”this.year”为什么不能被解释为”当前对象date1自己的year参数”呢🤔?

    🍑因为”参数”这个概念是就某个方法而言的,它相当于某个方法的”局部变量”,只是这个”局部变量”比起在方法中定义的真正的局部变量来讲有点特殊,🧢它能够接收从主调方法中传递过来的值因此,当我们说到”参数”这个概念的时候,都是相对于一个”方法”而不是一个”对象”而言的,所以也就不会有”某个对象的参数”这一说法。因此,”this.year”只能被虚拟机认定为当前对象date1自己的year成员变量,绝不会被当作参数。

    不知道大家理解💡了吗

     🧢可能现在你还有点模糊,但没关系,我们现在只是刚接触到this这个关键字,先能模仿着用就行,以后可以慢慢理解😂

    🧢刚才我们用this.成员变量名访问了我们当前对象的成员变量,那么我们能不能用this.成员方法名去访问我们的方法呢?当然可以呀this.xxx此时的作用不就相当于对象名.xxx吗😎,直接上代码😁

    class Cat {
        public void jump() {
            System.out.println("这个猫在跳!!!");
        }
        public void run() {
            this.jump();        // 在run方法中用this.方法名调用当前对象的一个成员方法jump
            System.out.println("这个猫在跑!!!");
        }
    }
    public class TestDemo2 {
        public static void main(String[] args) {
            Cat cat = new Cat();
            cat.run();
        }
    }
    

    🍑 可以看出在我们成功的在run方法中用this.方法名调用了同一个类下的其他方法。

    注意🔔:

    虽然调用本类的普通方法前可以不使用this关键词。但是建议追加是this,这样的目的是可以区分方法的定义来源🤔


    this()用于构造函数的调用

    🍑咱们之前说了,同一个类中可以同时有多个构造函数,通过this()还可以在一个构造函数里调用另一个构造函数。

    class Cat {
        String name;
        int age;
        Cat() {
            System.out.println("这是自定义的一个不带参数的构造函数");
        }
    
        public Cat(String name, int age) {
            this();            // 调用另一个不带参数的构造方法
            
            this.name = name;
            this.age = age;
            System.out.println(this.name + this.age + "岁了");
            System.out.println("这是自定义的一个带两个参数的构造函数");
        }
    }
    public class TestDemo2 {
        public static void main(String[] args) {
            Cat cat = new Cat("小花", 3);
        }
    }
    

     从输出结果可以看出通过💡this(),我们成功在一个构造方法中调用另一个不带参数的构造方法

    🔔但有几个问题需要我们注意一下 

    • this( ) 不能在普通方法中使用,只能写在构造方法中。
    • 在构造方法中使用时,必须是第一条语句。

    另外,再补充一些小细节📝 

    很多小伙伴可能不理解,为什么要通过这种方式来调用构造方法呢?我们在上面调用Cat类中一个不带参数的构造方法时,难道不能直接写一个🍑Cat();来调用吗?

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

    🔔这里必须做出解释:在Java语言中,一个类的构造方法与类名相同。但是,一个类当中也可以定义一个与类名相同的”普通方法”,💡换句话说就是:并不是只有构造方法与类名相同,”普通方法”也可以取和类相同的名称(只不过全世界的程序员都不会这么干)。

    🔔那么,在这种情况下,编译器如何区分这个方法是”普通方法”还是”构造方法”呢?💡很简单,”普通方法”的名称前面必须定义返回值类型,而”构造方法”的名称前面则没有返回值类型的定义。这样,编译器就能够分得清哪个是”构造方法”,哪个是”和类同名的普通方法”。

    🔔定义的时候分得清,但是在调用的时候,都是通过方法名来调用的💡,这时如何分得清代码中哪一句调用的是”构造方法”, 哪一句调用的是”和类同名的普通方法”呢?为了解决这个问题,Java语言规定,在本类中调用构造方法的时候,需要通过”🍑this(参数)”的方式来调用

    今天有关java中构造方法和this的使用分享就到这里了😊,下一篇博客让我们搞清楚public、static到底是个什么东东 🤔

    码字不易😅,各位铁汁们,都看到这里了,点个赞再走好吗😍

    展开全文
  • Java有参构造方法和无参构造方法详解

    万次阅读 多人点赞 2020-12-09 12:05:16
    一:有参数构造方法 在之前我们要为一个对象赋值,先要创建好对象之后然后“对象名.属性名”或者调用属性的setter为属性赋值。但是在很多时候觉得这样做很麻烦,最好的做法是在创建对象的时候完成属性的初始化操作...

     

    一:有参数构造方法

    在之前我们要为一个对象赋值,先要创建好对象之后然后“对象名.属性名”或者调用属性的setter为属性赋值。但是在很多时候觉得这样做很麻烦,最好的做法是在创建对象的时候完成属性的初始化操作,此时需要使用到有参数构造方法方能完成该功能(有人把构造方法叫做构造器)。

     

    DEMO:定义有参数构造方法

    上面定义了四个有参数构造方法,发现了构造方法可以重载,

    书写的习惯是重载的构造方法按照参数的个数进行升序排序。但是如何去调用有参数的构造方法呢?

     

    DEMO:调用有参数构造方法

    此时发现了我们不需要像之前一样,要为对象的属性赋值就必须先创建对象再使用“对象名.属性名”或者使用setter 方法去实现了,而是直接使用有参数的构造方法去实现。

     

    DEMO:继续观察代码

    此时提示“这个无参数构造Student()方法未定义”,在之前我们说了JVM会默,认为类提供无参数构造方法,但是这只能是在没有任何有参构造方法的条件下,现在我们定义了四个有参数构造方法(JVM认为你不需要无参数构造方法了),所以JVM不再提供无参数的构造的构造方法了。

    所以我们定义 了有参数构造方法那么也需要显示的定义出无参数构造方法。

     

    DEMO:显示定义无参数构造方法

     

    总结:

    1、构造方法的出现是为了方便为对象的属性初始化值

    2、一般在类中构造方法的顺序都是按照参数的个数去升序排序的

    3、如果定义了有参构造方法那么JVM就不会在提供无参数构造了,所以如果我们定义了有参构造那么无参构造也要显示的定义出来。

     

    二:Java无参构造方法

     

    一:构造方法给的概念

    在之前我们使用过方法,在调用的方法的是时候需要在方法名称之后加.上小括号,括号里面可以传递实参,那么我们在创建一个对象的时候使用的是“new类名()”的方式去实现,其实上这也是一种方法,但是这个方法我们没有明确的去定义,那为什么可以调用呢?观察代码。

    DEMO:观察代码

    以上的代码在创建的对象的时候使用“Student()”,发现了在“Student”之后使用小括号,这和方法的调用很相似,其实“Student()”就是-一个方法,是一个特殊的方法-构造方法,发现了构造方法的名称和类名一样,而且一定是在new关键字之后调用的。但是我们没有在Student类中看到这个方法依然能够调用,原因是JVM(Java的虚拟机,暂时不用管,你就认为是系统,后面我们讲解JVM内存模型的时候会分析)系统默认为该类提供了无参数构造方法,所以我们才能调用。

    我们也可以显示的将该方法定义出来。

    DEMO:显示的定 义构造方法

    此时我们显示的定义了一个五参数构造方法,构造方法是在什么时候调用的呢?如何很明显的看出调用了构造方法?

    DEMO:观察构造方法调用的时机

    总结:

    1、构造方法的概念(构造方法的出现是为了在实例化对象的时候可以为对象的属性初始化值)。

    2、默认jvm会为每个类提供一个无参数构造方法。

    3、构造方法的特征和它与普通方法的区别你要清楚。

     

     

    学习不要走马观花的学,每个知识重点大纲,就是学习路线都是根据每一天市场上多数公司用到的新技术整理,在学习的时候还需要结合练习题来做这里的话我也将我之前在学习过程中用到的一些学习资料整理成了文档,以及我自身之前的一个面试文案和知识点补充,有需要的朋友可以加我的QQ群   697888503   ,这里也希望大家最终都能够学有所成,学习编程不是一天两天的功夫,勤能补拙才是硬道理,祝大家最终都能成为一名合适开发攻城狮。 

    展开全文
  • Java中构造方法调用构造方法??

    千次阅读 2021-02-12 13:19:58
    心有猛虎_细嗅蔷薇正确的调用方法应该是直接一个this()来调用构造方法。请看代码:classStudent{Stringid;Stringname;Stringsex;//创建构造方法publicStudent(Stringid,Stringname,StringclassNum,Stringsex,intage){...

    535e16483efd23e5031372280ac0f581.png

    心有猛虎_细嗅蔷薇

    正确的调用方法应该是直接一个this()来调用构造方法。请看代码:class Student{

    String id;

    String name;

    String sex;

    //创建构造方法

    public Student(String id,String name,String classNum,String sex,int age){

    this(id,name,classNum,sex);

    this.age = age;

    }

    //重载构造方法,有两个参数

    public Student(String id,String name){

    this.name = name;

    this.id =id;

    }

    //重载构造方法,有3个参数

    public Student(String id,String name,String sex){

    this(id,name);                //在三个个参数的构造方法里面调用两个参数的构造方法 this(id,name)

    this.sex = sex;               // 在添加另一个参数,实现构造方法调用构造方法

    }

    public static void main(String[] args) {

    }

    }

    展开全文
  • java构造方法

    千次阅读 2022-02-26 17:41:08
    目录 一.构造方法概述: 二....构造方法是一个比较特殊的方法,通过构造方法可以完成对象的创建, 以及实例对象的初始化,换句话说:构造方法是用来创建对象,并且同时给对象的属性赋值。 二..
  • Java有参构造方法和无参构造方法

    万次阅读 多人点赞 2021-02-12 17:05:28
    (如果自己添加构造函数,无论有参数或是没参数,默认构造函数都将无效)编写时添加了有参构造方法而未添加无参构造方法,那么编译器只认有参构造方法而不会默认添加无参构造方法!如果需要使用无参构造方法,一定要在...
  • 一文搞懂Java的 构造方法 和 访问权限

    千次阅读 多人点赞 2020-07-20 16:41:54
    Java是一门当今最火的编程语言之一,拥有很多现成可用的库,在我们编程生涯中,有着无比重要的地位。本文主要讲解Java中的构造方法和四种类的访问权限。
  • Java构造器(构造方法)详解

    千次阅读 多人点赞 2021-09-11 21:47:58
    Java构造器(构造方法)详解 什么是构造器 构造器通常也叫构造方法、构造函数,构造器在每个项目中几乎无处不在。当你new一个对象时,就会调用构造器。构造器格式如下: [修饰符,比如public] 类名 (参数列表,可以...
  • 关于构造方法

    千次阅读 2022-03-30 19:40:29
    关于构造方法
  • Java中的构造方法(构造函数)与普通方法区别

    千次阅读 多人点赞 2020-10-17 00:50:29
    Java中的构造方法构造方法)与普通方法区别 ** 一、明白什么是构造方法,什么是普通方法? 所谓的构造方法,是一种特殊的方法,其作用是用来创建对象时初始化对象,即为对象成员变量赋初始值,总是与new运算符一起...
  • Java构造方法和子类构造方法

    千次阅读 多人点赞 2019-07-21 23:50:09
    Java构造方法 构造方法是用于初始化一个新建的对象。 普通构造方法 方法名与类名相同 无返回类型 子类不能继承父类的构造方法 不能被static、final、abstract修饰(有final和abstract修饰的是不能被子类继承的,...
  • 目录 1.构造方法的定义与说明 2.构造方法的声明与使用 3.注意事项 1.构造方法的定义与说明 ...如果没有显式地为类定义构造方法,Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方...
  • 构造方法的定义

    千次阅读 2021-03-06 19:14:44
    在一个类中定义的方法如果同时满足以下三个条件,该方法称为构造方法,具体如下:方法名与类名相同。在方法名的前面没有返回值类型的声明。在方法中不能使用return语句返回一个值。接下来通过一个案例来演示如何在类...
  • java this关键字调用构造方法

    千次阅读 2021-02-12 13:22:11
    一 this调用构造方法构造方法之间的调用,可以通过this关键字来完成。格式:this(参数列表);构造方法的调用举例:classPerson {//Person的成员属性private intage;privateString name;//无参数的构造方法Person() {}...
  • 构造方法作用就是对类进行初始化。 如果你没有定议任何构造方法的形式,程式会为你取一个不带任何参数的构造函数,那么你产生类的对像时只能用不带参数的方法.下面小编和大家来一起学习一下吧.怎么写 java构造方法...
  • 构造方法--无参构造方法

    千次阅读 2021-07-29 18:35:04
    没有指定构造方法: package java_animal; /** * 宠物猫类 * @author Y */ public class Cat { //成员属性:昵称、年龄、体重、品种 String name; //String类型变量默认值是null int month; //int类型变量...
  • Java构造器(构造方法/constructor)

    千次阅读 2021-02-12 19:24:43
    我们先来看一下什么是构造器:1、构造器也叫构造方法或构造函数,分为有参构造器和无参构造器;2、构造器也是一种方法,只不过是一种特殊的方法,它会在对象创建的时候被调用;3、构造器最大的作用就是在创建对象的...
  • java怎么调用构造方法

    千次阅读 2021-03-04 04:38:04
    Java调用构造方法,那就是子类调用基类(父类)的构造方法,如何调用,请看详细内容。子类中的构造方法的规则子类的构造过程中必须调用其基类的构造方法。子类可以在自己的构造方法中使用super(argument_list)调用基类...
  • 简单了解JAVA构造方法

    千次阅读 2021-02-12 23:17:19
    怎么写java构造方法必须满足以下语法规则:(1) 方法名必须与类名相同。(2)不要声明返回类型。(3)不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承,所以用final和abstract修饰没有...
  • java中构造方法和普通方法的区别

    千次阅读 2021-02-25 20:22:24
    java中构造方法和普通方法的区别一、普通方法是有修饰符修饰的成员方法,根据关键字static的有无分为静态方法和非静态方法;一旦使用static修饰成员方法,就成为了静态方法,静态方法不属于对象,而是属于类的;如果...
  • 构造方法

    万次阅读 多人点赞 2019-05-21 15:54:08
    构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是调用构造方法。 格式 public 类名称(参数类型 参数名称){ 方法体 } 注意事项 构造方法的名称必须和所在的类名称完全一样,就连大...
  • java的构造方法

    千次阅读 2021-07-20 18:14:59
    一、构造方法概述 这是创建一个对象 Student s1 =new Student(); 重点看new后边的Student() 我们常常根据一个东西的命名规则来判断他是一个什么,比如单词首字母大写,其他全小写,例如Student,StudentDemo这种...
  • 实例方法、类方法、构造方法

    千次阅读 多人点赞 2019-11-19 14:11:00
    Java中类的方法分为类方法(用static修饰,也叫静态方法)和...构造方法,没有返回值(就是连void都没有),方法名与类名一样 public static void myMethod();//类方法 public void myMethod2();//实例方法 public ...
  • Python中构造方法的解析(附示例)

    千次阅读 2020-12-29 06:06:56
    本篇文章给大家带来的内容是关于Python中构造方法的解析(附示例),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。Python中会看到前后都加双下划线的函数名,例如 __init__(self),这类写法在...
  • java重载方法与构造方法 区别

    万次阅读 2022-05-31 16:35:49
    本章讲述什么是构造方法和重载方法 以及区别,特点 ,实例

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,758,780
精华内容 1,103,512
关键字:

构造方法

友情链接: puzzle-master.zip