慢慢学习，然后惊呆所有人（六 ， 面向对象，二，构造函数）

目录

构造函数的使用：

this指针

类的成员初始化顺序

​

static 关键字

构造代码块与静态块

二个类的访问与使用

---

构造函数的使用：

作用：初始化成员变量

定义：

//无参
访问修饰符 类名称(){

}
//有参
访问修饰符 类名称(参数){

}

特点：

1.名称必须和类相同，

2.不能写返回值

3.如果定义类，没有写构造函数，JVM会自动生生成一个构造函数（无参）

4.如果定义了构造函数，系统将不再生成无参的构造函数（自己定义）

public class Text_person {
    //用户名
    String user;
    //密码
    double passwd;

//构造函数（alt+insert:上传构造方法)
    public  Text_person(String user,double passwd) {
        this.passwd = passwd;
        this.user = user;
        }
        //一旦我们自定义构造函数，无参构造不会自动生成，要自己构造
    public  Text_person(){

    }
}

对象属性默认值

int （整数）	0
float double （浮点数）	0.0
boolean （布尔类型）	false
char	' '
对象	null

this指针

在Java类中，存在一个this指针，该指针会自动在创建对象时，默认指向对象（最近的）。

类的成员初始化顺序

在初始对象时，首先初始化的是属性，之后才是构造函数，方法是在调用时才初始化。调用完成后出栈。

public class Test {
    public static void main(String[] args) {
        Student one= new Student();

    }
}
//构造学生类
class Student{
    //创建属性
    int id;
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }

}
//构造教室类
class Cls{
    int cla_id;
    String cls_mame;
    public Cls(int cla_id,String cls_mame){
        this.cla_id=cla_id;
        this.cls_mame=cls_mame;

    }
    //创建无参构造函数
    public Cls(){
        System.out.println("我是一个教室");
    }

}

static 关键字

static 是Java关键字：“静态的”

1，被static修饰的成员变量会被先加载到内存中

2，static修饰的方法，变量都属于类本身，不是对象，可以通过类名称调用（好处，可以不用构建对象，方便使用）

public class Test {
    public static void main(String[] args) {
        Student.say();
    }
}
//构造学生类
class Student{
    //创建属性
    int id;
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }
    //static 修饰的方法先加载
    public static void say(){
        System.out.println("我是一个学生");
    }

}

3，静态方法中不能直接调用（原因：加载顺序不同）

4，static修饰的变量，是放在常量区域的，不能回收（能修改）

public class Test {
    public static void main(String[] args) {
        Student one= new Student();
        //static修饰后，加载后可以访问为空
        System.out.println(one.id);

    }
}
//构造学生类
class Student{
    //创建属性
    static int id; //static 修饰后先加载。
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }

}
//构造教室类
class Cls{
    int cla_id;
    String cls_mame;
    public Cls(int cla_id,String cls_mame){
        this.cla_id=cla_id;
        this.cls_mame=cls_mame;

    }
    //创建无参构造函数
    public Cls(){
        System.out.println("我是一个教室");
    }

}

构造代码块与静态块

static {
        //静态代码块
        System.out.println("我是一个静态代码块");
        System.out.println("静态块，我只调用一次");
    }

    {
        //构造代码块
        System.out.println("构造代码块！！！");
        System.out.println("在构造函数之前执行");
    }

构造代码块：

1，直接定义在类中{}

2，相当于构造函数，比构造函数先调用触发。

二个类的访问与使用

匿名函数：

 Student one= new Student(1,"小罗","男",new Cls(2,"二班的"));
        //new Cls() 匿名对象

public class Test {
    public static void main(String[] args) {
        Student one= new Student(1,"小罗","男",new Cls(2,"二班的"));
        //new Cls() 匿名对象
        //访问
        System.out.println(one.name+"是"+one.cls.cls_mame);

    }
}
//构造学生类
class Student{
    //创建属性
    int id;
    String name;
    String gender;
    //引用其他类
    Cls cls=new Cls();
    //构造函数
    public Student(int id,String name,String gender,Cls cls){
        this.id=id;
        this.name=name;
        this.gender=gender;
        this.cls=cls;
    }
    //创建无参构造函数
    public Student(){
        System.out.println("我是一个学生");
    }

}
//构造教室类
class Cls{
    int cla_id;
    String cls_mame;
    public Cls(int cla_id,String cls_mame){
        this.cla_id=cla_id;
        this.cls_mame=cls_mame;

    }
    //创建无参构造函数
    public Cls(){
        System.out.println("我是一个教室");
    }

}