day12_oop

今日内容

零、 复习昨日
一、作业
二、封装
三、继承
四、重写
五、this和super
六、访问修饰符

零、 复习昨日

局部变量和成员变量什么区别
构造方法什么作用
有参无参构造什么区别
创建对象的过程
Car car = new Car();
构造方法执行,堆中开辟空间
属性初始化
再执行构造方法内的代码
将对象地址赋值给前面的引用
this是什么

一、作业

成年人类,孩子类,玩具类
成年人有孩子,孩子有玩具

见代码…

总结: 类中定义另外一个类类型的属性,例如

public class Adult{
  Child child;
}

那么该属性(child)只能由该类类型的对象赋值

---

老师类,学生类
老师带了很多学生
把学生存倒数组中 Student[] stus = new Student[6];

二、封装

面向对象编程有3大特点: 封装,继承,多态

封装: 就像快递打包封装,装起来… 为什么? 东西太多封装起来方便使用,把一些东西藏起来不用让别人看见

代码封装: 也是将一些实现的代码隐藏,对外提供一个可以访问的方式

类的封装具体如何实现封装:

1. 属性私有
2. 提供对外可以访问的方法来对属性进行设置和取值

作用:

• 将代码封装到方法,方便使用,复用
• 将代码功能增强

总结:

• 属性私有,private
• 对属性提供set,get方法
• set方法一定是有参无返回值
• get方法一定是无参有返回值
• 且set,get方法固定命名,一定是setXxx getXxx,即后面一定是属性首字母大写

package com.qf.oop;

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

    /**
     * public 访问修饰符,公共的意思
     * private 访问修饰符,私有的意思
     *  私有即只能自己用,自己即当前类中使用
     */
    private int age;// 寿命
    String name;// 昵称

    // 给属性赋值
    public void setAge(int age) {
        if (age < 0 || age > 20) {
            System.out.println("年龄设置有误" );
        } else {
            this.age = age;
        }
    }

    // 获取属性值
    public int getAge(){
        return age;
    }

    void eat(){
        System.out.println(age+"狗吃骨头" );
    }
}

练习: Cat类的封装

package com.qf.oop;
/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc 标准的类的封装
 */
public class Cat {
    // 属性私有
    private String name;
    private int age;
    private double price;
    // set方法
    public void setName(String name) {
        this.name = name;
    }  
    // get方法
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }

    public int getAge() {
        return age;
    }
    public void setPrice(double price) {
        this.price = price;
    }

    public double getPrice() {
        return price;
    }
    void fishing(){
        System.out.println("捕鱼" );
    }
}

        Cat cat = new Cat( );
        // 利用set方法赋值
        cat.setAge(1);
        cat.setName("小花");
        cat.setPrice(1500);
        // 调用get方法获得属性值
        System.out.println(cat.getAge() );
        System.out.println(cat.getPrice() );

三、继承(extends)[重点]

3.1 继承

继承: 子类继承父类,子类就可以使用父类中的东西(属性和方法)

为什么要继承?

• 有些类中定义的属性,方法有重复 --> 继承就可以减少重复
• 为多态做准备

如何写?

public class A extends B{
    
}

以上代码就是继承,A类继承B类,A类是子类,B是父类

---

继承有is a的关系, 子类为什么可以继承父类,因为子类是父类类型

---

如何定义父类? 将一些类中共同有的属性和方法向上抽取形成父类.即父类更抽象,子类更具体

// 父类
public class Animal {

    String name;
    int age;

    void eat(){
        System.out.println("吃东西" );
    }
}

// 子类
public class Dog extends Animal{
}
public class Cat extends Animal{
}

// 测试
public class TestExtends {
    public static void main(String[] args) {
        Cat cat = new Cat( );
		// 创建子类对象
        Dog dog = new Dog( );
        // 使用父类中的属性
        System.out.println(dog.age );
        // 调用父类中的方法
        dog.eat();
    }
}

3.2 继承的特点

• 子类继承父类,子类对象可以使用父类中非私有的属性和方法
• Java支持继承,但是只能单继承

3.3 继承中的属性

父类中有的属性,子类中没有的属性: 子类可以直接用父类中

父类中没有的属性,子类中有的属性: 子类用自己的

父类中有的属性,子类中有与之同名的属性: 子类用自己的.

3.4 继承中的方法

父类中有的方法,子类中没有的方法: 子类可以直接用父类中

父类中没有的方法,子类中有的方法: 子类用自己的

父类中有的方法,子类中有与之同名的方法: 子类用自己的. --> 重写

3.5 继承中的构造方法

子类对象不能调用父类的构造方法

在调用子类构造方法创建子类对象时 (子父类对象创建过程)

• 会先调用父类构造方法
• 初始化父类中的属性
• 执行父类的构造方法中的内容
• 再初始化子类的属性
• 再执行子类构造方法中的内容
• 将引用赋值给对象

为什么在调用子类构造方法创建子类对象时先调用父类构造方法呢?

是因为每个构造方法的第一行都隐藏一个super()调用父类无参构造方法

四、重写

重写有一定的必要性,为什么需要重写? 父类有方法,但是这个方法子类不适用

ps: 另外重写也是多态的前提

重写(Override),也叫覆写或者覆盖,

• 发生在子父类之间方法的关系
• 要求子父类的方法访问修饰符,返回值类型,方法名,参数列表完全一致,方法体不一样
• 父类私有方法不能重写

public class Animal {
    String name;
    int age;
    public Animal(){
        System.out.println("Animal()" );
    }
    // 父类中的eat方法
    public void eat(){
        System.out.println("吃东西" );
    }
}
public class Dog extends Animal {
    void watchHome(){
        System.out.println("狗看家" );
    }
    @Override // 子类重写父类方法
    public void eat() {
        System.out.println("狗吃骨头" );
    }
}

练习: 形状类…

五、super & this

super 代表当前对象的父类对象

默认的: 在每个构造方法中第一行隐式存在有super() 调用父类无参构造

也可以使用super(实参)来主动调用父类的有参构造

super代表父类对象,也就可以调用父类的属性和方法

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

六、访问修饰符

访问修饰符

• 访问 access, 能不能调用
• 修饰符, 就是一些符号
  • public , protected,默认/缺省/不写,private
• 访问修饰符又叫访问控制符或者访问权限符,即通过以上这些修饰可以改变访问的权限

	当前类内	同包下其他类	其他包子类内	其他包其他类
public	√	√	√	√
protected	√	√	子类对象可以访问	×
缺省package	√	√	×	×
private	√	×	×	×

访问权限修饰符: public > protected > package > private

自己尝试: 方法重写时,子类方法的访问修饰符权限 >= 父类访问权限

总结

1 上午作业,类中有其他类属性这种题,是一套类型
2 封装,很重要,写项目时每个实体类是要封装,但是很简单,主需要属性私有,提供setget方法
3 继承和重写很重要, 要掌握具体写法  (也是为多态做准备) 把形状练习题
4 this 和 super 会用,知道语法
5 熟悉