精华内容
下载资源
问答
  • JAVA构造函数(方法)

    万次阅读 多人点赞 2019-06-03 21:56:24
    java构造函数,也叫构造方法,是java中一种特殊的函数。函数名与相同,无返回值。 作用:一般用来初始化成员属性和成员方法的,即new对象产生后,就调用了对象了属性和方法。 在现实生活中,很多事物一出现,就...

    一、什么是构造函数

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

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

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

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

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

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

     一个对象建立,构造函数只运行一次。

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

     

    二、构造函数的特点

    1、函数名与类名相同

    2、不用定义返回值类型。(不同于void类型返回值,void是没有具体返回值类型;构造函数是连类型都没有)

    3、不可以写return语句。(返回值类型都没有,故不需要return语句)

    注:一般函数不能调用构造函数,只有构造函数才能调用构造函数。

     

     三、示例

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

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

    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功能。

    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对象时,即可直接输出值,如下

    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

     或

    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方法,此时是当做一般函数使用

    如下:

    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
    王二麻子

     

    四、默认构造函数

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

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

    class Person
    {  
        //Person(){}
    }

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

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

     

    五、构造函数的重载

    构造函数也是函数的一种,同样具备函数的重载(Overloding)特性。

    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

     

    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 ...............

     

    六、构造函数的使用

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

    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 必须写在方法的首行

    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构造函数

    千次阅读 多人点赞 2018-11-22 13:06:46
    Java构造函数创建java构造函数的规则Java构造函数的类型没参数的构造函数 (默认函数的构造类型)Java参数化构造函数Java 构造函数重载java的构造函数和方法之间的区别Q)构造函数没有返回值 ?Q)可以构造函数执行...


    java中的构造方法是一种特殊类型的方法,用于初始化对象。Java构造函数在对象创建时被调用。 它构造值,即提供对象的数据,这是为什么它被称为构造函数。

    创建java构造函数的规则

    • 构造函数名称必须与其类名称相同
    • 构造函数必须没有显式返回类型

    Java构造函数的类型

    没参数的构造函数 (默认函数的构造类型)

    示例

    class Student {
        int id;
        String name;
    /*
    *	public Student(){
    *	}                                                 //这个是默认的构造函数
    */
    }
    

    在上面的类中,代码中并没有创建任何构造函数,但编译器自动提供了一个默认构造函数。而默认构造函数的初始化就是为以上字段提供该类型初始的默认值。

    id = 0;
    name = null;
    

    Java参数化构造函数

    具有参数的构造函数称为参数化构造函数。作用:参数化构造函数用于为不同对象提供不同初始化的值。

    示例

    class Student {
        int id;
        String name;
    
    	public Student(int id,String name){
    		this.id = id;
    		this.name = name;
    	}                                                 
    }
    

    Java 构造函数重载

    构造方法重载是Java中的一种技术,一个类可以有任何数量的参数列表不同的构造函数。编译器通过构造函数参数列表中的参数数量及其类型来区分这些构造函数。

    示例

    class Student {
        int id;
        String name;
        int age;
    
        Student(){
        }                                                                             //初始默认构造函数
    
        Student(int i, String n) {				    //重载默认构造函数
            id = i;
            name = n;
        }
    
        Student(int i, String n, int a) {                          //重载默认构造函数
            id = i;
            name = n;
            age = a;
        }
    }
    

    java的构造函数和方法之间的区别

    Java构造函数Java方法
    构造器用于初始化对象的状态(数据)。方法用于操作对象。
    构造函数不能有返回类型。方法一般都有返回类型。
    构造函数隐式调用。方法要显式调用。
    如果没有指定任何构造函数,java编译器提供一个默认构造函数。在任何情况下编译器都不会提供默认的方法调用。
    构造函数名称必须与类名称相同。方法名称随意
    Q)构造函数没有返回值 ?

    A)不是的,构造函数返回当前类的实例(不能指定返回值类型,但它会返回一个值)。

    Q)可以构造函数执行其他任务而不是初始化?

    A)可以的构造函数可以执行任何操作,类似于普通方法。

    展开全文
  • java构造函数

    千次阅读 2019-05-25 16:18:54
    在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数Java构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。 构造函数...

    当新对象被创建的时候,构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数。
    Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
    构造函数必须与类名相同
    构造函数不能有返回值(返回值也不能为void)
    构造函数不能被继承
    子类可以通过super显式的调用父类的构造函数
    构造函数的权限修饰符的默认修饰符和当前类的权限修饰符一致

    展开全文
  • JAVA构造函数

    千次阅读 2014-02-26 16:21:35
    Java中,当为一个类创建了多个构造函数时,有时想在一个构造函数中调用另一个构造函数以减少代码量。这时可以使用this关键字来实现。 通常,当使用this关键字时,它意味着“这个对象”或者“当前对象”,并且它...

    在Java中,当为一个类创建了多个构造函数时,有时想在一个构造函数中调用另一个构造函数以减少代码量。这时可以使用this关键字来实现。
    通常,当使用this关键字时,它意味着“这个对象”或者“当前对象”,并且它自身产生对当前对象的引用。在一个构造函数中,当给传递给它一个参数列表时,它就有了不同的意义。它将直接的调用能够匹配这个参数列表的构造函数。因此,我么可以直接的调用其它构造函数:


    public class Neeke{

     int age = 0;
     String name = "";

     Neeke(int a){
      age = a;
      System.out.println("age:" + age);
     }

     Neeke(String n){
      name = n;
      System.out.println("name:" + name);
     }

     Neeke(int a, String n){
      this(a);
      this.name = n;
      System.out.println("both!");
     }
     
     public static void main(String[] args){
      new Neeke(5, "ssss");
     }
     
    }

    为什么构造函数Neeke(int a, String n)中的name赋值不可以调用对应的构造方法呢?尽管可以在构造函数中调用构造函数,但是只可以调用一次,并且构造函数的调用必须排在第一位,否则将会出现编译时错误。

     

    package gouzao;

    public class Gouzao {

     public Gouzao(){
      
      this("this is Gouzao");
      System.out.println("默认构造函数已经被调用");
     }
     
     public Gouzao(String s){
      this(5);
      System.out.println("参数是String的构造函数已经被调用");
     }
     
     public Gouzao(int a){
      this(6.0);
      System.out.println("参数是 int的构造函数已经被调用");
     }
     
     public Gouzao(double a){
     
      System.out.println("参数是double的构造函数已经被调用");
     }
     
     public static void main(String[] args){
      new Gouzao(); 
     }
    }

    参数是double的构造函数已经被调用
    参数是 int的构造函数已经被调用
    参数是String的构造函数已经被调用
    默认构造函数已经被调用
    !!!!!递归性构造函数调用会出现编译错误

     

     

     

     

     

     

    展开全文
  • 主要介绍了java构造函数示例(构造方法),需要的朋友可以参考下
  • 本篇文章给大家详细讲述了Java构造函数与普通函数用法以及相关知识点,对此有兴趣的朋友可以参考学习下。
  • 主要介绍了Java构造函数的相互调用代码示例,分享了两段代码示例,通过this关键字实现对的构造函数的调用,具有一定参考价值,需要的朋友可以了解下。
  • Java 构造函数的详解

    万次阅读 多人点赞 2016-07-14 14:54:44
    我们人出生的时候,有些人一出生之后再起名字的,但是有些人一旦出生就已经起好名字的。那么我们在java里面怎么在对象一旦...而构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初
  • java构造函数调用构造函数

    千次阅读 2014-04-26 15:01:57
    一个类可包含多个构造函数,在java中一个构造函数可以
  • Java构造函数之调用父类构造函数

    万次阅读 2016-09-21 09:54:39
    如果父类提供了无参数的构造函数,此时子类的构造函数就可以不显式的调用父类的构造函数,默认调用父类的无参构造函数。 package com.bjut.StudyTest; class Person { public Person() { Syste
  • Java构造函数中调用构造函数

    千次阅读 2019-07-22 23:44:39
    Java中,当为一个类创建了多个构造函数时,有时想在一个构造函数中调用另一个构造函数以减少代码量。这时可以使用this关键字来实现。通常,当使用this关键字时,它意味着“这个对象”或者“当前对象”,并且它自身...
  • Java构造函数 为什么需要无参构造函数  分享| 2013-05-08 16:20匿名 | 浏览 3298 次  java编程语言函数 class cust { int a; cust(){} cust(int a) { this.a=a; } } class test { cust A=...
  • JAVA构造函数不能使用void关键字

    千次阅读 2018-12-24 21:18:29
    JAVA构造函数不能使用void关键字 ** Java 函数的构造函数一般不返回值,所以新手容易添加void关键字,这时候编译器容易报错 java.lang.NullPointerException,这是因为构造函数代表的函数子函数可能会有返回值,...
  • js构造函数与JAVA构造函数

    千次阅读 2008-03-02 16:08:00
    下面是我自己对JS构造函数与JAVA构造函数区别的一点看法:先看两段JS构造函数的代码: script language="javascript"> function Person(i)...{ this.address = i; } Person.prototype.n
  • java构造函数在什么时候被调用及特点1 构造函数在什么时候被调用2 构造函数特点 1 构造函数在什么时候被调用 在java语言 中,构造函数又称构造方法。构造函数的作用是初始化对象,即在创建对象时被系统调用(与普通...
  • Java构造函数到底有没有返回值?

    万次阅读 2016-03-11 09:37:27
    Java构造函数到底有没有返回值?
  • Java 构造函数特点

    千次阅读 2019-03-20 12:10:52
    构造函数定义的是,对象在调用功能之前,在建立时,应该具备的一些内容。也就是对象的初始化内容。 (2). 构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后,当对象调用该功能时才会执行。 ...
  • java构造函数的调用

    2018-11-09 01:35:42
    一、使用this关键字 构造函数的调用,需要使用this关键字 ...在一个构造函数中调用另一个构造函数,主要是为了增加代码的复用性。 二、实际使用 package com.initialization; /** * 构造...
  • JNI之 c/c++调用java构造函数

    千次阅读 2017-12-23 16:15:02
    有时候c/c++是面向过程编码,很多有用工具类都没有,要编码人员自己实现,如果可以调用java...public class JniConsTest { //c访问java构造函数,并返回对象 public native Date getCurrentTime(); public static voi
  • 通常java构造函数被设置为public的(若你不写构造函数java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里。...
  • java构造函数简要分析

    千次阅读 2013-12-17 17:27:04
    java在创建对象的时候会同时调用这个对象的构造函数完成对象的初始化工作。 使用构造函数时需要记住: 1.构造函数必须与类同名(如果一个源文件中有多个类,那么构造函数必须与公共类同名) 2.每个类可以有一个...
  • B继承自A,在B的构造函数中调用super(),在A的这个方法中调用 多态的构造方法 this(2),这时会调用A的多态方法,而不是B的。 但如果是非构造方法,则会调用子类B的方法。 这就是为什么Android自定义...
  • java 构造函数什么时候被调用执行

    千次阅读 2021-03-30 21:26:41
    java语言 中,构造函数又称构造方法。特殊性在于,与普通方法的区别是,他与类名相同,不返回结果也不加void返回值。构造函数的作用是初始化对象,即在创建对象时被系统调用(与普通方法不同,程序不能显示调用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 668,670
精华内容 267,468
关键字:

java怎么构造函数

java 订阅