day08_面向对象_封装_继承_this_super_访问修饰符

今日内容

1.作业
2.封装
3.继承
4.this和super
5.访问修饰符

零、复习

成员变量和局部变量(画表格)

this的作用

• this是当前对象,当前方法的调用者
• this可以调用属性和方法
• this.属性, this.方法名(),this()

构造方法的作用和语法特征

• 作用: 创建对象,属性初始化
• 特征: 没有返回值,没有void,方法名是类名

有参无参构造的区别

• 无参创建出的对象属性是默认值
• 有参创建出的对象属性是指定值

重载的语法要求

• 在同一类中,方法名,参数列表不一样

一、作业

1.1 关于引用类型的题目

pdf5，t4,5,9,14 都是

解题思路
* 1 方法执行进栈,执行完弹栈
* 2 凡是new都会在堆中创建对象
* 3 基本数据类型,赋值是直接将数据复制一份传递
*   引用数据类型(数组,类,接口),赋值是将地址值赋值一份传递
* 4 成员变量在堆中(在堆中的对象中)
*   局部变量在栈中(在栈中的方法中)
----------------------
多画内存图，多读代码

1.2 类中定义类属性

有工人(Worker)类,有地址(Address)类

工人类中定义属性addr,该属性是Address类型的
工人类中定义属性age,该属性是int类型

public class Worker {

    /**
     * 属性,就是变量
     * 数据类型 变量名;
     * 基本数据类型/引用数据类型
     */
    String name;
    int age;
    double salary;// 薪水
    Address addr; // Address属性
    //....
}
    
public class TestWorker {

    public static void main(String[] args) {
        // 创建一个Worker 对象，其姓名为"zhangsan"，年龄为25，工资为2500，
        // 家庭住址为“北京市海淀区清华园1 号”，邮政编码为100084。

        Worker worker = new Worker( );
        System.out.println(worker.age);// 0
        System.out.println(worker.salary);// 0.0
        System.out.println(worker.name);// null
        System.out.println(worker.addr);// null

        worker.age = 25;
        worker.salary =2500;
        worker.name = "张三";
        /**
         * NullPointerException
         * 空指针异常
         * 指针就是引用
         * 空指针即空引用,空对象
         * ------------------
         * 凡是空指针异常,就是在拿着一个空对象在调用属性或者方法
         */
        // worker.addr.address = "航海路60号";
        worker.addr = new Address(  );
        worker.addr.address = "航海路60号";
        worker.addr.zipCode = "450000";

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

}

练习题

• 部门类(Dept)

  • 属性 部门编号,部门名称

• 员工类(Emp)

  • 属性 姓名,工号,职位

• 部门类中设置属性emp,属性为Emp

• 创建部门类对象,给每个属性赋值

二、封装

在这之前,学习的

• 类,属性,方法
• 创建对象
• 内存关系
• 构造方法
• 引用类型的理解

都是面向对象的基础知识

---

面向对象的核心

• 封装
• 继承
• 多态

2.1 封装

封装: 就是将代码封装起来,方便使用

比如: 快递包裹,手机,电脑

作用: 将一些实现的动作隐藏起来,只需要关心如何使用

---

封装可以分为

• 方法的封装
• 属性的封装
• 类的封装(多个类,组成一个庞大系统)

2.2 属性的封装

为什么要封装属性? 因为现在是直接通过对象操作属性,这样不安全

怎么封装?

• 属性私有化,设置private修饰符
• 设计方法
  • setXxx 给属性赋值
  • getXxx 取出属性值

---

重要: 以后写项目,工作中属性封装都是固定格式(属性私有,setget方法)

• 给属性赋值的方法名 必须叫set,后面必须跟属性名,例如 setAge
• 获得属性值的方法名,必须叫get,后面必须跟属性名,例如 getAge

 /* @desc  属性封装演示
 */
public class Phone {

    /**
     * 属性就是变量,
     * 特殊的是前面可以使用修饰符,例如public
     * 现在属性要封装,就要将其私有,就是写private
     */
    private String brand;// 品牌
    private double price;

    /**
     * 设计方法对属性封装,封装成方法
     * 有了方法后就可以对属性做一些操作
     */
    // setXxx给属性赋值
    public void setPrice(double price) {
        if (price >= 0) {
            this.price = price;
        } else {
            System.out.println("价格有误!" );
        }
    }

    // getXxx用于取出属性值
    public double getPrice(){
        return price;
    }

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

    public String getBrand(){
        return brand;
    }
}

// 测试

public class TestPhone {
    public static void main(String[] args) {
        // 创建对象
        Phone phone = new Phone( );
        // 属性赋值
        // phone.price = -3999;
        // 属性私有了,不能再直接通过对象调用

        // 调用set方法给属性赋值
        phone.setPrice(3999);
        // 调用get方法获得属性值
        double price = phone.getPrice( );
        System.out.println(price );
    }
}

三、继承【重点】

3.1 继承

什么是继承? 子级(子类) 从父级(父类) 获得它们的东西(属性,方法)

为什么需要继承?

• 将多个类重复代码向上抽取到父类,子类复用
• 继承是多态的前提

代码写继承? class A extends B ,就是继承,读作A类继承B类,A是子类,B是父类

// 父类
public class Animal {
    int age;
    String  name;

    public void eat(){
        System.out.println("吃 " );
    }
}
// 子类Dog继承Animal
 /* @desc 狗类继承Animal动物类
 * 狗类是子类
 * 动物是父类
 */
public class Dog extends Animal{// 继承
}
// 测试
public class TestExtends {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();// 调用父类中的方法
        System.out.println(dog.age );// 调用的是父类中的属性
    }
}

3.2 继承特点

java中类只能单继承,即一个类只能继承一个类,不能出现两个父类

支持层次继承(多级继承)

子类继承父类**,可以使用父类非私有修饰的属性和方法**

3.3 继承中的属性

• 子类继承父类只能使用父类非私有属性
• 特殊的,某一个属性,父类中 子类中都有,子类默认使用自己的属性

3.4 继承中的方法

• 子类继承父类,只能使用父类中非私有的方法
• 特殊的,某一个方法,父类中 子类中都有,子类默认使用自己的方法
  • 这就是方法的重写(Override)

3.5 方法重写

方法重写又叫方法覆盖,方法覆写

什么是重写? 在继承中,子类重写了父类方法(子类和父类方法签名一样,但是方法体不一样)

为什么需要重写?

• 继承的目的是为了使用父类的属性和方法
• 但是有些时候子类在使用父类方法时,不适用于自己,所以需要重写
• 这也是多态前提

如何写?

• 子类继承父类
• 子类中写一个与父类方法
  • 访问修饰符一样
  • 返回值类型一样
  • 方法名一样
  • 参数列表一样
  • 方法体不一样
• 的方法就是重写

3.6 继承中的构造方法

在创建子类时会先创建父类对象

调用子类构造方法创建子类对象时,会 调用父类构造方法创建父类对象

• 机制: 每个类的每个构造方法第一行都隐藏了一个super()在调用父类无参构造

---

创建对象的过程

• 调用子类构造方法创建对象
• 先父类属性初始化
• 再执行父类构造方法内代码
• 后再子类属性初始化
• 最后再子类构造方法内代码执行

---

总结:

• 整体是有父类先执行父类,后子类
• 具体到类中,先初始化属性再执行构造方法

四、this和super

	this	super
代表	代表当前类对象	代表父类对象
调用属性	this.属性(子类属性,子类没有也会调用父类属性)	super.属性(父类属性)
调用方法	this.方法()(子类方法,子类没有也会调用父类方法)	super.方法()(父类方法)
构造方法	this() 调用自己无参构造 this(参数) 调用自己有参构造	super() 调用父类无参构造 super(参数) 调用父类有参构造

ps: 调用构造方法的语句必须放在构造方法内的第一行

五、单词

private 私有
extends 继承
super 父
sub 子

六、总结

封装： 
	属性私有
	提供setget方法
	固定写法，可以生产
继承：
	注意继承中特性（属性，方法，构造）
重写的知识（知道语法）
this和super知识（知道怎么用）

作业

不用重复代码，应该按照笔记中写的特性，自己建类实现这些特性
重写和重载总结表格
写两道关于继承的题（很重要）pdf6-t19，t24