小白猿Day7(面向对象,构造方法)

最新推荐文章于 2025-08-08 14:03:48 发布

原创最新推荐文章于 2025-08-08 14:03:48 发布 · 122 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#html5 #html #python

小白笔记专栏收录该内容

20 篇文章

订阅专栏

本文详细介绍了Java中的构造函数，包括无参构造、含参构造和全参构造，强调构造函数在对象创建时的作用。同时，探讨了构造代码块和局部代码块的执行时机及作用。此外，讲解了`this`关键字在成员变量与局部变量冲突时的使用，以及`super`关键字在继承场景下如何调用父类构造函数和成员变量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

构造函数：

格式：与本类类名同名，且没有返回值类型

作用：创建对象，创建一次，执行一次构造函数

分类：

1）无参构造：默认存在，如果添加了其他的构造，默认的构造函数会被覆盖

2）含参构造：对于参数没有任何要求，有参数就行

3）全餐构造：全参构造的参数必须于本类属性一致

全餐构造不仅可以创建对象，还可以给对象的所有属性赋值

public class TestConstructor {
    public static void main(String[] args) {
        //4.创建Person类的对象\
        /*1,每次new对象是,都会自动出发对应类中的构造方法*/
        /*2.每一个类中都默认存在一个没有参数的构造方法
        * 但是,如果你提供了其他的构造函数,默认的无参构造会被覆盖
        * 所以,我们要手动的提供无参构造,这样才能不传参数,也能创建对象*/
        Person p1=new Person();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.address);
        p1.eat();
        /*4.每次创建对象,都会执行一个构造方法
        * 构造方法的作用:用来创建对象的 */
        Person P2= new Person(45);
        System.out.println(P2.name);
        Person P3=new Person("李逵",18,"柳树下");
        System.out.println(P3.name);
        System.out.println(P3.address);
        System.out.println(P3.age);;
    }
}
//1.创建Person类,描述人这一类事物
class Person{
//2.定义属性
    String name;//名字
    int age;//年龄
    String address;//地址
    /*3构造方法的格式:与本类类名同名,且没有返回值类型的方法*/
    //5.1创建无参构造
    public Person(){
        System.out.println("我是Person类的无参构造");
    }
  //  5.2创建本类的含参构造--含有参数的构造方法
    public Person(int n){
        System.out.println("我是Person类的含参构造"+n);
    }



    //5.3创建本类的全参构造--此构造函数的本参数与本类的属性一致
    //右键->Generate->Constructor->Shift全选所有属性->OK
    public Person(String name, int age, String address) {
        System.out.println("我是Person类的全参构造");
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void eat(){
        System.out.println("端起了我的饭盆~");
    }
  //private Person(String name, int age, String address){
    //}
    


}

构造代码块：

位置：类里方法外

执行时机：每次创建对象时的执行，并优先于构造方法的执行

作用：用于提取所有构造方法的共性功能

局部代码块：

位置：方法里

执行时机：调用本剧代码块所处的方法时执行

作用：用于控制变量的作用范围

执行顺序：构造代码块->构造方法->普通方法->局部代码块->分析

*1.当创建对象时，会触发结构函数

* 2.创建对象时，也会触发构造代码块，并且构造代码块优先于狗仔方法执行

* 3，我们厂家好对象后才能通过对象调用普通方法

* 4. 如果普通方法里面有局部代码快，才会触发对应的局部代码块 */

public class TestBlock {
    public static void main(String[] args) {

        pig  p=new pig("xiao",18);
        System.out.println(p.age);
        System.out.println(p.food);
        pig p2=new pig("佩奇");
        pig p3=new pig();
        p3.eat();
        p.eat();
        p2.eat();
    }
}
//1.创建一个小猪类用于测试
class pig{
    //2.定义属性
    String food;//食物
    int age;//年龄
    //7.创建本类的构造代码块
    {
/*构造代码快：{}
* 1.位置：类里的方法外
* 2.执行时机：每次创建对象时都会执行代码块，并且构造代码块有限于狗仔方法的执行
* 3.作用：用于提取所有的构造方法的共性功能 */
        System.out.println("野生黑猪");
        System.out.println("我是一个代码块");
    }

    //3.创建普通方法
    public void eat(){
        System.out.println("小猪爱吃菜叶子");
        //8.创建本类的局部代码块
        {
        /*局部代码块：{}
        * 1.位置：方法里
        * 2.执行时机：调用本局部代码块所处的方法是才会执行
        * 3.作用：用于控制变量的作用范围，变量的作用越小越好*/
            System.out.println("我是一个局部代码块");
            int i=100;
            System.out.println(i);//局部代码块中的局部变量i只能在代码块里使用
        }

}

    public pig(){

        System.out.println("我是Pig类的无参构造");
    }
    public pig(String  s){
        System.out.println("我是pig类的含餐构造"+s);
    }
    public pig(int n){
        System.out.println("我是pig类的含参构造"+n);
    }
    public pig(String food, int age) {
        System.out.println("今年"+age+"喜欢"+food);
        this.food = food;
        this.age = age;{

        }


    }
}

This 的用法：

1、当成员变量于局部变量同名，用this方法

2、使用this 在构造方法的第一行调用构造方法的功能

this（）；--调用的是本类的无参构造

this（参数）；--调用的是本类无参构造

（/当成员变量于局部变量同名时，可以使用this指定本科的成员变量
如果不适用this指定，打印的就是进出的这个局部变量，就近原则*/）

super的用法:

1.当父类的成员变量与子类的变量t同名时,使用super指定父类的成员变量

1)子类在创建对象时,默认会先调用父类的构造方法
* 2).原因时子类构造函数中的第一行默认存在super();-表示调用父类的无参构造*/

2.使用super 在子类构造方法的第一行调用父类构造方法的功能

super（）；--调用的是父类的无参构造

super（参数）；--调用的是父类对参数的构造方法构造

eg:this

public class TestThis2 {
    public static void main(String[] args) {
        //3.1触发无参构造创建本类对象
       Dog d=new Dog();
         //3.1触发含参构造本类对象
       // Dog d1=new Dog("旺财");

}
}
//1.创建小狗类
class Dog{
    //2.1创建本类的无参构造
    public Dog(){
        /*在无参构造中,调用含参构造的功能
        * 注意:调用是单向的,不能来回双向调用,否则回死循环报错*/
        this("哈哈哈");
        System.out.println("我是无参构造");
    }
    //2.2创建一个本类含参构造string s
    public Dog(String s){
        /*在含参构造中,调用无参构造功能
        * 规定:this关键字,必须在构造函数的第一行*/

        System.out.println("我是含餐构造"+s);

    }
}

eg:super

package cn.tedu.oop2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时,默认会先调用父类的构造方法
* 2.原因时子类构造函数中的第一行默认存在super();-表示调用父类的无参构造
* 3.当父类没有无参构造的时,可以通过super(参数) ,调用父类的其他含参构造
* 子类必须调用一个父类的构造函数,不管是无参还差含参,选一个即可
* 4.构造方法不可以被继承!因为语法的原因:要求构造方法的名字必须是本类类名
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
    public static void main(String[] args) {
          //Father2 f1=new Father2();
        //  Father2 f2=new Father2("哈哈哈2");
         // son2  s3=new son2();
          son2  s2=new son2();

    }
}
//1.创建父类
class Father2{
//    public Father2(){
//
//        System.out.println("我是父类的无参构造");
//    }
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }
}
//2/创建子类
class son2 extends Father2{

    public son2(){
      super(" ");//默认存在调用父类的无参构造
        System.out.println("我是子类的无参构造");
    }
    public son2(String s1){
        this();
        System.out.println("我是子类的含参构造"+s1);
    }

}

public class TestExtends2 {
    public static void main(String[] args) {
        Father f=new Father();
        new son().study();
    }
}
//1.创建父类
class Father {
    //3.创建父类的成员变量
    int sum = 1;
    int count = 2;
}
//2.创建子类
class son extends Father {
    //4.创建一个普通的值
    int sum=10;
    //5.创建一个子类普通的方法
    public void study(){
        System.out.println("study().......");
        int sum=100;
        //6.1打印子类的局部变量sum
        System.out.println(sum);
        //6.1打印子类的成员变量sum
        System.out.println(this.sum);
        //6.1打印父类的成员变量count
        System.out.println(count);
        //6.1打印父类的成员变量sum
        System.out.println(super.sum);

    }