2017.9.18学习小结 - 抽象类与接口2

回顾

一、抽象类
1.抽象类的基本概念
抽象类定义规则

学习小结

抽象类的特征：

①抽象类中可以有构造方法

抽象类的构造方法必须在子类中被调用，并且先默认调用父类构造方法，再调用子类的构造方法，这个抽象方法无法直接被外部实例化对象直接调用。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月18日 下午9:45:45
 * @Description TODO 抽象类中构造方法的定义使用
 */
public class P325_13_2 {
    public static void main(String[] args) {
        Student12 s = new Student12("张三", 20, "学生"); // 创建Student类对象s
        System.out.println(s.talk()); // 调用被覆写的方法
    }
}

abstract class Person23 { // 定义一个抽象类Person
    String name;
    int age;
    String occupation;

    public Person23(String name, int age, String occupation) { // 定义构造函数
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }

    public abstract String talk(); // 声明一个抽象方法talk()
}

class Student12 extends Person23 { // 声明抽象类的子类

    public Student12(String name, int age, String occupation) {
        // 在这里必须强调用抽象类中的构造方法
        super(name, age, occupation);
    }

    public String talk() { // 覆写talk()方法
        return "学生--》姓名：" + this.name + "，年龄：" + this.age + "，职业：" + this.occupation + "！";
    }

}

运行结果：

运行结果1

②抽象类不能使用final定义

③在外部抽象类上无法使用static声明，但是内部抽象类却可以使用static定义，使用static定义的内部抽象类就是一个外部类。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月18日 下午10:04:22
 * @Description TODO 验证static定义的内部抽象类
 */
public class P326_13_3 {
    public static void main(String[] args) {
        Book3.CD cd = new JavaCD(); // 实例化对象
        cd.get();
    }
}

abstract class Book3 {
    public abstract void print(); // 抽象方法

    static abstract class CD { // 静态内部抽象类
        public abstract void get(); // 抽象方法
    }
}

class JavaCD extends Book3.CD {
    public void get() {
        System.out.println("java 学习");
    }
}

运行结果：

运行结果2

④抽象类之中可以没有抽象方法，但即便没有抽象方法的抽象类也不能够直接在外部通过关键字new实例化。

2、抽象类应用——模板设计模式

不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现，这就是模板方法模式。

三类事物实现如下功能：
机器人：吃饭、工作；
美女：吃饭、跑步、睡觉；
帅哥：吃饭、工作、跑步、睡觉。

package com.Javastudy2;

/**
 * @author Y.W.
 * @date 2017年9月18日 下午10:17:52
 * @Description TODO 模板设计模式
 */
public class P327_13_4 {
    public static void main(String[] args) {
        Action actA = new Robot(); // 机器人行为
        actA.command(Action.EAT);
        actA.command(Action.WORK);
        Action actB = new Woman(); // 美女的行为
        actB.command(Action.EAT + Action.SLEEP + Action.RUN);
        Action actC = new Man(); // 帅哥的行为
        actC.command(Action.EAT + Action.SLEEP + Action.RUN + Action.WORK);
    }
}

abstract class Action { // 表示操作行为
    public static final int EAT = 1;
    public static final int WORK = 2;
    public static final int SLEEP = 5;
    public static final int RUN = 10;

    public abstract void eat(); // 声明一抽象类

    public abstract void sleep(); // 声明一抽象类

    public abstract void run(); // 声明一抽象类

    public abstract void work(); // 声明一抽象类

    public void command(int ch) { // 具体的命令
        switch (ch) {
        case EAT:
            this.eat();
            break;
        case SLEEP:
            this.sleep();
            break;
        case RUN:
            this.run();
            break;
        case WORK:
            this.work();
            break;
        case EAT + WORK:
            this.eat();
            this.work();
            break;
        case EAT + SLEEP + RUN:
            this.eat();
            this.sleep();
            this.run();
            break;
        case EAT + SLEEP + RUN + WORK:
            this.eat();
            this.work();
            this.run();
            this.sleep();
            break;
        }
    }
}

class Robot extends Action { // 定义子类Robot行为
    public void eat() { // 覆写抽象方法
        System.out.println("为机器人加燃料。");
    }

    public void sleep() {
    }

    public void run() {
    }

    public void work() {
        System.out.println("让机器人开始工作。");
    }
}

class Woman extends Action { // 定义子类Woman行为

    public void eat() {
        System.out.println("请美女吃饭。");
    }

    public void sleep() {
        System.out.println("让美女睡美容觉。");
    }

    public void run() {
        System.out.println("让美女跑步健身。");
    }

    public void work() {

    }
}

class Man extends Action { // 定义子类Man行为

    public void eat() {
        System.out.println("帅哥吃早饭、午饭、晚饭、加餐。");
    }

    public void sleep() {
        System.out.println("帅哥休息好以恢复精神和体力。");
    }

    public void run() {
        System.out.println("帅哥通过跑步来锻炼身体。");
    }

    public void work() {
        System.out.println("帅哥为了和美女幸福地生活在一起，要好好工作。");
    }
}

运行结果：

运行结果3

如果想实现指定操作，只需将方法按照要求覆写即可，相当于父类定义出了一个操作模板。实际用的时候也可以在servlet程序设计上使用。

二、接口

接口（interface）是一种特殊的类，结构上和抽象类非常相似，也具有数据成员与抽象方法，但与抽象类又有不同。

1.接口的基本概念

接口里的数据成员必须初始化，且数据成员均为常量，常见的是全局变量。

接口允许定义默认方法，即default方法，也可以称作Defender方法，或者虚拟扩展方法（Virtual extension methods）。

语法：

interface 接口名称 { // 定义接口类
　　final 数据类型 成员名称 = 常量; // 数据成员必须赋初值
　　abstract 返回值的数据类型 方法名称（参数···）; // 抽象方法，注意在抽象方法里没有定义方法体
　　default 返回值的数据类型 方法名称（参数···）{ // 默认方法，包含方法体
　　···方法体···
　　}
}

定义接口例：

interface A { // 定义一个接口
　　public static final String INFO = "Hello Worlk."; // 全局常量
　　public abstract void print(); // 抽象方法
}

带默认方法的接口定义例：

interface B { // 定义一个接口
　　public static final String INFO = "Hello Worlk."; // 全局常量
　　public abstract void print(); // 抽象方法
　　default public void otherprint() { // 带方法体的默认方法
　　　　 System.out.println("default menthods!"); // 默认方法的方法体
　　}
}

思考

出差中，舟车劳顿，有点累。也确实有一段时间没有看书了。。。

---

记于2017年9月18日夜