Java中的构造器（构造方法）和this关键字

最新推荐文章于 2024-04-29 00:15:00 发布

_雨_

最新推荐文章于 2024-04-29 00:15:00 发布

阅读量729

点赞数 1

分类专栏： Java 文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/weixin_53616401/article/details/129626333

版权

Java 专栏收录该内容

73 篇文章 0 订阅

订阅专栏

什么是构造器

在Java中构造器是类的一种特殊的方法，他的主要作用是用来完成对新对象的初始化，有一些地方也把构造器叫做构造方法，因此在看到其他地方叫构造方法时不要觉得奇怪

基本语法

[修饰符] 方法名(形参列表)(

方法体；

}

1.构造器的修饰符可以默认，也可以是public protected private

2.构造器没有返回值

3.方法名和类名字必须一样

4.参数列表和成员方法一样的规则

5.构造器的调用由系统完成

代码演示：

package com.objectOriented.constructor;

/**
 * 演示构造器的基本使用
 */
public class constructor01 {
    public static void main(String[] args) {


    }
}


class Person {

    private int age;
    private String name;

    //构造器的基本语法
        /*
        public Person(){
        }
         */

    //1.构造器的修饰符可以默认，也可以是public protected private
//    public Person(){
//
//    }
    private Person() {

    }

    //2.构造器没有返回值
    //这样有返回类型就不在是构造器了，而是一个方法
//    public int Person(){
//
//    }

    //3.方法名 和类名字必须一样
//    public a(){//这样写就会报错，因为构造器的名字要和，类名保持一致
//
//    }

    //4.参数列表和 成员方法一样的规则
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    

    //5.构造器的调用由系统完成
}

构造器的特点

1)方法名和类名相同

2)没有返回值

3)在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化。

注意：构造器是对新对象的初始化，并不是创建新对象

构造器使用事项和注意细节

1.一个类可以定义多个不同的构造器，即构造器重载 ·

2.构造器名和类名要相同

3.构造器没有返回值

4.构造器是完成对象的初始化，并不是创建对象

5.在创建对象时，系统自动的调用该类的构造方法

6.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也 叫默认构造器)，使用javap指令反编译看看

7.一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无 参构造器，除非显式的定义一下，即：Dog{}写(这点很重要)

代码演示：

1.我们在创建对的时候，一般都是 Dog dog = new Dog();如果这样写，那么系统在创建对象的时候，就会默认调用无参构造器，如果是这样写Dog dog = new Dog(10); 这样调用的就是带一个参数的构造器了。

2.如果自己定义了构造器，那么默认的无参构造器就会被覆盖，如果还想要用原来的无参构造器，就需要自己重新在写一遍

package com.objectOriented.constructor;

/**
 * 演示构造的注意事项和使用细节
 */
public class ConstructorDetail {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //使用的就是这个无参构造器
        /*
        public Dog(){
        
        }
        
         */

        Dog dog1 = new Dog(1);
        /*
        使用的就是带一个参数的构造器也就是这个
        public Dog(int age){
            this.age=age;
        }
         */


    }
}

class Dog {
    private int age;
    private String name;

    //1.一个类可以定义多个不同的构造器，即构造器重载 ·
    //这样就是三个构造器，也就是构造器的重载，注意不可以写两个一模一样的构造器否则会报错
    //举例
    //这样写就是错误的，因为重载是要参数个数，顺序，或者形参类型，至少一个不同才可以
//    public Dog(){
//
//    }
    //这样也可以，参数的顺序不同
    //public Dog(String name,int age){}

    public Dog() {

    }

    public Dog(int age) {
        this.age = age;
    }

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //2.构造器名和类名要相同
    //如果写的一个和类名不相同的构造器就会报错
    //这个是错误的
//    public A(){
//
//    }

    //3.构造器没有返回值
    //这个是错误的，如果写了返回类型，那么就变成了一个方法，不是构造器了，注意go'za
//    public int Dog(){
//
//    }

    //4.构造器是完成对象的初始化，并不是创建对象
    //5.在创建对象时，系统自动的调用该类的构造方法
    //我们在创建对的时候，一般都是 Dog dog = new Dog();如果这样写，那么系统在创建对象的时候，就会默认调用无参构造器也就是这个
    /*
    public Dgo(){

    }

   注意即使你不写这个，构造器，只要没有其他的有参构造器，那么无参构造器是默认都有的
     */

    //6.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也 叫默认构造器)，使用javap指令 反编译看看
    //7.一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无 参构造器，除非显式的定义一下，即：Dog{}写(这点很重要)
    /*
    比如我们现在的dog类已经有了两个有参数的构造器，如果想要使用无参构造器，那么需要自己在重新定义一遍
     */

}

构造器习题

代码分析：

1.在使用Cat cat = new Cat();创建对象的时候，就会使用我们的默认的无参构造器，因为我们在无参构造器中已经为，age属性进行了赋值，因此创建对象实例成功后，输出的age就是18 ，而name我们并没有给他赋值所以，输出的就是null

2.第二个我们在使用Cat cat1 = new Cat(2,"jack");使用这个创建对象的时候，就不会使用我们原来的无参构造器，而是使用的是有参构造器，并且在创建对象的时候，系统会自动的帮助我们初始化属性。

package com.objectOriented.constructor;

/**
 * 构造器的习题
 */
public class ConstructorExercise {
    public static void main(String[] args) {
        // 在前面定义的Cat类中添加两个构造器：
        // 第一个无参构造器：
        // 利用构造器设置所有人的age属性初始值都为18
        // 第二个带pName和pAge两个参数的构造器：
        // 使得每次创建Person对象的同时初始化对象的
        // age属性值和name属性值。
        // 分别使用不同的构造器，创建对象.
        Cat cat = new Cat();
        System.out.println(cat.name);
        System.out.println(cat.age);
        Cat cat1 = new Cat(2, "jack");
        System.out.println(cat1.name);
        System.out.println(cat1.age);
    }
}

class Cat {

    public int age;
    public String name;

    //无参构造器
    public Cat() {
        age = 18;
    }

    //带两个参数的构造器
    public Cat(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

对象创建的流程分析

流程分析：

1.先加载Person类的信息（Person.class）,注意类的加载只会发生一次

2.在堆中分配空间（地址）

3.完成对象的初始化

（第一步默认初始化 age=0 name=null，注意在对对象进行初始化的时候，并不会直接给他赋值而是先进行默认初始化，也就是我们每一个数据类型都会有对应的默认值

第二步显式初始化age=90,name=null，然后第二部，在看在类中有没有已经直接给属性赋值了的，比如int age = 90;如果有会先对此进行初始化

第三步构造器的初始化age=20，name=小倩]。最后才是我们的构造器的初始化

4.在对象在堆中的地址，返回给p(p是对象名，也可以理解成是对象的引用)）即p就可以执行Person类中的属性，但是要遵守访问修饰符的权限

class Person{//类Person
	int age=90;
	String name;
	Person(String n ,int a)//构造器name=n;//给属性赋值
	age=a;
}//..
Person p=new Person("小倩”，20);

this关键字

this小结：简单来说，哪个对象调用，this就代表那个对象

this注意事项和使用细节

1.this关键字可以用来访问本类的属性、方法、构造器

2.this用于区分当前类的属性和局部变量

3.访问成员方法的语法：this.方法名(参数列表)；

4.访问构造器语法：this(参数列表)；注意只能在构造器中使用(即只能在构造器中访问另外一个构造器，必须放在第一条语句)

5.this不能在类定义的外部使用，只能在类定义的方法中使用。

代码演示：

package com.objectOriented.this_;

/**
 * 演示this关键字的细节
 */

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

        // T t1 = new T();
        // t1.f2();
        T t2 = new T();
        t2.f3();

    }
}

class T {
    
    String name = "jack";
    int num = 100;

	/*
	细节: 访问构造器语法：this(参数列表);
	注意只能在构造器中使用(即只能在构造器中访问另外一个构造器)

	注意： 访问构造器语法：this(参数列表); 必须放置第一条语句
	 */

    //无参构造器
    public T() {
        //这里去调用 T的带两个参数的(String name, int age) 构造器
        this("jack", 100);
        System.out.println("T() 构造器");
        //4.访问构造器语法：this(参数列表)；注意只能在构造器中使用(即只能在构造器中访问另外一个构造器，必须放在第一条语句)
//        System.out.println("T() 构造器");
//        this("jack", 100);
        

    }

    //带两个参数的构造器
    public T(String name, int age) {
        System.out.println("T(String name, int age) 构造器");
    }

    //2.this用于区分当前类的属性和局部变量
    public void f3() {
        String name = "smith";
        //传统方式 会遵守就近原则，因此输出的就是smith 而不是jack
        System.out.println("name=" + name + " num=" + num);//smith  100
        //也可以使用this访问属性 this.属性名 表示的就是全局变量
        System.out.println("name=" + this.name + " num=" + this.num);//jack 100
    }

    //细节: 访问成员方法的语法：this.方法名(参数列表);
    public void f1() {

        System.out.println("f1() 方法..");
    }

    //1.this关键字可以用来访问本类的属性、方法、构造器
    //3.访问成员方法的语法：this.方法名(参数列表)；
    public void f2() {
        System.out.println("f2() 方法..");
        //调用本类的 f1
        //第一种方式
        f1();
        //第二种方式
        this.f1();
    }

}

this例题

代码演示：

1.注意在判断字符串是否相等的时候要用equals方法不能用等号

package com.objectOriented.this_;

/**
 * this关键字例题
 */
public class thisExercise {
    public static void main(String[] args) {
        // 定义Person类，里面有name、age属性，
        // 并提供compareTo比较方法，用于判断是否和另一个人相等，
        // 提供测试类TestPerson用于测试，名字和年龄完全一样，就
        // 返回true，否则返回false
        Person person1 = new Person("jack", 10);
        Person person2 = new Person("jack", 10);

        System.out.println(person1.compareTo(person2));

    }
}

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean compareTo(Person person) {
        return this.age == age && this.name.equals(person.name);
    }
}

_雨_

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java中的构造器（构造方法）和this关键字

1.先加载Person类的信息（Person.class）,注意类的加载只会发生一次2.在堆中分配空间（地址）3.完成对象的初始化（第一步默认初始化 age=0 name=null，注意在对对象进行初始化的时候，并不会直接给他赋值而是先进行默认初始化，也就是我们每一个数据类型都会有对应的默认值第二步显式初始化age=90,name=null，然后第二部，在看在类中有没有已经直接给属性赋值了的，比如int age = 90;如果有会先对此进行初始化
复制链接

扫一扫