今日内容

零、复习昨日
一、作业
二、局部变量&成员变量
三、this关键字
四、构造方法
五、重载

零、复习昨日

晨考

public class Phone {
    // 成员属性/成员变量
    // 数据类型 变量名;
    double price;
    String brand;
    
    // 成员方法
    public void call(String num) {
        System.out.println("给xxx打电话");
    }
}

public static void main(String[] args) {
    // 创建对象
    // 类名 对象名 = new 类名();
    Phone p = new Phone();
    p.price = 100.0;
}

对象创建时,内存过程

一旦执行new Phone();
会在堆中开辟空间
属性初始化,方法初始化
对象分配地址,地址赋值给对象引用

一、作业

略

二、成员变量&局部变量

以学生类为例演示: 属性年龄和姓名方法学习和睡觉

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Student {

    /**
     * 成员变量
     * 1 类中方法外
     * 2 声明完,可以在方法内直接使用
     * 3 在创建对象时成员变量被初始化
     * 4 生命周期: 创建对象时出现,当对象失去引用后被GC机制回收
     * 5 成员变量在堆
     */
    String name;
    int age;

    /**
     * 局部变量
     * 1 方法签名中,和方法体内
     * 2 声明完局部变量,必须手动赋初始值
     * 3 局部变量是方法进栈时完成初始化
     * 4 局部变量生命周期: 随着方法进栈而出现,方法执行完弹栈而消失
     * 5 局部变量在栈
     */
    public void study(int hours) {
        System.out.println(name );// 使用成员变量
        // 定义局部变量
        int a = 1;
        System.out.println(a ); // 使用局部变量
        System.out.println("学生学习,学了"+hours+"小时" );
    }

    public void sleep() {
        System.out.println("学生睡觉" );
    }
}

不同点	成员变量	局部变量
位置不一样
使用前初始值不一样
初始化时机
生命周期
内存位置

为什么成员变量使用前,没见到赋值动作,还能使用呢?

答案: 任何变量使用前都要有初始值
在new 对象时,堆内存空间会给属性初始化
此时属性已经被赋值
等到对象调用方法执行时,成员变量已经被赋值了

总结:(掌握的程度)

分清楚哪是成员变量哪是局部变量
搞清楚变量初始值使用上的不同
其余: 内存位置,初始值时机,生命周期等熟悉即可

三、this关键字

this

单词是这个
代表当前对象
代表的是调用这个方法的当前对象
即谁调用这个方法,this就是谁

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc this关键词
 */
public class Phone {

    String color;
    double price;

    public void call(String num) {
        /**
         * 当成员变量和局部变量重名时:
         * 1 就近原则,自己方法内有就用自己的
         * 2 即如果不重名,那就只能使用成员变量
         * ----------------------------------
         * this 是这个的意思,即这个当前对象
         */
        String color = "黑色";// 局部变量
        System.out.println("this --> "+this );
        System.out.println("这个手机什么颜色? " + color );
        /**
         * 当前成员变量和局部变量重名时,但是还要使用成员变量
         * 此时就必须使用this来说明,调用的就是对象的成员变量
         */
        System.out.println("这个手机什么颜色? " + this.color );
        // this就是当前对象,可以调用属性和方法
        this.play();
        System.out.println("给"+num+"打电话" );
    }

    public void play(){
    }
}

总结:

this就是当前对象
this可以调用对象的属性和方法
什么时候用到this呢? 只有当局部变量和成名变量重名时使用!!!
即使用this来区别一下

四、构造方法[重要]

4.1 构造方法/构造函数/构造器/constructor

是什么? 是个方法,但是有点特殊…(后续解密)

干什么的? 构造方法: 用来创建对象的方法,即构造是构造出一个对象

怎么干的? 类名对象名 = new 类名(); --> 类名对象名 = new 构造方法();

在哪? 每个类中都有,默认是隐藏的,也可以显式写出

构造方法语法:

public 类名([参数]){}

构造方法的特点

构造方法是方法,但是没有返回值类型,也没有void
方法名也很特殊,当前类的类名,首字母大写的
构造方法参数列表可以添加参数的
只能通过new 来调用

4.2 对象创建过程

构造方法用来创建对象.那么调用构造方法创建对象的过程是怎么样?

Car car = new Car();

调用Car(),即调用Car类的无参构造方法
内存中开辟空间,属性初始化
再执行构造方法内的代码
地址值赋值给引用

4.3 有参构造

为什么要有有参构造?

因为无参构造创建出的对象属性都是默认值(null,0,0.0)这些,使用时还需再单独赋值,比较麻烦. 所以才有了有参构造,可以创建出对象,属性就有指定值;

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 构造方法
 */
public class Car {

    String brand;
    double price;

    // 无参构造
    public Car(){
        System.out.println("Car()执行了" );
    }
    
    // 有参数的构造方法
    public Car(String brand,double price) {
        this.brand = brand;// 局部变量给成员变量赋值
        this.price = price;
    }

    public void run(){
        System.out.println("跑到" );
    }
}

public static void main(String[] args){
    // 类名 对象名 = new 构造方法();
        Car car = new Car();
        System.out.println(car.brand);
        System.out.println(car.price);
        /**
         * 无参构造创建出的对象中属性值: 默认值
         * 使用时还需再赋值?
         * 有没有创建出对象就有指定的属性值? --> 有参构造
         */

        Car  car2 = new Car("东风",280000);
        System.out.println(car2.brand );
        System.out.println(car2.price );

        Car  car3 = new Car("解放",180000);
        System.out.println(car3.brand );
        System.out.println(car3.price );
        /**
         * 有参构造创建出的对象属性都是指定值
         * 作用是什么? 为了方便创建对象
         */
}

总结: 无论是有参构造还是无参构造,都是用来创建对象. 用哪个创建对象都可以,只不过无参创建出的对象属性都是默认值,有参构造创建出的对象属性都是指定值

4.4 语法总结

构造方法写在类中
没有返回值类型,也没有void
方法名一定是类名
可以有参数,可以无参数
构造方法只能通过new来调用
每个类都默认隐藏一个无参构造
但是类中显式写出任何一种构造方法,隐式不再提供
因此我们建议,有参无参构造要同时给出

学完构造方法,你要会什么?
1 理解什么是构造方法,用来干什么,怎么写的,写在哪里
2 对比有参无参构造的区别
3 [重要] 熟练的使用有参无参构造创建对象
4 [熟知] 有参无参创建出的对象有什么不一样

五、重载

重载(Overload)

重载是指一个类中多个方法之间的关系叫重载
具体点: 这些方法方法名一样,参数列表不一样的关系叫做重载
参数列表不一样
参数的个数,类型,顺序任何不一样都是不一样

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Dog {
    public String name;
    public int age;

    // 这些构造方法是重载关系
    public Dog() {
    }
    public Dog(String name) {
        this.name = name;
    }

    public Dog(int age) {
        this.age = age;
    }

    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public Dog(int age,String name) {
        this.name = name;
        this.age = age;
    }
}

        new Dog();
        new Dog(2,"");
        new Dog(2);
       /**
         * 这些方法都是重载,主要目的就是方便调用.
         * 根据传入的参数类型,来确定执行哪个方法
         */
        System.out.println( );
        System.out.println(1);
        System.out.println(1.1);
        System.out.println("zzzz");

六、复习

由类创建对象: Car car = new Car(); Dog dog = new Dog(); Tiger tiger = new Tiger();

创建出的对象,对象内部有什么

属性
方法

使用对象,使用对象的什么东西?

使用属性
- 取值数据类型变量名 = 对象.属性;
- 赋值对象.属性 = 值;
使用方法
- 对象.方法();

七、作业

工人类

package com.qf.oop;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 引用数据类型: 数组,类,接口
 */
public class Worker {
    String name;// 姓名
    int age;// 年龄
    double salary;// 薪水
    Address addr;

    // 无参构造
    public Worker(){}

    // 有参构造
    public Worker(String name,int age,double salary) {
        this.salary = salary;
        this.age = age;
        this.name = name;
    }

    // 工作的方法
    public void work() {
        System.out.println("工作" );
    }

    public void work(int hours) {
        System.out.println("工作"+hours+"小时" );
    }

    public static void main(String[] args) {
        Worker w1 = new Worker( );
        w1.salary = 1000;
        w1.name = "张三";
        w1.age = 19;

        System.out.println(w1.salary );
        System.out.println(w1.name );
        System.out.println(w1.age );

        w1.work();
        w1.work(10);

        Worker w2 = new Worker("李四", 20, 2000);
        System.out.println(w2.salary );
        System.out.println(w2.name );
        System.out.println(w2.age );
        w2.work();
        w2.work(8);
        // --------------------
        Worker w3 = new Worker();
        w3.name = "王五";
        w3.age = 25;
        w3.salary = 2500.1;

        // 因为addr的数据类型是Address类型
        w3.addr = new Address();
        // System.out.println(w3.addr );
        w3.addr.zipCode = "100086";
        w3.addr.address = "郑州航海路60号";

        System.out.println(w3.name );
        System.out.println(w3.age );
        System.out.println(w3.salary );
        System.out.println(w3.addr.address );
        System.out.println(w3.addr.zipCode );
    }
}

地址类

public class Address {
    String address;// 地址
    String zipCode;// 邮编

    public Address(){}
    public Address(String address,String zipCode){
        this.address = address;
        this.zipCode = zipCode;
    }
}

附录

student 学生
sleep 睡觉
eat 吃
study 学习
method signature 方法签名
方法签名主要是方法的定义,即不包含方法体的那一部分
public void study(int hours)
might 可能
salary 薪水
NullPointerException 空指针异常,空指针就是空引用就是空

public class Address {
    String address;// 地址
    String zipCode;// 邮编

    public Address(){}
    public Address(String address,String zipCode){
        this.address = address;
        this.zipCode = zipCode;
    }
}

[外链图片转存中…(img-vJnyYmni-1681206567135)]

附录

student 学生
sleep 睡觉
eat 吃
study 学习
method signature 方法签名
方法签名主要是方法的定义,即不包含方法体的那一部分
public void study(int hours)
might 可能
salary 薪水
NullPointerException 空指针异常,空指针就是空引用就是空