Java构造器(构造方法)详解

Java构造器(构造方法)详解

什么是构造器

构造器通常也叫构造方法、构造函数,构造器在每个项目中几乎无处不在。当你new一个对象时,就会调用构造器。构造器格式如下:

[修饰符,比如public] 类名 (参数列表,可以没有参数){ //这里不能有return}

Java构造器

构造器的注意事项:

  1. 构造器的名称必须和类名一致
  2. 一个类中可以定义多个构造器,但是构造器的参数列表必须不同(重载)
  3. 如果我们没有手动定义构造器,则Java系统会提供一个默认的构造器给我们使用,一旦我们定义了构造器,则系统会把默认的构造器收回
  4. 构造器的作用:实例化对象,给对象赋初始值
  5. 代码游离块优先执行

怎么定义构造器

构造方法的名字必须和所在类的名字一致,没有返回值,但不能声明void,访问权限可以为任意,但是一般情况下使用public方法权限,构造方法中的参数可以根据需要自行定义,参数的不同的构造方法构成重载

public 构造方法名(参数){
    ...
}

/*注意:
  1.构造方法没有返回值类型
  2.构造方法名必须和该类的类名保持一致,大小写都一样

例:

   class Fu
   {
     public Fu(){} //无参的公有构造方法
     public Fu(int i){} //参数类型为int的公有构造方法
   ......
   }


   public class Demo extends Fu
   {
     public Demo(){} //无参的公有构造方法
     public Demo(int i){} //参数类型为int的公有构造方法
     public Demo(int i,double d){} //参数类型为int和double的公有构造方法
     ...
   }

构造器的使用

Java中构造方法的使用有两个地方,一个是跟在关键字new后面,类名加上一个小括号(),小括号内根据实际加上实参,另外一个是跟在关键字super或this后加上一个小括号(),小括号内根据实际添加实参,下面进行举例。

例1:

Demo demo = new Demo(); //这里是调用的是一个无参的构造方法,必须声明在方法中,最好声明在主方法

上面构造方法的参数根据实际添加实参,Jvm根据构造方法的参数不同加载不同的构造方法

例2:

public Demo(){
  this(2); //这里调用参数为int类型的本类的构造方法
 }

例3:

public Demo(){
  super(1); //调用参数为int类型的父类的构造方法
 } 

注意:例2和例3中this或super调用构造方法只能出现在构造方法中,而且必须出现在第一行,所以一个构造方法中第一行只能为this或super调用构造方法,两者不能同时调用构造方法出现,而且注意this或super调用构造方法时,要留构造方法出口,意思就是最后调用的构造方法中没有再调用别的构造方法!

构造器的继承

子类构造器会默认调用父类无参构造器,如果父类没有无参构造器,则必须在子类构造器的第一行通过 super关键字指定调用父类的哪个构造器,具体看下文例子。final类是不允许被继承的,编译器会报错。很好理解,由于final修饰符指的是不允许被修改,而继承中,子类是可以修改父类的,这里就产生冲突了,所以final类是不允许被继承的。

构造器、静态代码块、构造代码块的执行顺序,详见下文实例

  • 无继承的情况下的执行顺序静态代码块:只在程序启动后执行一次,优先级最高构造代码块:任何一个构造器被调用的时候,都会先执行构造代码块,优先级低于静态代码块构造器:优先级低于构造代码块总结一下优先级:静态代码块 > 构造代码块 > 构造器
  • 有继承的情况下的执行顺序:父类静态代码块:只在程序启动后执行一次,优先级最高 子类静态代码块:只在程序启动后执行一次,优先级低于父类静态代码块 父类构造代码块:父类任何一个构造器被调用的时候,都会执行一次,优先级低于子类静态代码块父类构造器:优先级低于父类构造代码子类构造代码块:子类任何一个构造器被调用的时候,都会执行一次,优先级低于父类构造器子类构造器:优先级低于子类构造代码块总结一下优先级:父类静态代码块 > 子类静态代码块 > 父类构造代码块 > 父类构造器 > 子类构造代码块 > 子类构造器

实例

1.默认构造器

新建一个类,不提供任何构造器,编译器会默认提供一个无参构造器,这就是为什么没定义任何构造器,却可以new 某个对象()

public class People {}
//以上这个People类就可以直接通过new People()来实例化

2.禁止对象被外部创建

如果不希望People在外部通过new People()来实例化,只需要将构造器定义为private

public class People{
    private People(){
        
    }
}

3.构造器重载

重载可以简单理解为:同个方法名,不同的参数列表。如果希望People能在外部通过new People() 或 new People(“字符串”) 来实例化,则通过以下代码即可

public class People{
    //通过new People()调用
    public People(){
        
    }
    //通过new People("字符串")调用
    public People(String str){
        
    }
    
    
}

4.构造器的继承

定义父类构造器,由于该构造器自定义了一个带参构造器,覆盖了默认的无参构造器,所以不能直接 new Father() 调用了,除非再定义一个无参构造器

//父类构造器
public class Father{
    
    //自定义带参构造器
    public Father(String str){
        System.out.println("父类的带参构造方法,参数为:"+str);
    }
    
}

定义子类构造器,继承Father,由于Father没有无参构造器,所以必须在子类构造器中通过 super(“字符串”)来调用,否则编译器会报错

//子类构造器
public class Son extends Father{
    
    //无参构造器
    public Son(){
        //由于Father()没有无参构造器,所以必须在子类型构造器中通过super("字符串")来调用,否则编译器会报错。
        //如果没定义这句,系统会默认调用super()
        super("");
    }
    
    //带参构造器
    public Son(String str){
        //由于Father()没有无参构造器,所以必须在子类型构造器中通过super("字符串")来调用,否则编译器会报错。
        //如果没定义这句,系统会默认调用super()
        super(str);      
    }  
    
}

5. 构造器、静态代码块、构造代码块的执行顺序

5.1无继承的情况
public class Father {
    static {
        System.out.println("父类的静态代码块,程序启动后执行,只会执行一次");
    }

    //父类无参构造方法
    public Father(){
        System.out.println("父类的默认构造方法");
    }

    //重载,自定义父类带参构造方法
    public Father(String str){
         System.out.println("父类的带参构造方法,参数为:"+str);
    }
    
    {
        System.out.println("父类构造代码块,每次调用构造方法都会执行的");
    }
}

实例化Father

//实例化Father
    public static void main(String[] args) {
        System.out.println("---------------------------------------");
        Father father1 = new Father();
        System.out.println("---------------------------------------");
        Father father2 = new Father("阿马");
    }

执行上述代码

父类的静态代码块,程序启动后执行,只会执行一次
---------------------------------------
父类构造代码块,每次调用构造方法都会执行的
父类的默认构造方法
---------------------------------------
父类构造代码块,每次调用构造方法都会执行的
父类的带参构造方法,参数为:阿马
5.2有继承的情况

定义父类Father

public class Father {
    
    static {
        System.out.println("父类的静态代码块,程序启动后执行,只会执行一次");
    }

    //父类无参构造方法
    public Father(){
        System.out.println("父类的默认构造方法");
    }

    //重载,自定义父类带参构造方法
    public Father(String str){
         System.out.println("父类的带参构造方法,参数为:"+str);
    }
    
    {
        System.out.println("父类构造代码块,每次调用构造方法都会执行的");
    }
}

定义子类Son,继承自父类Father

//子类构造器
public class Son extends Father{
    static {
        System.out.println("子类的静态代码块,程序启动后执行,只会执行一次,先执行父类的,在执行子类的");
    }
    {
        System.out.println("子类构造代码块,每次调用构造方法都会执行的");
    }

    //无参构造器
    public Son(){
        //这里没有指定调用父类的哪个构造方法,会默认调用super(),调用父类的无参构造器public Father()
    }

    //重载构造器,多传两个参数
    public Son(String str1,String str2){
        //必须写在构造器第一行,调用父类的带参构造器public Father(str)
        super(str1);
        System.out.println("子类带参构造器:"+str2);
    }
}

实例化Son

public static void main(String[] args) {
        System.out.println("-----------------------------------");
        Son son1 = new Son();
        System.out.println("-----------------------------------");
        Son son2 = new Son("子类第一个参数","子类第二个参数");
    }

执行上述代码

父类的静态代码块,程序启动后执行,只会执行一次
子类的静态代码块,程序启动后执行,只会执行一次,先执行父类的,在执行子类的
-----------------------------------
父类构造代码块,每次调用构造方法都会执行的
父类的默认构造方法
子类构造代码块,每次调用构造方法都会执行的
-----------------------------------
父类构造代码块,每次调用构造方法都会执行的
父类的带参构造方法,参数为:子类第一个参数
子类构造代码块,每次调用构造方法都会执行的
子类带参构造器:子类第二个参数
  • 133
    点赞
  • 602
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
Java中的监听(Listener)是一种广泛应用的设计模式,它用于处理程序中的事件。通过监听,我们可以在事件发生时执行一些特定的操作。在Java中,我们可以使用内置的监听API或自定义监听实现此功能。 下面是Java中的常见监听类型: 1. ActionListener:用于处理按钮、菜单等组件的动作事件。 2. WindowListener:用于处理窗口事件,如窗口打开、关闭等。 3. MouseListener:用于处理鼠标事件,如单击、双击、拖动等。 4. KeyListener:用于处理键盘事件,如键盘按下、释放等。 5. FocusListener:用于处理组件焦点事件,如获得或失去焦点等。 使用监听的步骤如下: 1. 创建一个监听类,该类实现了相应的监听接口。 2. 在需要监听的组件上添加监听对象。 3. 在监听类中实现相应的方法来处理事件。 下面是一个简单的示例代码,演示了如何使用ActionListener监听处理按钮单击事件: ```java import java.awt.*; import java.awt.event.*; import javax.swing.*; public class ButtonListenerDemo implements ActionListener { private JFrame frame; private JButton button; public ButtonListenerDemo() { frame = new JFrame("Button Listener Demo"); button = new JButton("Click Me"); button.addActionListener(this); frame.getContentPane().add(button); frame.pack(); frame.setVisible(true); } public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(frame, "Button Clicked!"); } public static void main(String[] args) { new ButtonListenerDemo(); } } ``` 在上面的代码中,我们创建了一个ButtonListenerDemo类,该类实现了ActionListener接口。在构造函数中,我们创建了一个按钮对象,然后将该按钮添加到窗口中,并将该按钮的监听设置为当前类。当用户单击按钮时,程序将调用actionPerformed()方法来处理事件,该方法将弹出一个消息框来告诉用户按钮已被单击。 总之,监听Java编程中非常重要的组成部分。使用监听,我们可以轻松地处理程序中的事件,并实现交互式用户界面。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值