Java 构造器等总结

最新推荐文章于 2024-11-09 12:43:52 发布

自己看海

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量154

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/cursed_people/article/details/118582331

版权

构造器：

Constructor: 构造器 | 构造方法 | 构造函数

作用：为对象初始化信息（初始化：第一次赋值）--> 为对象的成员变量在创建对象的同时赋值。

使用：跟随new一起使用（new第二步所调用的）

定义：

修饰符类名 (参数列表){

方法体;

}

不需要返回值的类型，也没有void；

可以根据需要定义return关键字，作用提前结束方法；

构造器的名字与类名保持一致；

特点：

构造器也是特殊的方法，可以定义多个重载构造器，构造器的名字都是与类名保持一致，参数列表不同就能构成重载构造器；

如果没有显示的定义构造器，编译器会自动提供一个空构造；

如果存在显示定义的构造器，编译器不会提供任意构造器；

注意：

空构造就是没有参数的构造器；

先创建对象后赋值；

创建对象的同时赋值，为创建赋值更早，在创建对象的时候就能确定成员的值，更简单；

为了所定义的所有的javabean，必须至少有一个空构造；

public class Class001_Constructor {
    public static void main(String[] args) {
        //先成员对象
        Dog dog = new Dog();
        dog.lookDoor();
        //创建对象的同时赋值
        new Dog("馒头").lookDoor();
        new Dog("麻团","中华田园犬","斑点").lookDoor();
    }
}
class Dog{
    public String name;
    public String type;
    public String color;

    //空构造: 没有参数的构造器
    public Dog(){
        System.out.println("空构造");
    }
    public Dog(String dogName){
        System.out.println("一个参数构造");
        //把实参接收到的数据赋值给了当前对象的成员变量name
        name = dogName;
    }
    public Dog(String dogName,String dogType,String dogColor){
        System.out.println("三个参数构造");
        //把实参接收到的数据赋值给了当前对象的成员变量name
        name = dogName;
        type = dogType;
        color = dogColor;
    }
    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
}

Static 关键字

static 静态的

成员修饰符：只能修饰成员位置的内容，不能修饰局部

修饰变量：静态变量|类变量

修饰方法：静态方法|类方法

修饰块：静态块

修饰类：静态内部类

静态内容的使用：

1、跟随类名使用

类名.静态变量名

类名.静态方法名(参数列表);

2、跟随对象使用：

引用.静态变量名

引用.静态方法名(参数列表);

成员是属于对象的

静态是属于类的

成员变量：

被static修饰的变量 -->静态变量|类变量

不被static修饰的变量 -->实例变量

成员方法：

被static修饰的方法 --> 静态方法|类方法

不被static修饰的方法 --> 实例方法

注意：

this只能使用在非静态环境中；

在非静态方法中使用this，默认指代当前调用实例方法的对象；

静态内容是独一份的，静态变量存在与静态区中，多个对象共享的资源；

成员内容跟随对象存在与对象的堆内存中，多个对象，就有多分成员；

初始加载顺序：先静态后成员；

静态内容在类第一次加载完成之后就会进行初始化；

成员变量必须在执行到new对象的时候，才会存在对象的堆内存，在对象的堆内存中才会有成员变量；

静态内容和成员内容使用区别：

1、在静态内容中，可以直接使用静态的内容，需要跟随对象使用成员。

2、在成员内容中，可以直接使用静态内容，可以直接使用成员内容。

this不能使用在静态环境中，静态的方法可以直接跟随类调用，可能根本不存在对象，静态方法的this，无法指代某个对象。

public class Class001_Static {
    //成员位置: 类中方法外
    //实例变量
    int i = 1;
    //静态变量
    static int j = 2;
    //静态方法
    public static void main(String[] args) {
        //测试静态内容使用方式
        System.out.println(j); //本类中可以省略类名直接使用
        System.out.println(Class001_Static.j);
        Class001_Static cs = new Class001_Static();
        Class001_Static cs2 = new Class001_Static();
        System.out.println(cs.j);
        //测试实例变量的使用
        System.out.println(cs.i);
        //System.out.println(Class001_Static.i);
        cs.j++;
        cs2.j++;
        System.out.println(cs.j);  //4
        System.out.println(cs2.j); //4
        System.out.println(Class001_Static.j); //4
    }
}

public class Class002_Static {
    //成员位置: 类中方法外
    //实例变量
    int i = 1;
    //静态变量
    static int j = 2;
    public static void main(String[] args) {
        System.out.println(j);
        Class002_Static cs  = new Class002_Static();
        System.out.println(cs.i);
        cs.test();
        testStatic();
    }
    //成员方法中,this默认指代调用成员方法的对象
    public void test(){
        System.out.println("成员方法");
        System.out.println(j);
        System.out.println(this.i);
    }
    public static void testStatic(){
        System.out.println("静态方法");
    }
}

有关静态变量|方法的应用场景：

1、工具类：Math，Arrays...静态工厂

可以跟随类名直接使用静态方法，使用简单

2、定义一个类，类中的内容，所有当前类型对象共享的，唯一的可以定义为静态的|没有对象就可以使用的成员可以定义为静态的

具体的需要根据业务进行分析，不绝对。

this关键字：

指代当前对象（new的对象）-->存储所有指向的对象的地址

构造器的首行调用本类中的其他构造器

this(参数列表)

区分同名的成员与局部的问题

默认就近原则

如果出现同名问题，想要指代调用成员，通过this.成员-->因为this指代对象，通过对象调用成员

如果没有同名问题，可以省略this.调用成员

在构造器中使用this，默认指代当前new的对象，存储的是this的对象的地址

在成员方法中使用this，this在成员方法中默认指代当前调用成员方法的对象

注意：

1、多个构造器之间不能互相调用，否则无法停止调用

2、在static修饰的内容中不能使用this

public class Class001_This {
    public static void main(String[] args) {
        Dog dog = new Dog("斑点波比","萨摩耶","白色");
        dog.show();

        Dog dog2 = new Dog("小白");
        dog2.show();
        System.out.println("dog2的地址"+dog2);
    }
}

class Dog{
    public String name;
    public String type;
    public String color;

    //构造器
    public Dog(){
        System.out.println("空构造");
    }

    public Dog(String name){
        System.out.println("一个参数构造");
        this.name = name;
        System.out.println("this地址" + this);
    }

    public Dog(String name,String type){
        System.out.println("二个参数构造");
        this.name = name;
        this.type = type;
    }

    public Dog(String dogName,String dogType,String dogColor){
        this(dogName,dogType);
        color = dogColor;
        System.out.println("三个参数构造");
    }

    public void lookDoor(){
        System.out.println(name+"正在看家....");
    }
    public void show(){
        String name = "局部的name值";
        //this在成员方法中默认指代当前调用成员方法的对象
        System.out.println(this.name+"-->"+type+"-->"+color);
    }
}