day10_面向对象_抽象_接口

今日内容

1.作业
2.final
3.抽象
4.接口

零、复习

按从大到小的顺序写出访问修饰符

• public > protected > package (default)> private
  static修饰属性和方法的特点
• 在内存的特点: 在方法区(不是在堆,也不是在栈)
• 初始化的特点: 随类(字节码文件)加载到内存已经初始化
• 使用的特点: 直接通过类名调用,被该类所有对象共享

多态出现的前提条件

• 继承
• 重写方法
• 向上转型(父类对象被子类对象赋值)

多态使用的场景

• 方法的参数列表是父类类型,传参数传入子类对象
• 方法的返回值类型是父类类型,真正return返回的是子类对象
• 数组数据类型是父类类型,真正存储的是子类对象

一、作业

详见 pdf6_t22_t25

二、final

final 意思: 最终的

是修饰符,修饰类,属性(变量),方法

final修饰类: 类不能被继承(不能有子类)

final修饰属性: 属性变成常量,不可更改

final修饰方法: 方法不能被重写

三、抽象类

3.1 介绍

抽象: 不具体的,看不太明白,跟正常有区别的…

抽象类: 不具体的类,跟正常有区别的类

---

语法: 使用abstract修饰类和方法

• abstract修饰方法,方法就是抽象方法
• 抽象方法不能有方法体
• 抽象方法必须放在抽象类
• 抽象类中可以写正常方法的
• 抽象类中可以写构造方法,但不能通过new直接创建对象,而是给子类super()
• 抽象类存在意义,被子类继承
• 子类继承抽象类要么重写抽象方法,要么自己也得定义成抽象类

3.2 演示

// 父类

 /* @desc 抽象类
 */
public abstract class Animal {
    // 属性不能被abstract修饰
    int age;

    /**
     * - abstract修饰方法,方法就是抽象方法
     * - 抽象方法不能有方法体
     * - 抽象方法必须放在抽象类
     * - 抽象类中可以写正常方法的
     * - 抽象类中可以写构造方法,但不能通过new直接创建对象,而是给子类super()
     * - 抽象类存在意义,被子类继承
     */
    public abstract void eat();
    // 可以有正常方法
    public void play(){
        System.out.println("动物玩耍" );
    }

    // 可以有构造方法
    public Animal(){
        System.out.println("Animal()" );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 子类

 /* - 子类继承抽象类要么重写抽象方法,要么自己也得定义成抽象类
 */
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头" );
    }
  // 非抽象方法可以重写,也可以不重写,即不强制
}
1
2
3
4
5
6
7
8
9

// 测试

public class TestAbstract {
    public static void main(String[] args) {
        // 抽象类不能直接new来创建对象
        // Animal a = new Animal();

        // 创建子类对象(内存中:调用父类构造方法创建父类对象)
        // 这也解释了为什么抽象类中有构造方法,是为了给子类用的,不是给自己创建对象的
        Dog dog = new Dog( );

        // 抽象类虽然不能直接创建对象,但是
        // 它可以当父类引用,指向子类对象,其实就得多态的应用
        Animal animal = new Dog();
        animal.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.3 一些理解

以前的方法也能用,为什么现在需要将方法变成抽象方法?

• 通过一些练习(动物系列类吃,玩耍,形状系列类求周长面积,员工系列发工资)发现,父类的方法虽然有,但是子类不适用,都需要再重写,以适应自己

• 所以,干脆父类只是定义方法,但不实现方法,即抽象

继承抽象类后,为什么必须实现(重写)抽象方法?

• 因为父类抽象方法没有方法体,无法执行
• 只有子类重写了才能执行功能

抽象类存在意义是什么?有什么用呢?

• 确实以前没有抽象类抽象方法也可以写代码,实现功能,甚至是多态功能
• 其实,设置抽象后,就会多了一层限制功能
• 所谓"限制",即某个类要想继承抽象类,就必须重写抽象方法,而且抽象类不能创建对象,只能用于当做父类引用,指向子类对象
• 这就是多态的三个前提
• 也就是说,抽象就是为了多态**,是之前多态的是一种升级,多了一个限制而已**
• 除此之外,与之前一模一样

---

抽象类是用来抽象差异性、具体共同点的。

也就是将差异性方法抽象化，提供给子类用于重写。共同的方法具体化，所有子类继承使用。

---

把子类不一样的方法抽象成抽象方法,每个子类都重写
把子类都一样的方法提取到父类,每个子类直接用,不用重写

3.4 练习

改造之前动物类为抽象类

改造形状类为抽象类

改造员工类为抽象类

四、接口

生活中接口: USB接口,typec,水管

接口是一种规范,一种约束,满足这种约束 两个 物体就可以对接

---

在程序中接口,其实就是必须抽象类更抽象一种java文件

4.1 演示语法

接口的特性

1. 接口不是类,没有class修饰,而是interface

2. 接口中没有属性(变量)
     * 所有属性都是常量,默认被final修饰
     * 且也被static修饰,即接口中都是静态常量
     * 且 被public修饰
     * ------------------------------------
     * 接口中的属性默认只能被public static final修饰
     * 一般情况下,前面可省了
3. 接口中没有正常方法,所有方法都是抽象的不能有方法体
     * 因为接口中方法都默认被public abstract修饰
     *
     * ps: jdk1.8有新特性可以有方法体     

 4. 接口没有构造方法,不能创建对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 /* 1. 接口不是类,没有class修饰,而是interface
 */
public interface USB {
    /**
     * 2. 接口中没有属性(变量)
     * 所有属性都是常量,默认被final修饰
     * 且也被static修饰,即接口中都是静态常量
     * 且 被public修饰
     * ------------------------------------
     * 接口中的属性默认只能被public static final修饰
     * 一般情况下,前面可省了
     */
    public static final double length = 1.0;
    double width = 1.0;

    /**
     * 3. 接口中没有正常方法,所有方法都是抽象的不能有方法体
     * 因为接口中方法都默认被public abstract修饰
     *
     * ps: jdk1.8有新特性可以有方法体
     */
    public abstract void tongdian();

    /**
     * 4. 接口没有构造方法,不能创建对象
     */
    //public USB(){}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

接口存在主要用处是为了子类 实现 的

* 1 类实现接口,要么实现全部抽象方法,要么自己变成抽象类
* 2 类不允许多继承,但是允许多实现,即同时实现多个接口(同时遵循多种规范)
* 3 类 继承的同时还可以实现(先继承后实现)
1
2
3

 /* @desc 类实现接口
 * 实现单词 implement
 * 1 类实现接口,要么实现全部抽象方法,要么自己变成抽象类
 * 2 类不允许多继承,但是允许多实现,即同时实现多个接口(同时遵循多种规范)
 * 3 类 继承的同时还可以实现(先继承后实现)
 */
public class UDisk extends Waishe implements USB,Disk{
    @Override
    public void tongdian() {
        System.out.println("U盘通电" );
    }

    @Override
    public void read() {
        System.out.println("U盘读取数据" );
    }

    @Override
    public void write() {
        System.out.println("U盘写入数据" );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.2 作用

接口不能创建对象,主要用来当做父引用指向子实现类对象

 		// 接口当做引用,执行子实现类对象
        USB usb = new UDisk();
        // 其实完成多态的前提的第三步
1
2
3

即,接口主要作用,就是哪里可以用多态哪里可以用接口

4.3 与抽象的区别

4.4 一些经验

对于以后写代码,该怎么设计?

• 很多类有公共的属性,方法的抽取到父类来继承
• 有些类中的方法虽然被抽取到父类中,但是子类又不合适还需要再重写,那干脆就把类和方法定义成抽象类
• 将一些功能性的行为定义成接口,让想拥有这些功能的类去实现即可

作业

复习总结:仿照下面思维导图,总结一下面向对象的知识点
https://www.processon.com/view/link/63511007f346fb0728dc0109 访问密码：2313

写pdf5 员工题(封装继承)  pdf6 员工题(多态) pdf7 写前10个(针对static,final,abstract概念理解)

pdf8 t14,t15

OOP综合练习.pdf(学会设计类)
1
2
3
4
5
6
7
8