构造函数 构造/局部代码块this

1.构造方法

1.1概念
构造方法是一种特殊的方法，它是一个与类同名且没有返回值的方法
构造方法的主要功能就是完成对象创建或者初始化
当类创建对象(实例化)时，就会自动调用构造方法
构造方法与普通方法一样也可以重载
1.2形式
与类同名，且没有返回值类型，可以含参也可以不含参

1.3练习：构造方法创建对象/构造方法赋值

package cn.tedu.cn.tedu.oop;

import com.sun.xml.internal.bind.v2.schemagen.xmlschema.TypeHost;

public class TestConstructor {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println(p.age);
        System.out.println(p.address);
        System.out.println(p.name);
        p.eat();
        System.out.println("------------------------");
        /*没词创建对象就会触发一次无参构造
        * 构造方法的作用：用来创建对象*/
        Person p2 = new Person();
        System.out.println(p2.age);
        System.out.println("-=--------------------------");
        Person p3=new Person(88);
        System.out.println(p3.name);
        System.out.println("------------------");
        Person p4 = new Person("小建",18,"在天上");
        System.out.println(p4);
        System.out.println(p4.name);
        System.out.println(p4.address);

    }
}
    class Person{
        String name;
        int age;
        String address;

        public Person(){
            System.out.println("我是无参构造");
            System.out.println(name);
        }
        public Person(int n){
            System.out.println("我是含参构造"+n);
            System.out.println(name+"77");
        }
        public void eat(){
            System.out.println("我是功能-方法");
        }
/**关于构造函数的记忆：
 * 1.特点：方法名与类名相同，且没有返回值类型
 * 2.执行时机：创建对象立即执行
 * 3.默认会创建无参构造但是如果自定义了含参构造。默认的无参构造会被覆盖，注意需要手动添加*/
//创建本类的全参构造
//右键->Generate->Constructor->Shift全选所有属性->OK
/**This只能在方法内部使用，表示对"吊桶发的那个对象的引用。"但要注意，如果在方法内部调用同一个类的另一个方法
 * ，就不必shiyongthis，直接调用即可。当前方法中的this引用会自动应用于同一类中的其他方法。*/
        public Person(String name, int age, String address) {
            this.name = name;
            this.age = age;
            this.address = address;
            System.out.println("我是全参构造");
            System.out.println(name+"6");
            System.out.println(address+"6");
        }
    }

构造代码块与局部代码块

2.1形式：

{ 代码… }

2.2 构造代码块的特点

位置: 在类的内部,在方法的外部
作用: 用于抽取构造方法中的共性代码
执行时机: 每次调用构造方法前都会调用构造代码块
注意事项: 构造代码块优先于构造方法加载

2.3局部代码块

位置: 在方法里面的代码块
作用: 通常用于控制变量的作用范围,出了花括号就失效
注意事项: 变量的作用范围越小越好,成员变量会存在线程安全的问题

2.4练习：测试代码块的加载顺序

package cn.tedu.cn.tedu.oop;

public class TestBlock {
    public static void main(String[] args) {
        //5.分别触发3个构造函数创建对象
//        pig p1 = new pig();
//        pig p2 = new pig("佩奇");
        pig p3 = new pig("肉包子",5);
        //6.通过创建好的对象进行测试
//        System.out.println(p1.age);//0,默认值
//        System.out.println(p2.age);//0,默认值
        System.out.println(p3.age);//5，创建对象时赋值的

//        p1.eat();
//        p2.eat();
        p3.eat();

    }
}
//1.创建一个小猪类用于测试
class pig{
    //2.定义属性(成员变量)
    String name;
    int age;
    //7.创建本类的构造代码块
    {
        /**构造代码块{}
         * 1.位置：类里方法外
         * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块优先于构造方法执行
         * 3.作用：用于提取所有构造方法的共性功能*/

        System.out.println("我是一个构造代码块");

    }
    //4.创建本类的无参构造/含参构造/全参构造
    public pig(){

        System.out.println("我是无参构造");
    }
    public pig(String s){
        System.out.println("我是含参构造"+s);
    }
    //右键->Generate->Constructor->Shift全选所有属性->ok
    public pig(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("我是全参构造");

    }

    //3.创建普通方法

    public void eat(){
        System.out.println("小猪爱吃菜叶子");

        {
            /**局部代码块：{}
             * 1.位置方法里
             * 2.执行时机：调用本局部代码块所处的方法时才会执行
          * 3.作用：用于控制变量的作用范围，变量的作用方位越小越好*/
            System.out.println("我是一个局部代码块");
          int i=100;
            System.out.println(i);
        }
    }
}

//构造代码块->构造方法->普通方法->局部代码块->

执行顺序

构造代码块->构造方法->普通方法->局部代码块

this

概念：this代表本类对象的一个引用对象

练习: this练习之变量名相同时使用

package cn.tedu.cn.tedu.oop;

import java.sql.SQLOutput;

/*本类用于this测试*/
public class TestThis1 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();

    }
}
class Cat{
    int count=666;
    int sum=100;
    {
        System.out.println("构造代码块");
        int sum= 666 ;
        System.out.println(sum);
    }
    public void eat(){
        int sum=10;
        System.out.println(sum);
        /**在同一个类中成员变量和和方法里的变量同名时而且在方法里调用同名变量的时候会调用方法里的变量，
         * 方法里的变量也叫局部变量，若想调用类里的成员变量需要用This指定*/
        System.out.println(this.sum);
        System.out.println(sum);
    }

    public Cat(){
        System.out.println("无参构造");
        System.out.println(sum+"泡");
        {
            System.out.println("我是局部代码块");
        }
    }
}

package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
    public static void main(String[] args) {
        //3.1触发无参构造创建本类对象
        Dog d1 = new Dog();
        //3.2触发含参构造创建本类对象
        //Dog d2 = new Dog("旺财");
    }
}
//1.创建小狗类
class Dog{
    //2.1创建本类的无参构造
    public Dog(){
        /*在无参构造中，调用含参构造的功能
        * 注意：调用是单向的，不能来回双向调用，否则会死循环*/
        this("小旺旺");
        System.out.println("无参构造");
    }
    //2.2创建本类的含参构造String s
    public Dog(String s){
        /*在含参构造中，调用无参构造的功能
        * 规定：this关键字必须在构造函数的第1行*/
        //this();
        System.out.println("含参构造"+s);
    }
}

创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情
1.把Person.class文件加载进内存
2.在栈内存中，开辟空间，存放引用变量p
3.在堆内存中，开辟空间，存放Person对象
4.对成员变量进行默认的初始化
5.对成员变量进行显示初始化
6.执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
7.堆内存完成
8.把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值

package cn.tedu.cn.tedu.oop;
/*本类用于进行oop综合练习*/
// 创建对象的流程
//         Person p = new Person();//短短这行代码发生了很多事情
//         1.把Person.class文件加载进内存
//         2.在栈内存中，开辟空间，存放引用变量p
//         3.在堆内存中，开辟空间，存放Person对象
//         4.对成员变量进行默认的初始化
//         5.对成员变量进行显示初始化
//         6.执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
//         7.堆内存完成
//         8.把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值
public class TestTeacher {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println(teacher.getName());
        teacher.setName("鲁智深");
        System.out.println(teacher.getName());
        //创建对象开辟一块内存叫堆，堆里面存的数据的方式是地址值
        Teacher teacher1 = new Teacher("诸葛","智星",28,300);
        System.out.println(teacher1.getName());
    }

}
class Teacher{
    private String name;
    private String gender;
    private int age;
    private double salary;
    public Teacher(){
        System.out.println("无参构造");
    }

    public Teacher(String name, String gender, int age, double salary) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.salary = salary;
        System.out.println(" 我是全参构造");
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}