不枯燥的学习java抽象

工具类介绍

开发中一些经常用到，重复使用的代码可以封装工具类，为了之下的代码整洁性，使用的工具类统一会在这里定义

StringUtil.java

/**
 * 字符串处理工具类
 *
 * @author 博博
 * @Title: StringUtil
 */
public class StringUtil {
 	  
     // 占位符
     private static final String FORMAT_PLACEHOLDER = "%s";
    
    
    /**
     * 安全的进行字符串 format
     *
     * @param target 目标字符串
     * @param params format 参数
     * @return format 后的
     */
    public static String format(String target, Object... params) {
        if (target.contains(FORMAT_PLACEHOLDER) && ArrayUtils.isNotEmpty(params)) {
            return String.format(target, params);
        }
        return target;
    }
    
}

ArrayUtils.java

/**
 * 数组工具类
 *
 * @author 博博
 * @Title: ArrayUtils
 */
public class ArrayUtils {


    private ArrayUtils() {
    }

    /**
     * 判断数据是否为空
     *
     * @param array 长度
     * @return 数组对象为null或者长度为 0 时，返回 false
     */
    public static boolean isEmpty(Object[] array) {
        return array == null || array.length == 0;
    }

    /**
     * 判断数组是否不为空
     *
     * @param array 数组
     * @return 数组对象内含有任意对象时返回 true
     * @see ArrayUtils#isEmpty(Object[])
     */
    public static boolean isNotEmpty(Object[] array) {
        return !isEmpty(array);
    }

}

抽象

• // 说到抽象，抽象是Java基础中极其重要一点，但是并不是那么好理解，为啥呢？顾名思义非常抽象，当然如果理解了其实也不难
  // 先来扯一下，何为java抽象，先来举个示例
  // 小鱼想买薯片和可乐（这货肯定是个肥宅），需要去薯片商店和可乐商店，这时候我们需要有两个属性  name、money
  
   	/**
       * 辣条类
       */
      static class SpicyStrip {
          // 名称
          private String name;
          // 价钱
          private double money;
  
          public SpicyStrip() {
              this.name = "辣条";
              this.money = 2.5;
          }
  
          public void shop() {
              System.out.println(StringUtil.format("您购买了%s,花费了%s", name, money));
          }
  
      }
  
      /**
       * 薯片类
       */
      static class PotatoChips {
          // 名称
          private String name;
          // 价钱
          private double money;
  
          public PotatoChips() {
              this.name = "薯片";
              this.money = 5.5;
          }
  
          public void shop() {
              System.out.println(StringUtil.format("您购买了%s,花费了%s", name, money));
          }
      }
  
      public static void main(String[] args){
          SpicyStrip spicyStrip = new SpicyStrip();
          spicyStrip.shop();
          PotatoChips potatoChips = new PotatoChips();
          potatoChips.shop();
      }
  
  
  

输出结果 您购买了辣条,花费了2.5 您购买了薯片,花费了5.5

以上小鱼去买东西的流程，小鱼都快疯了，好麻烦啊，我买个东西跑这还要跑那，幸好我没有去买辣条不然够我减肥了
有没有办法可以解决这种问题了，马某人这时候站出来办法捏还是有的，不过呢，最近有点想吃辣条，你懂意思吧。
小鱼一听慌忙说到我懂我懂，那麻烦您解决吧，马某人会心一笑，其实在Java中有一种感念叫抽象，使用‘abstract’修饰

使用前我们先注意抽象类的注意事项：
1.抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
2.抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类实例。即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
3.抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要用于被子类调用。
4.含有抽象方法的类（包括直接定义了一个抽象方法；或继承了一个抽象父类，但没有完全实现父类包含的抽象方法；或实现了一个接口，但没有完全实现接口包含的抽象方法三种情况）只能被定义成抽象类。
5.抽象方法，不能定义为私有的

小鱼一听，眼前一亮，小马小马那咱们快去啊，小马听到微微一笑，打了他一下，你慌啥，你知道它注意事项嘛？小鱼一听诶，好像也是诶，小马那他的注意事项是啥？小马眉头一皱你听好这很重要：
抽象类好归好，但是所有事情都是有得必有失，得到了抽象的能力，抽象类可以包括抽象方法；失即是失去了实例化的能力，抽象类无法实例化。
需要注意的是，抽象方法和空方法不是一个概念，例如 public abstract void shop();是个抽象方法，抽象方法没有方法体，即没有花括号（{}），用分号(;)替代；
但是 public void shop(){}　就是一个普通方法，即使什么事情都不做，也不能用　abstract　修饰。
听懂了嘛？小鱼说：半懂了小马，那你快点吧买东西的改造一下吧，我可以不想那么麻烦。小马一笑：懒猪，那你好好看。

首先我们得知道，一个完整的超市需要有有一个收银人员来结算账单．需要定义一个收银员的方法

	/**
     * 抽象类
     */
    static abstract class AbstractShop{

        // 名称
        protected String name;
        // 价钱
        protected double money;

        // 购买物品抽象方法
        protected abstract void shop();

        /**
         * 收银人员结账
         */
        public void settleAccounts(){
            shop();
        }

    }

	/**
	 * 薯片
	 */
    static class PotatoChips extends AbstractShop{

        public PotatoChips() {
            this.name = "薯片";
            this.money = 5.5;
        }

        @Override
        protected void shop() {
            System.out.println(StringUtil.format("您购买了%s,花费了%s", name, money));
        }
    }

	/**
	 * 辣条
	 */
    static class SpicyStrip extends AbstractShop{

        public SpicyStrip() {
            this.name = "辣条";
            this.money = 2.5;
        }

        @Override
        protected void shop() {
            System.out.println(StringUtil.format("您购买了%s,花费了%s", name, money));
        }
    }

    public static void main(String[] args){
        SpicyStrip spicyStrip = new SpicyStrip();
        spicyStrip.settleAccounts();
        PotatoChips potatoChips = new PotatoChips();
        potatoChips.settleAccounts();
    }

输出结果 您购买了辣条,花费了2.5 您购买了薯片,花费了5.5

小鱼瞅见没有，我们现在买东西，只需要购买了对应的物品，调用抽象方法中定义的收银员方法就可以了，省去了很多重复的操作
是不是方便了很多，如果以后在需要买其他的物品啊，就不用在重复编写大量重复代码，只需要继承抽象父类，然后实现抽象方法，就可以了
小鱼听了之后，开心的不得了，以后就方便很多啦，呐之前买的两包辣条都给你了，我先回家试试手。小马听到溺宠一笑，说到你只是知道怎么使用，还不知道具体的作用。

小鱼听到后：说好像也是诶，那小马快讲讲吧，讲完我好回去练手，小马听到一笑，看你猴急的，那你听好啊。

抽象类不能创建实例，只能当做父类被继承，从语义的角度来看的话，抽象类是从多个具体类中抽象出来的父类，它具有更高层的抽象。从多个具有相同特征的类中提取出
相同的部分形成抽象类。这种抽象类作为子类的模板，从而避免子类设计的随意性。
（什么是子类的随意性，就比如三个人去完成三个功能，人员A定义方法名称 maidongx(),人员B定义方法goumaidongx(),人员c定义方法shop()，在调用的时候往往很混乱）

抽象类体现出了一种模板模式的设计（设计模式会在后面学习到），抽象类作为多个子类的模板，子类在模板上进行扩展改造。

如上我们在抽象类中定义了方法settleAccounts() 这是子类的通用方法，而抽象方法shop()，细节留给子类实现，这就是一种设计模式，叫做模板模式，简单而又常用。

小鱼知道了嘛，抽象很重要但是不是那么好理解，但是如果你理解之后就会发现抽象类是多么有用和优秀
小马我知道了，小鱼沉稳的说。
那你快回家试试手吧，抽象课程先结束了。