day07(2021.10.13)--构造函数

review

package cn.tedu.review;
/*本类用于复习面向对象案例*/
public class TestPhone {
    public static void main(String[] args) {
        //4.创建手机类对象测试
        Phone p1 = new Phone();
        //5.
        p1.setBrand("banana");
        p1.setColor("石墨黑");
        p1.setSize(4.5);
        p1.setPrice(999);
        //6.查看p1
        System.out.println(p1.getBrand());
        System.out.println(p1.getColor());
        System.out.println(p1.getPrice());
        System.out.println(p1.getSize());
        //7.创建手机类的第二个对象
        Phone p2 = new Phone();
        //8.调用手机类的功能
        p2.music();
        //p2.message();//不可以直接调用发短信的功能，因为私有方法只能在本类使用
        p2.video();
    }
}
//1.创建手机类
class Phone{
    //2.创建手机类的属性
    private String brand;
    private double size;
    private double price;
    private String color;

    //3.创建方法
    public void music(){
        System.out.println("正在听音乐");
        message();
    }
    private void message(){
        System.out.println("正在发短信");
    }
    public void video(){
        System.out.println("正在看直播");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
}

构造函数

1.构造函数：
格式：与本类类名同名，且没有返回值类型
作用：创建对象，创建一次，执行一次构造函数
分类：
1）无参构造：默认存在，如果添加了其他构造，默认的构造函数会被覆盖
2）含参构造：对于参数没有任何要求，有参数就行
3）全参构造：全参构造的参数必须与本类属性一致
全参构造不仅可以创建对象，还可以给对象的所有属性赋值

2.构造代码块：
1）位置：类里方法外
2）执行时机：每次创建对象时执行，并且优先于构造方法执行
3）作用：用于提取所有构造方法的共性功能

3.局部代码块：
1）位置：方法里
2）执行时机：调用本局部代码块所处的方法时执行
3）作用：用于控制变量的作用范围

package cntedu.oop;
/*本类用作构造函数的入门案例*/
public class TestConstructor {
    public static void main(String[] args) {
        //4.
        /*1.每次new对象时，都会自动触发对应类中的构造方法
        * 2.每一个类中都会默认存在一个没有参数的构造方法
        * 但是你提供了其他的构造函数，默认的无参构造会被覆盖掉
        * 所以，我们要手动提供无参构造，这样才能不传参数，也能创建对象
        * */
        Person p1 = new Person();
        System.out.println(p1.name);
        System.out.println(p1.age);
        System.out.println(p1.address);
        p1.eat();
        /*4.每次创建对象，都会执行一个构造方法
        * 构造方法的作用：用来创建对象的*/
        Person p2 = new Person(500);
        System.out.println(p2.name);
        /*5.全参构造不仅可以创建对象，还可以给对象的所有属性赋值*/
        Person p3 = new Person("李逵",18,"柳树下");
        System.out.println(p3.name);
        System.out.println(p3.age);
        System.out.println(p3.address);
    }
}
//1.创建类
class Person{
    //2.
    String name;
    int age;
    String address;

    /*3.构造方法的格式：与本类类名同名且没有返回值类型的方法*/
    //5.创建本类的无参构造
    public Person(){
        System.out.println("我是Person类的无参构造");
    }
    //5.2创建本类的含参构造--含有参数的构造方法
    public Person(int n){
        System.out.println("我是Person类的含参构造" + n);
    }


    //5.3创建本类的全参构造--此构造函数的参数与本类的属性一致
    public Person(String name, int age, String address) {
        System.out.println("我是Person类的全参构造");
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //3.功能--方法
    public void eat(){
        System.out.println("端起了我的饭盆");
    }
}

package cn.tedu.oop;
/*本类用于测试代码块
* 执行顺序：构造代码块 -> 构造方法 -> 普通方法 -> 局部代码块,分析
* 1.当创建对象时，会触发构造函数
* 2.创建对象时，也会触发构造代码块，并且构造代码块优先于构造方法执行
* 3.我们创建好对象后才能通过对象调用普通方法
* 4.如果普通方法里有局部代码块，才会触发对应的局部代码块
* */
public class TestBlock {
    public static void main(String[] args) {
        System.out.println("今天的你真好看");
        Pig p1 = new Pig();
        Pig p2 = new Pig("佩奇");
        Pig p3 = new Pig("肉包子",10);
        System.out.println(p2.age);
        System.out.println(p3.age);
        p1.eat();
        p2.eat();
        p3.eat();
    }
}
//1.
class Pig{
    String food;
    int age;

    //7.创建本类的构造代码块
    {
        /*构造代码块：{}
        * 1.位置：类里方法外
        * 2.执行时机：每次创建对象时都会执行构造代码块，并且构造代码块先于构造方法执行
        * 3.作用：用于提取所有构造方法的共性功能*/
        System.out.println("我是一个构造代码块");
        System.out.println("黑猪!");
    }
    //4.1无参构造
    public Pig(){
        System.out.println("我是Pig类无参构造");
    }
    //4.2含参构造
    public Pig(String s){
        System.out.println("我是Pig类含参构造" + s);
    }
    //4.3全参构造
    public Pig(String food, int age) {
        System.out.println("我是Pig类全参构造");
        this.food = food;
        this.age = age;
    }
    //3.
    public void eat() {
        System.out.println("小猪爱吃菜叶子");
        //8.创建本类的局部代码块
        {
            /*局部代码快：{}
            1.位置：方法里
            2.执行时机：调用本局部代码块所处的方法时才会执行
            3.作用：用于控制变量的作用范围，变量的作用范围越小越好
             */
            System.out.println("我是一个局部代码块");
            int i = 100;
            System.out.println(i);
        }
        //System.out.println(i);//局部代码快中的变量i只能在代码块里使用
    }
}

this

this的用法：
1.当成员变量与局部变量同名时，使用this指定成员变量
2.使用this在构造方法的第一行调用构造方法的功能
this（）；–调用的是本类的无参构造
this（参数）；–调用的是本类对应参数的构造方法

package cn.tedu.oop;
/*本类用于this测试*/
public class TestThis1 {
    public static void main(String[] args) {
        //4.创建对象并调用方法
        Cat c = new Cat();
        c.eat();
    }
}
//1.创建小猫类
class Cat{
    //5.创建一个成员变量
    int count = 666;
    int sum = 100;
    //2.创建方法
    public void eat(){
        //3.创建局部变量
        int sum = 10;
        System.out.println(sum);
        /*当成员变量余额局部变量同名时，可以使用this指定本类的成员变量
        如果不使用this指定，打印的就是近处的这个局部变量，就近原则*/
        System.out.println(this.sum);
        System.out.println(count);
    }
}

package cn.tedu.oop;
/*本类用于测试this的用法2*/
public class TestThis2 {
    public static void main(String[] args) {
        Dog d1 = new Dog();
        //Dog d2 = new Dog("旺财");

    }
}
class Dog{
    public Dog(){
        /*在无参构造中调用含参构造的功能
        * 注意：调用是单向的，不能来回双向调用，否则会是循环*/
        this("小旺旺");
        System.out.println("无参构造");
    }
    public Dog(String s){
        /*在含参构造中调用无参构造
        * 规定：this关键字必须在构造函数的第1行*/
        //this();
        System.out.println("含参构造"+s);
    }
}

package cn.tedu.oop;
/*本类用于oop综合练习*/
public class TestTeacher {
    public static void main(String[] args) {
        //5.1
        Teacher t1 = new Teacher();
        //5.2
        Teacher t2 = new Teacher(10);
        //5.3
        Teacher t3 = new Teacher("paopao",'女',20,99999.99);
        System.out.println(t3.getName()+t3.getAge()+t3.getGender()+t3.getSalary());

        //6.1
        t1.setName("孙悟空");
        t1.setAge(11);
        t1.setGender('男');
        t1.setSalary(100);
        System.out.println(t1.getGender()+t1.getName()+t1.getAge()+t1.getSalary());
    }
}
class Teacher{
    private String name;
    private char gender;//性别
    private int age;
    private double salary;

    public Teacher(){
        System.out.println("无参构造");
    }
    public Teacher(int n){
        System.out.println("含参构造"+n);
    }
    public Teacher(String name, char gender, int age, double salary) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.salary = salary;
        System.out.println("全参构造");
    }
    public String ready(){
        System.out.println("正在备课中·····");
        return "产出课程+1";
    }
    public void teach(String subject){
        System.out.println("正在授课:"+subject);
    }

    public String getName() {
        return name;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char 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;
    }
}

super

super的用法：
1.当父类的成员变量与子类的成员变量同名时，使用super指定父亲的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super（）；–调用的是父类的无参构造
super（参数）；–调用的是父类对应参数的构造方法