java构造器及this、super、package、import关键字

一.构造器

constructor:建造者，建设者

定义：构造器：和类名相同但无返回类型（也不能写void）的方法。
说明：
用于当前或某一对象的实例化，并将当前或某一对象返回。要得到一个类的实例时，往往是要运行其构造函数/构造器的。
二.构造器的作用：
1.创建对象
2.初始化对象的信息
三、构造器的格式：

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

四、构造器的特点：
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式：权限修饰符 类名（参数列表）{}
3.一个类中定义多个构造器，彼此构成重载。
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器（即每个类都有自己的构造器）。
6.构造器的默认权限和类一致。类是public则构造器也是，类是缺省的，构造器也是缺省权限。

二.属性的赋值过程

：

三.拓展知识：JavaBean

JavaBean:是一种java语言写成的可重用性组件。
所谓JavaBean,是指符合如下标准的java类：

• 1.类是公共的
• 2.有一个无参的公共的构造器
• 3.有属性，且有对应的getter,setter方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的jsp页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的赋值和粘贴的功能，而不用关心任何改变。

四.this关键字

this关键字的使用：

this的产生：

在类的方法中，我们可以使用“”this.属性”或者“”this.方法”的形式，调用当前对象属性或方法。但是通常情况下，我们都选择省略this.
特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用this.变量的方法，声明次变量是属性，而且是某一个对象的属性，而非形参。

1.this可以用来修饰：属性、方法、构造器

2.this修饰属性和方法：
this理解为：当前对象（谁调用含有this的方法，那么this就代表谁！）或当前正在创建的对象（构造其中的this）
3.this可以调用构造器：
3.1我们在类的构造器中，可以显式使用"this(形参列表)"方式，调用类中指定的其他构造器
3.2构造器中不能通过“”this()参数列表”方式调用自己（不能自己和自己玩吧），同理，不能出现交叉调用，来回互相调用（不能互相调用永远不出来吧）。
3.3如果一个类中有n个构造器，则最多有n-1构造器中使用了“this（形参列表）”
3.4规定：“this（形参列表）”必须声明在当前构造器的首行。
4.5构造器内部，最多只能声明一个“this（形参列表）”，来调用其他的构造器。

4.this的产生和深入理解：

代码演示：

package com.fan.ssm.pojo;

public class StuTest {
    public static void main(String[] args) {
        Jianli jianli01 = new Jianli();
        jianli01.setName("张三");

        Jianli jianli02 = new Jianli();
        jianli02.setName("李四");
    }
}
//简历类（简历模板）
class Jianli {
    private String name;//姓名，为了演示this,我们设置一个属性和方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //技能方法
    public void jieng(){
        System.out.println("写代码");
    }
}

图文结合：

图文理解说明（自己拙见，有问题希望大佬指正）：
我们暂且把一个类想象成一个word简历模板，这个简历中有姓名，电话，地址等。然后这个简历模板当有人使用的时候，就去打印一份纸质的（创建这个模板的一份实例/对象） ，比如张三打印了一份，李四也打印了一份。那张三的那个纸质的简历中有名字属性，同样李四的那个纸质的简历中也有名字属性，当张三填写自己的名字（类似于setName(String name)）的时候就是把张三这个参数名字 赋值给 统一简历模板的这个名字这一栏；对于模板来说就是这个模板的属性名字。而对于对象来说，就是把模板中的this泛指，变成了当前这个纸质对象。this从这方面看来就是一个联系类和对象的桥梁（在类中叫this,到了对象那就具体指代正在使用的那个对象）。

总结：this从这方面看来就是一个联系类和对象的桥梁（在类中叫this,到了对象那就具体指代正在使用的那个对象）。

this调用构造器实例：

五、super关键字

super:理解为：父类的

(1)super可以用来调用：属性、方法、构造器

(2) super语法格式：

super.属性名//访问父类的属性

super.方法名(参数);//调用父类的方法。

super(参数);//调用父类的构造方法。
//初始化当前对象的父类型特征

(3)特点：

1、super的使用不限于直接父类
2、如果父类和爷爷类中都相同的成员，则默认访问的是父类的成员，遵循就近原则
3、this(实参列表)和super(实参列表)不能同时出现在构造器中

(4)super的使用（重点）:

1.我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方法，显式的调用父类中声明的属性和方法。但是通常情况下，我们习惯省略super.;
2.特殊情况：当子类和父类中定义了同名的属性时（比如，都子父类都定义了 int id,String name,属性不会覆盖掉，内存中是存在两个同名id,或者两个同名的name），我们要想在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的是父类中声明的属性。
3.特殊情况：当子类重写父类的方法以后，我们想在子类的方法中调用父类中被重写前的方法时，则必须显式的使用super.方法的方式，表明调用的是父类中被重写前的方法。

代码演示父子类出现同名属性的情况：

3.特殊情况演示：当子类重写父类的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用super.方法的方式，表明调用的是父类中被重写前的方法。

（3）super调用构造器

1、一个类如果没有手动提供任何构造方法，系统会默认提供一个无参数构造方法。
2、一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供。

3、重要的结论！！！：

3.1当一个构造方法第一行既没有this()又没有super()的话，系统默认会有一个super()；表示通过当前子类的构造方法调用父类的无参数构造方法。所以必须保证父类的无参数构造方法是存在的。
3.2我们在类的构造器中，针对于“this(形参列表)”或者“suoper(形参列表)”只能二选一，不能同时出现；必须二选一（即:不是super（形参列表）,就是this（形参列表））。

3.3 我们可以在子类的构造器中显式的使用“super(形参列表)”的形式，调用父类中声明的指定的构造器。
3.4 “super（形参列表）”的使用，必须声明在子类的构造器的首行。
3.5 在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类中的构造器。（不可能只有this(参数列表)，不然就成了一个环了）

代码演示：
父类Person ：

package com.fan.domain;

public class Person {//作为父类被继承复用的
    String name;
    private int age;//验证父类私有属性能不能被子类继承

    public Person(){
        System.out.println("我是父类空参构造器");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private void show(){
        System.out.println("父类私有展示方法");
    }
    public  void sleep(){
        System.out.println("父类睡觉");
    }

}

子类Student :

package com.fan.domain;

public class Student extends Person {
    int score;//成绩属性

	/*
    当一个构造方法第一行既没有this()又没有super()的话，
    系统默认会有一个super()；表示通过当前子类的构造方法调用父类的无参数构造方法。
    所以必须保证父类的无参数构造方法是存在的
    * */
    public Student(){
        //super();隐式调用了。也可以显式写出来
        System.out.println("我是子类空参构造");
    }

	/*
    当一个构造方法第一行既没有this()又没有super()的话，
    系统默认会有一个super()；表示通过当前子类的构造方法调用父类的无参数构造方法。
    所以必须保证父类的无参数构造方法是存在的
    * */
    public Student(int score){
        //super();隐式调用了。
        System.out.println("我是子类有参构造");
        this.score = score;
    }

    //这个方法不是重写；如果是重写，则可以通过：子类对象.show()调用，并显示“子类私有方法”
    //下面通过测试类进行验证
    public void show(){//private 方法
        System.out.println("子类私有展示方法");
    }

}

测试类StudentTest ：

package com.fan.domain;

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student(90);

        System.out.println("===============");
        Student student1 = new Student();

    }
}

另外理解此内存图：

(5)构造方法链

1、在任何情况下,构造一个类的实例时,将会调用沿着继承链的所有父类的构造方法。当构造一个子类的对象时,子类构造方法会在完成自己的任务之前,首先调用它的父类的构,造方法。如果父类继承自其他类,那么父类构造方法又会在完成自己的任务之前,调用它自己的父类的构造方法。这个过程持续到沿着这个继承体系结构的最后一个构造方法被调用为止。
2、父类的构造方法是一定会执行的。

六、 this和super的对比

1.this：代表本类对象，可以访问本类的属性、方法、构造。它的出现主要为了区分成员变量和局部变量，以及调用本类构造器。

通过this访问成员时，先从本类中查找，如果找不到再从直接父类找，如果还找不到，继续往上追溯找间接父类，直到找到为止！

2.super：代表父类引用，可以访问父类的属性、方法、构造。它的出现主要为了区分本类和父类的成员，以及调用父类构造器。

通过super访问成员时，先从直接父类找，如果还找不到，继续往上追溯找间接父类，直到找到为止！

七、package关键字

1. 为了根号的实现项目中类文件的管理，提供包的概念。（从文件存放位置来看，包本质就是文件夹，从workspace下就可以查看，或者eclips中的Navigate下查看是文件夹）
2. 使用package声明类或接口所属的包，声明在原文件的首行
3. 包，属于标识符，遵循标识符的命名规则、规范（包名全是小写的）、“见名知意”。
4. 每“.”一次，就代表一层文件目录
   补充：同一个包下，不能命名同名的接口、类
   不同的包下，可以命名同名的接口、类

八、import关键字

import:导入的意思，一般是导包，需要包外的类才需要导包的。

1. 在源文件中显式的使用import结构导入指定包下的类、接口。（即本包外类要在本包内用，需要导包）
2. 如果使用的类或者接口是本包内定义的，则可以省略impot结构。
3. 声明在包的声明 和类的声明之间。package下面。
4. 如果需要导入多个结构，则可以并列写出即可。
5. 可以使用“xxx.*”的方法，表示可以导入xxx包下的所有结构。
6. 如果使用的类或接口是java.lang包下定义的，则必须省略import结构。
7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
8. 使用“xxx.*”方式表明可以调用xxx包下的所有结构，但是如果使用的是xxx子包下的结构，则仍然需要显式import。
   9.import static :导入指定类或接口中的静态结构：属性或方法。