Java抽象类、继承及多态和适配器的实现

Java继承

方法重写是Java语言多态的特性，必须满足以下条件

1. 在子类中，方法名称与父类方法名称完全相同
2. 方法的参数个数和类型完全相同，返回类型完全相同
3. 方法的访问修饰符访问级别不低于父类同名方法的访问级别
4. 在方法上添加@override注释，如果报错说明不是重写

方法重写限制

1. final修饰的父类方法在子类中不能被重写
2. static修饰的父类方法在子类中不能被重写，只能覆盖

super关键字

1. super关键字和this类似，super修饰的是父类的对象，如super();调用的是父类的默认无参构造器

Java抽象类

抽象类特点

1. 抽象类通常应包含抽象方法，也可以包含非抽象方法
2. 抽象类不能使用final关键字修饰
3. 抽象类自身不能够实例化
4. 抽象类就是用来被继承的

抽象类的继承

1. 子类必须实现父类所有的抽象方法
2. 如果子类已经override实现父类的抽象方法，间接子类可以不用实现该方法。

适配器

1. 定义一个适配器，类名+Adapator。比如MamalAdapator。继承给父类所有的方法一个空的实现。后面实例的类继承这个适配器，就可以选择性的重写实现部分父类的方法而不会报错。
2. 抽象类只提供一个抽象方法然后供子类去继承和重写override，然后特别是override的这个功能，可以做到比如Dog.eat，Cat.eat，不同的类，有不同的方法实现，但是方法名称都相同，给开发提供了极大的灵活性，后面的程序员接手开发的时候，比如需要再新增Tiger.eat,只需要再写一个Tiger类继承父类再override他的eat方法就可以了。

/**
 * 1 使用Eclipse 工具建立一个普通Java控制台应用程序, 自定义一个类继承Counter 类,
 * 并根据理解定义在Counter类中定义的抽象方法对父类的抽象方法进行实现,体会普通类继承
 * 抽象类必需做什么? 不同子类在继承Counter抽象类并实现抽象方法时的算法和什么有关.
 */

public class Test {
    public static void main(String[] args) {
        //用父类的类型去new一个子类
        Counter cou = new Add();
        //用父类的类型去调用子类的addition方法并实现
        System.out.println("3+9的和是"+cou.addition(3,9));
    }
}

/**
 * 1 使用Eclipse 工具建立一个普通Java控制台应用程序,
 * 自定义一个类继承Counter 类,并根据理解定义在Counter
 * 类中定义的抽象方法对父类的抽象方法进行实现,体会普通类
 * 继承抽象类必需做什么? 不同子类在继承Counter抽象类并
 * 实现抽象方法时的算法和什么有关.
 */

//定义一个抽象的父类Counter
public abstract class Counter {
    //定义一个抽象方法addition
    public abstract int addition(int num1, int num2);

    public Counter(){
        System.out.println("调用Counter父类构造器");
    }
}

/**
 * 1 使用Eclipse 工具建立一个普通Java控制台应用程序,
 * 自定义一个类继承Counter 类,并根据理解定义在Counter类中
 * 定义的抽象方法对父类的抽象方法进行实现,体会普通类继承抽象
 * 类必需做什么? 不同子类在继承Counter抽象类并实现抽象方法
 * 时的算法和什么有关.
 */

public class Add extends Counter{

    int num1 = 0;
    int num2 = 0;

    //重写父类中的加法并实现加法
    @Override
    public int addition(int num1, int num2) {
        this.num1 = num1;
        this.num2 = num2;
        return num1+num2;

    }

    public Add(){
        System.out.println("调用Add子类构造器");
    }
}

-----------------------------------------------分割线--------------------------------------------------------------

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.test;

import tool.abstracts.Construct;
import tool.abstracts.Tool;
import tool.abstracts.Traffic;
import tool.imp.Car;
import tool.imp.Hammer;

public class Test {
    public static void main(String[] args) {
        //实例化顶级工具类对象,调用其中功能方法
        Tool tool1 = new Traffic() {
            @Override
            public void constructTool() {

            }
        };
        tool1.trafficTool();

        Tool tool2 = new Construct() {
            @Override
            public void trafficTool() {

            }
        };
        tool2.constructTool();

        //实例化特殊工具类对象,调用其中功能方法
        Traffic traffic = new Car();
        traffic.trafficTool();

        Construct construct = new Hammer();
        construct.constructTool();


    }
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.abstracts;

//定义一个tool抽象类
public abstract class Tool {
    //定义一个交通工具抽象方法
    public abstract void trafficTool();
    //定义一个建筑工具抽象方法
    public abstract void constructTool();
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.abstracts;

//定义一个交通工具抽象类继承自工具类
public abstract class Traffic extends Tool {

    public void trafficTool(){
        System.out.println("我是所有交通工具的集合");
    };
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.abstracts;

//定义一个建筑工具抽象类继承自工具类
public abstract class Construct extends Tool {

    public void constructTool(){
        System.out.println("我是所有建筑工具的集合");
    };
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.adaptor;

import tool.abstracts.Construct;

//定义一个Construct的适配器
public class ConstructAdaptor extends Construct {

    //对交通工具方法进行一个重写和空实现
    @Override
    public void trafficTool() {

    }
    //对建筑工具方法进行一个重写和空实现
    @Override
    public void constructTool() {

    }
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.adaptor;

import tool.abstracts.Traffic;

//定义一个Traffic的适配器
public class TrafficAdaptor extends Traffic {

    //对交通工具方法进行一个重写和空实现
    @Override
    public void trafficTool() {
        System.out.println("我是所有交通工具的集合");
    }
    //对建筑工具方法进行一个重写和空实现
    @Override
    public void constructTool() {

    }
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.imp;

import tool.adaptor.TrafficAdaptor;

//定义一个普通类并具体实现交通工具方法
public class Car extends TrafficAdaptor {
    @Override
    public void trafficTool() {
        System.out.println("我是交通工具汽车");
    }
}

/**
 *2 生活中很多东西都可以被人利用从而作为一种工具,这些工具都具备一个共同的功能那就是“用途”，
 * 同时也有很多适合某个领域的工具(如,交通工具,建筑工具等 ),它们也在工具的范畴之内, 也有用
 * 途功能,同时又具备自己的一些领域功能, 人们在使用这些工具时,可以根据实际情况选择哪种具体
 * 类别的工具实体.
 * 根据以上描述,结合本单元知识点,设计工具抽象类定义用途的抽象方法,在此类的基础上定义在此抽
 * 象工具类范畴内的至少2种特殊工具的抽象类并继承上述的工具类 , 再根据实际使用工具的情况定
 * 义更具体的工具类实现对2种特殊工具类其一的继承, 分别实例化顶级工具类及特殊工具类对象,调
 * 用其中功能方法, 理解领悟抽象类之间的继承及实现多层继承的普通类要注意哪些问题.
 *
 * 3 继任务2实现, 当我们在使用继承抽象父类的时候, 我们的本意只是为使用某个抽象类的特定方法,
 * 但是受于普通类继承抽象类的限制,必需实现所有父级抽象类中的所有方法,既使不用那些方法也必需
 * 在子类中提供抽象方法的空实现,如何解决这个问题呢, 请在任务2的基础上编程实现.
 */

package tool.imp;

import tool.adaptor.ConstructAdaptor;

//定义一个普通类并具体实现建筑工具方法
public class Hammer extends ConstructAdaptor {
    @Override
    public void constructTool(){
        System.out.println("我是建筑工具锤子");
    }
}

-----------------------------------分割线-----------------------------------

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */

package test;

import abstracts.Tool;
import imp.*;

//定义一个主类Test
public class Test {
    public static void main(String[] args) {
        //实例化Person类
        Person per = new Person();
        //通过多态的方式，以父类的类型实例化各个子类
        Tool car = new Car();
        Tool plane = new Plane();
        Tool print = new Printer();
        Tool laptop = new Laptop();

        //调用对应的子类去具体实现抽象方法
        per.useTool(car);
        per.useTool(plane);
        per.useTool(print);
        per.useTool(laptop);
    }
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */

package abstracts;

//定义一个抽象的工具类作为父类
public abstract class Tool {
    //定义一个旅行的抽象方法
    public abstract void travel();

    //定义一个打印的抽象方法
    public abstract void print();

    //定义一个学习的抽象方法
    public abstract void study();
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */
package adaptor;

import abstracts.Tool;

//定义一个适配器，继承工具类并提供3个方法的空实现
public class ToolAdaptor extends Tool {
    @Override
    public void travel() {

    }

    @Override
    public void print() {

    }

    @Override
    public void study() {

    }
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */
package imp;

import adaptor.ToolAdaptor;

//定义一个汽车类继承父类的适配器，重写并具体实现旅行的这个抽象方法
public class Car extends ToolAdaptor {
    @Override
    public void travel() {
        System.out.println("使用汽车旅行");
    }
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */
package imp;

import adaptor.ToolAdaptor;

//定义一个飞机类继承父类的适配器，重写并具体实现旅行的这个抽象方法
public class Plane extends ToolAdaptor {
    @Override
    public void travel(){
        System.out.println("使用飞机旅行");
    }
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */
package imp;

import adaptor.ToolAdaptor;

//定义一个笔记本电脑类继承父类的适配器，重写并具体实现学习的这个抽象方法
public class Laptop extends ToolAdaptor {
    @Override
    public void study(){
        System.out.println("使用笔记本电脑学习Java");
    }
}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */
package imp;

import adaptor.ToolAdaptor;

//定义一个打印机类继承父类的适配器，重写并具体实现打印的这个抽象方法
public class Printer extends ToolAdaptor {
    @Override
    public void print() {
        System.out.println("使用打印机打印文件");
    }


}

/**
 * 4 在生活中,人们都会根据实际情况为完成某项任务而选择利用不同的工具.
 * 如我要旅行,会用到汽车或者飞机,我在打印文件时会用到打印机,我要学习
 * java会用到笔记本电脑, 如何设计一个应用程序定义一个人类并在人类中
 * 定义一个使用工具的方法, 能够让在真正使用工具时, 用什么工具则这个
 * 工具就能够出现在使用工具的过程中,请根据java语言继承及多态的特点
 * 完成此编程任务.
 */

package imp;

import abstracts.Tool;

//定义一个Person类
public class Person {
    //定义一个使用工具的方法，接收tool抽象类的类型，并调用tool抽象类的三个抽象方法
    public void useTool(Tool tool){
        tool.travel();
        tool.print();
        tool.study();
    }
}