Java day8【第十八章】抽象类的定义与使用

一.【第十八章】抽象类的定义与使用：

1.抽象类的基本概念：

　　　类继承的主要作用是可以扩充已有功能，但对于之前的继承我们不难发现，子类可以根据自己的需求来决定是否要覆写某一个方法，这时候父类无法对子类做出强制性决定（你必须覆写某些方法）。

　这个时候往往不会采用类的继承（在实际的开发中，很少会出现继承一个已经完善的类，可以直接使用的类，而是必须要继承抽象类），在以后进行父类设计的时候，我们优先考虑的，一定是抽象类。

 

　　　抽象类的主要作用在于对子类中覆写方法进行约定，在抽象类里面可以去定义一些抽象方法以实现这样的约定

　抽象类主要是指使用了abstract关键字定义的并且没有提供方法体的方法，而抽象方法所在的类必须为抽象类，抽象类必须使用abstract关键字定义（普通类的基础上追加抽象方法就是抽象类）。

范例：如何定义抽象类

abstract class Message
{
    private String type;
    public abstract String getConnectInfo();    //定义抽象类
    public void setType(){
        this.type = type;
    }
    public String getType(){                    //普通方法
        return this.type;
    }
}

　　抽象类的使用原则：

　　抽象类必须提供有子类，子类使用extends继承一个抽象类。

　　抽象类的子类（不是抽象类）一定要覆写抽象类中的全部抽象方法。

　　抽象类的对象实例化可以利用对象多态性通过子类向上转型的方法完成。

范例：

abstract class Message
{
    private String type;
    public abstract String getConnectInfo();    //定义抽象类
    public void setType(String type){
        this.type = type;
    }
    public String getType(){                    //普通方法
        return this.type;
    }
}

class DatebaseMessage extends Message
{

    @Override
    public String getConnectInfo(){
        return "Oracle数据库消息加载中....";
    }
}

 public class tsy
{
    public static void main(String[] args) 
    {
        Message mgr = new DatebaseMessage();    　　//向上转型实例化抽象类
        mgr.setType("客户消息");
        System.out.println(mgr.getConnectInfo());
        System.out.println(mgr.getType());
    }
}

　　从整体上来讲，抽象类只是比普通类增加了抽象方法以及对子类方法的强制性覆写。

对抽象类使用的几点意见：

　　1.抽象类使用很大程度上有一个核心问题：抽象类自己无法直接实例化；

　　2.抽象类之中主要的目的是进行过度操作使用，所以当你要使用抽象类进行开发的时候，往往都是在你设计中需要解决类继承问题所带来的代码重复处理

二.抽象类的相关说明

　　抽象类是一个重要的面向对象设计的结构，对于抽象类使用的时候需要注意以下几点内容：

　　1.抽象类不能用final关键字来进行定义

　　2.抽象类是作为一个普通类的加强版出现的（抽象类的组成就是在普通类的基础上扩展而来的，只是追加了抽象方法），那么既然是在普通类的基础上扩展的，

那么普通类之中就可以定义属性和方法，那么这些属性一定是要求进行内存空间开辟的，所以抽象类一定可以提供构造方法，并且子类也一定会按照子类对象的实

例化原则进行父类构造调用

　　3.抽象类中允许没有抽象方法，但是即便没有抽象方法，也无法直接使用关键字new实例化抽象类对象。

　　4.抽象类中可以提供有static方法，并且该方法不受到抽象类对象的局限。

范例：

abstract class Message
{
    public abstract String getInfo();//定义抽象方法。
    public static Message getInstance(){
        return new DatebaseMessage();
    }
}
class DatebaseMessage extends Message
{
    public String getInfo(){        //覆写抽象类方法
        return "数据库连接信息..." ;
    }
}

 public class tsy
{
    public static void main(String[] args) 
    {
        Message mgr = Message.getInstance();
        System.out.println(mgr.getInfo());
    }
}

　　static方法永远不受到实例化或者结构的限制，永远可以直接通过类名称直接调用。

 三.模板设计模式

　　抽象类的本质上就属于一个加强的类，那么对于类清楚了，可以描述一切的有关的现实事物，但是通过分析也可以发现，抽象类的设计应该是比类更高一层的定义。

那么下面我们来研究一下抽象类的实际应用。

　　假如说现在要描述有三类的事物：

　　　　1.机器人：不休息，只知道补充能量和工作

　　　　2.人类:需要休息、需要吃饭以及努力工作

　　　　3.猪：需要休息，不需要工作，只需要吃饭

abstract class Action
{
    public static final int Eat = 1;
    public static final int Sleep = 5;
    public static final int Work = 10;
    public void command(int code){
        switch(code){
            case Eat:{
                this.Eat();
                break;
            }
            case Sleep:{
                this.Sleep();
                break ;
            }
            case Work:{
                this.Work();
                break;
            }
            case Work+Eat+Sleep:{
                this.Work() ;
                this.Sleep() ;
                this.Work();
                break;
            }

        }
    }
    public abstract void Eat();
    public abstract void Sleep();
    public abstract void Work();
}

class Robot extends Action
{
    public void Eat(){
        System.out.println("电量不足请充电");
    }
    public void Sleep(){}
    public void Work(){
        System.out.println("梓同智能机器人开始工作...");
    }
}
class Person extends Action
{
    public void Eat(){
        System.out.println("我饿了");
    }
    public void Sleep(){
        System.out.println("我需要睡觉");
    }
    public void Work(){
        System.out.println("开始工作");
    }
}
class Pig extends Action
{
    public void Eat(){
        System.out.println("我需要吃饭");
    }
    public void Sleep(){
        System.out.println("我需要睡觉");
    }
    public void Work(){}
}
 public class tsy
{
    public static void main(String[] args) 
    {
        Action RobotAction = new Robot();
        Action PersonAction = new Person();
        Action PigAction = new Pig();
        System.out.println("-----------机器人行为----------");
        RobotAction.command(Action.Eat);
        RobotAction.command(Action.Work);
        System.out.println("-----------人类行为----------");
        PersonAction.command(Action.Sleep+Action.Work+Action.Eat);
        System.out.println("-----------猪的行为----------");
        PigAction.command(Action.Sleep);
        PigAction.command(Action.Eat);
    }
}

 

　　父类提供了子类方法的模板

　　抽象类最大的好处是对子类方法的统一管理，二十可以自身提供有一些普通方法可以调用抽象方法，这些抽象方法必须在子类提供实现的时候才会生效