Java学习总结——枚举

拾壹——快速归类整型常数

一、枚举的简介

在 JDK 1.5 以前，Java 并不支持枚举数据类型。在 JDK 1.5，Java 引入的一种新类型——枚举类型（ Enumerated Type ）。定义时，它使用 enum 关键字标识。例如，表示一周的星期几，用 SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY 就可表示为一个枚举。枚举所用的自然表示法让程序更具有可读性。

二、Java 中的枚举

JDK 1.5 以后，Java 语言中新出现的类型诸如枚举类型等一系列新的数据，这些类型的出现表明 Java 日趋完善，编程语言的日益人性化。

1.常见的枚举定义方法

在枚举类型中，一般的定义形式如下：

        enum 枚举名 {枚举值表};

其中 enum 是 Java 中的关键字。在枚举值表中应罗列出所有的可用值，这些值也称为枚举元素。

例如：

        enum WeekDay {Mon,Tue,Wed,Thu,Fri,Sat,Sun};

这里定义了一个枚举类型 WeekDay，枚举值共有 7 个，即一周中的 7 天。凡被说明为 WeekDay 类型变量的取值，只能是这 7 天中的某一天。

枚举变量也可用不同的方式说明，如先定义后说明、定义的同时说明或直接说明。

设有变量 a、b、c 被定义为上述的枚举类型 WeekDay，可采用以下任意一种方式。

        enum WeekDay {Mon,Tue,Wed,Thu,Fri,Sat,Sun};    //先定义
        enum WeekDay a,b,c;    //后说明

或者为：

        enum WeekDay {Mon,Tue,Wed,Thu,Fri,Sat,Sun} a,b,c;    //定义的同时说明

或者为：

        enum {Mon,Tue,Wed,Thu,Fri,Sat,Sun} a,b,c    //直接说明，即定义无名枚举

2.在程序中使用枚举

如果使用 Java 中的 Enum 方法，代码量将大大减少。同时，代码的可修改性与可读性也会相应地提高。

例如：

        //在Java中使用枚举
        enum MyColor {红色，绿色，蓝色};
        public class EnumColor
        {
            public static void main(String[] args)
            {
                MyColor c1 = MyColor.红色;    //获取红色
                System.out.println(c1);

                MyColor c2 = MyColor.绿色;    //获取绿色
                System.out.println(c2);

                MyColor c3 = MyColor.蓝色;    //获取蓝色
                System.out.println(c3);
            }
        }

通过 Java 提供的枚举类型，可以很轻松地调用枚举中的每一种颜色。而且，使用此方式还可以避免使用接口实现枚举的操作。

3.在 switch 语句中使用枚举

使用 Enum 关键字创建的枚举类型，也可以直接在多处控制语句中使用，如 switch 语句等。在 JDK 1.5 之前，switch 语句只能用于判断字符或数字，它并不能对在枚举中罗列的内容进行判断和选择。而在 JDK 1.5 之后，通过 Enum 创建的枚举类型，也可以被 switch 判断使用。

例如：

        //在Java中使用枚举
        enum MyColor {红色，绿色，蓝色};
        public class EnumSwitch
        {
            public static void main(String[] args)
            {
                MyColor c1 = MyColor.绿色;    //定义MyColor枚举变量c1，并赋值为“绿色”
                switch(c1)    //用switch方式来比较枚举对象
                {
                    case 红色：
                    {
                        System.out.println("红色");
                        break;
                    }

                    case 绿色：
                    {
                        System.out.println("绿色");
                        break;
                    }

                    case 蓝色：
                    {
                        System.out.println("蓝色");
                        break;
                    }
                }
            }
        }

由于 Java 采用的是 Unicode 的字符串编码方式，所以枚举值也可支持中文。由此看出，在 JDK 1.5 之后，switch 同样可以用来判断一个枚举类型，并对枚举类型作出有效选择。这有助于增加代码的可读性和延伸性。

三、枚举和枚举关键字

枚举类型的出现，有助于简洁程序的代码量，减少出错量。在大多数情况下，枚举类和枚举关键字是相互依存的。枚举关键字是定义枚举类型时必不可少的声明，而枚举类则是规定的枚举类型母类。

1.枚举类

枚举类（ Enum 类 ）是在 Java.lang 包下定义的一个公共类，它的作用是用来构造新的枚举类型。这是在 JDK 1.5 之后 Java 推出的一个新的类。用来弥补关于枚举这一常用集合在 Java 中的不足。同时，Enum 类中的构造方法可方便对代码的操作。

在 JDK API 中可以看到，在 Enum 类中定义了大约十多个方法，每一种方法都是对用 Enum 创建的枚举对象实时操作，所以 Enum 类是一个完整的类型。它拥有自己的方法，当创建一个关于 Enum 的类型对象时，便可调用其中的方法来完善对于枚举类型的操作。

下表列出了 Enum 类中的主要方法：

修饰符	方法及其功能
protected	Enum(String name,int ordinal)单独的构造方法
protected Object	clone() 抛出 CloneNotSupportedException
int	compareTo(E o) 比较此枚举与指定对象的顺序
boolean	equals(Object other) 当指定对象等于此枚举常量时，返回 true
protected	void finalize() 枚举类不能有 finalize 方法
Class<E>	getDeclaringClass() 返回与此枚举常量的枚举类型相对应的 Class 对象
int	hashCode() 返回枚举常量的哈希码
String	name() 返回此枚举常量的名称，在其枚举声明中对其进行声明
int	ordinal() 返回枚举常量的序数（ 它在枚举声明中的位置，其中初始常量序数为零 ）
String	toString() 返回枚举常量的名称，它包含在声明中
static
<T extends Enum<T>> T	valueOf(Class<T> enumType,String name) 返回带指定名称的指定枚举类型的枚举常量

例如：

        //通过values()方法得到对象取值
        enum MyColor{红色，绿色，蓝色};
        public class ValueOfEnum
        {
            public static void main(String[] args)
            {
                MyColor[] allColor = MyColor.values();    //用枚举数组读取枚举中的值
                for(MyColor aColor:allColor)    //遍历输出枚举数组的元素
                {
                    System.out.println(aColor);
                }
            }
        }

枚举关键字（ enum ）是定义的一个枚举类型。实际上，在此次定义的过程中，通过 enum 关键字相当于定义了一个类，并且此类将继承自 Enum 类。在上面的 Enum 类 “ 方法概要 ” 的表格中，并没有列出来 values() 方法。实际上，这是编译器添加的隐式方法，如果一个对象被声明为 enum 类型，编译器会自动给该类型添加一个隐含的方法 values()，它的原型为：

        public static E[] values();

2.枚举关键字

被定义的对象拥有 Enum 类中的构造方法的使用权。如前面的 Enum 类 “ 方法概要 ” 的表中所示，在 Enum 类中的构造方法中时受保护的，实际上对于每一个枚举的对象一旦声明之后，就表示自动调用此构造方法，所有的编号方式均采用自动编号的方式进行。在没有对编号作出特殊声明时，Java 虚拟机将对被创建的枚举类型对象的枚举值自动编号，编号从 0 开始。例如，对于下面的枚举定义：

        enum MyColor{红色，绿色，蓝色};

" 红色 " 对应的编号是 0，" 绿色 " 对应的编号是 1，" 蓝色 " 对应的编号是 2。

举例说明：

        //通过调用Enum类中的ordinal()方法，输出枚举类型中每一个对象的编号
        enum MyColor{红色，绿色，蓝色};
        public class OrderOfEnum
        {
            public static void main(String[] args)
            {
                MyColor[] allColor = MyColor.values();    //用枚举数组读取枚举中的值
                for(MyColor aColor:allColor)    //遍历输出枚举数组元素对应的编号
                {
                    System.out.println(aColor.name() + "→" + aColor.ordinal());
                }
            }
        }

其中引入了两种在 Enum 类中包含的方法：name() 和 ordinal()，分别获得不同对象的名称及编号。

3.枚举类与枚举关键字的联系

在 JDK API（ 应用程序接口，Application Programming Interface，简称 API ）中，找到 Java.lang 下的 Enum类，可看到许多关于 Enum 类的方法。实际上，使用 enum 关键字，相当于定义了一个类，该类继承自 Enum 类。而在 Enum 类中的方法，访问权限都是保护（ protected ）类型的，因此这些方法都可以在 enum 关键字定义的对象中直接使用。例如，调用 Enum 类中存在 valueof() 方法，该方法返回带指定名称的指定枚举类型的枚举常量。

举例说明：

        //调用 Enum 类中的valueof()方法
        enum Color{红色，绿色，蓝色};
        public class ValueOfEnum
        {
            public static void main(String[] args)
            {
                Color c = Color.valueOf(Color.class,"红色");
                System.out.pringln(c);
            }
        }

Color 枚举类型调用在 Enum 类中方法 valueof()，这是一个静态方法，用于返回枚举类中指定名称的枚举值。方法 valueof() 的第一个参数 “ Color.class ” ，用来返回 Color 的类型——枚举类型，第二个参数是字符串常量 “ 红色 ”。

valueof() 方法的原型比较复杂，如下所示：

        public static <T extends Enum<T>> T valueOf(Clsaa<T> enumType,String name)

该方法的第一个参数 enumType，是枚举类型的 Class 对象返回一个常数。在上面valueof()方法的举例中，可通过传递 Color.class 类型来完成参数的传入。

该方法的第二个参数 name，是一个常量字符串名称。这个参数必须在与该枚举类中声明枚举值时使用的标识符完全匹配，不允许使用额外的空白字符。例如，如果在上面的代码中使用 “ 红    色 ”，字符串中间有空格，则会返回方法无法识别数据源的错误。

        java.lang.Enum.valueOf(Unknown Source)

该方法的返回值为 <T extends Enum<T>> T，它是指定枚举类型的枚举常量。从返回类型中的修饰符 “ extends Enum ”，可以看出该方法返回的枚举类型继承自类 Enum。而该方法中出现的 “ T ” 表示的是模板类型参数，在上例中，被实例化为 Color。此外，应注意到由于 valueof() 为静态方法，所以访问方式为 “ 类名.方法名() ”。

下面我们总结一下使用枚举类的注意事项：

（1）如果 enum 定义的枚举类访问权限定义为 public，则需要单独形成一个 .java 文件，即不可与包含 main 方法的 public 类同处一个文件。如果 enum 定义的枚举类访问权限为默认类型，即 enum 关键字前没有修饰符，则 enum 定义的对象可在同一个包里访问，无需重复定义。如不在同一个包中，可通过导入（ import ）的模式来复用这个定义。

（2）使用 enum 定义的枚举类，默认继承于 java.lang.Enum 类。使用 enum 定义的枚举类，默认会使用 final 修饰，因此该类无法派生子类。

（3）使用 enum 定义的枚举类，其所有的枚举值（ 实际上是该类的实例 ）必须在枚举类的第一行显示列出，否则这个枚举类将永远不能产生实例。在列出这些实例时，系统会自动添加 public static final 修饰。

（4）所有使用 enum 定义的枚举类，都会由系统隐式提供一个 values() 方法，该方法可方便地遍历所有的枚举值。

四、类集对于枚举的支持

在 JDK 1.5 之后，为了更好的支持枚举类型，java.util 中又添加了两个新类，分别是 EnumMap 和 EnumSet，使用它们可更加高效地操作枚举类型。

1.EnumMap

Map（ 映射 ）本质上是一种把键和值<key，value>一一对应的映射集合，它的每一个元素都包含一对键对象和值对象。Map 关系类似于学生的学号和姓名的对应关系，找到关系，就能很快找到学生的姓名，在这个映射表中，如果来了新的学生，我们可以很自然地添加一个新的<学号，姓名>映射元素。

Map 是 Java 中的一个类，EnumMap 是 Map 接口的子类，它被视为专门为枚举类型量身定做的 Map 实现。虽然使用其他 Map 实现（ 如 HashMap ）也可以完成枚举类型实例到值的映射，但使用 EnumMap 会更为高效。这是因为 EnumMap 只接收同一枚举类型的实例作为键值，枚举类型实例的数量有限并且相对固定，因此 EnumMap 使用数组来存放与枚举类型对应的值，这使得 EnumMap 的存取效率比较高。由于 EnumMap 继承自 Map，Map 中的方法都可以在 EnumMap 使用，通过调用 EnumMap 中的方法可方便地完成对枚举对象的操作。

例如：

        //使用EnumMap操作枚举类中实例
        import java.util.EnumMap;
        import java.util.Map;
        enum Color{红色，绿色，蓝色};
        public class EnumMapDemo
        {
            public static void main(String[] args)
            {
                EnumMap<Color,String> eMap = new EnumMap<Color,String>(Color.class);
                eMap.put(Color.红色,"RED");    //添加EnumMap元素
                eMap.put(Color.绿色,"GREEN");
                eMap.put(Color.蓝色,"BLUE");
                for(Map.Entry<Color,String> me:eMap.entrySet())
                {
                    System.ouot.println(me.getKey() + "→" + me.getValue());
                }
            }
        }

值得注意的是，EnumMap<KeyType,NameType>是一个模板类，这里它们的两个类型参数 KeyType 和 NameType 分别被实例化为 Color 和 String。EnumMap 的构造方法参数不能为空，需要指定一个枚举类，上例中的参数为 Color.class，这个 .class 对象给 EnumMap 类提供有关枚举 enum 的元信息（ meta information ），这些信息主要包括枚举值的数量，这样是为 EnumMap 创建内置数组来存储这些枚举值提供方便。

在上例中，将 “ Color.红色 ” 作为键（ key ），“ RED ” 作为映射的值（ value ），二者一起构成一对<key，value>映射，然后利用 EnumMap 中的 put() 方法来操作完成这种映射。其中，EntrySet() 是定义在 Map 类中的一个方法，其作用是返回整个映射实例（ entry ）的集合。EntrySet() 方法名中的 Set 不能理解 “ 设置 ”，其表示的含义是 “ 集合 ”。

2.EnumSet

Map 是一个二元组的集合，Map 中的每个元素都是由 <key，value> 两个属性组成。Map 提供从 key 到 value 的映射。通过 key 可以很容易地找到其对应的 value。一个 Map 中不能包含相同的 key，即每个 key 必须是独一无二的，且每个 key 只能映射一个 value。这里需要说明的是，value 的值是可以重复的。

而对于 Set，它是一个一元组集合，其包含一系列不可重复的数据，即对于 Set 中任意两个元素 e1 和 e2，都有 e1.equals(e2)=false。也可以将 Set 理解为，其元素中只包含 key，而 key 是不允许重复的。Set 中最多有一个 null（ 空 ）元素。Set 可进行集合的各种操作（ 如交、并、补等 ）。

EnumSet 可视为专门用于处理枚举（ enum ）类型的 Set 类集。EnumSet 本身是 Set 接口的子类，但是在此类中并没有提供任何的构造方法定义，这表明其构造方法被私有化了。此外，所有对此类方法的操作均属于静态操作。

举例：

        //测试 EnumSet 静态方法 allOf()
        import java.util.EnumSet;
        import java.util.Iterator;

        enum Color{红色，绿色，蓝色};
        public class EnumSetDemo
        {
            public static void main(String[] args)
            {
                //下行表示将枚举全部的内容设置到集合中
                EnumSet<Color> eSet = EnumSet.allOf(Color.class);
                Iterator<Color> iter = eSet.iterator();

                while(iter.hasNext())
                {
                    System.out.println(iter.next());
                }    
            }
        }

allof() 是 EnumSet 中的内部静态方法，用来将这个方法参数中所指向的全部内容设置到集合。在上例中，定义了一个指向枚举类型 Color 类型的迭代器（ Iterator ）。

迭代器，有时也称游标（ cursor ），在某种意义上，它类似于 C/C++ 中的 “ 指针 ”，用于遍历集合类的元素。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。设计人员仅需了解集合遍历的接口，而无需关注集合类中的内存分配的实现细节。

hasNext() 方法，判断集合中是否还有元素，如果有，迭代器通过 iter.next() 方法指向下一个集合元素，如果没有元素了，while 循环中的逻辑判断条件 iter.hasNext() 返回 false，终止循环。

举例：

        //调用noneOf()方法，对同样包含在EnumSet类中的不同方法的调用
        import java.util.EnumSet;
        import java.util.Iterator;

        enum Color{红色，绿色，蓝色};
        public class EnumSetDemo
        {
            public static void main(String[] args)
            {
                //下行表示此类型的空集合
                EnumSet<Color> eSet = EnumSet.noneOf(Color.class);
                Iterator<Color> iter = eSet.iterator();

                while(iter.hasNext())
                {
                    System.out.println(iter.next());
                }    
            }
        }

使用了 noneOf() 方法，表示 Color.class 中的元素一个也不取，所以 eSet 为空集合。

五、深入了解枚举

在 Java 中，枚举的作用占有举足轻重的地位。

1.枚举的构造方法

枚举的使用非常灵活，它可应用于代码中的各个角落，只要定义的对象具有枚举的特征，均可使用枚举对其进行定义，这样在减少代码量的同时，也可增加代码的可读性和可操作性。

举例：

//定义枚举的构造方法
enum NewColor
{
    
    //NewColor定义的三个对象
    RED("红色"，4)，GREEN("绿色"，5)，BLUE("蓝色"，6);
    
    //成员变量
    private String name;
    private int index;
    
    //构造方法
    private NewColor(String name,int index)
    {
        this.name = name;
        this.index = index;
    }

    //普通方法
    public static String getName(int index)
    {
        for(NewColor c:NewColor.value())
        {
            if(c.getIndex() == index)
            {
                return c.name;
            }
            return null;
        }
    }

    public String getName()
    {
        return name;
    }

    public static void setName(int index,String name){
        for(newColor c:NewColor.values())
        {
            if(c.getIndex == index)
            {
                c.name = name;
                return;
            }
        }
    }

    public static void setIndex(int index,String name)
    {
        for(NewColor c:NewColor.values())
        {
            if(c.getName() == name)
            {
                c.index = index;
                return;
            }
        }
    }
}


public class DeepEnum
{
    public static void main(String[] args)
    {
        System.out.println("——————输出枚举中的元素——————");
        System.out.println(NewColor.RED.getIndex() +"→"+ NewColor.RED.getName());
        System.out.println(NewColor.GREEN.getIndex() +"→"+ NewColor.GREEN.getName());
        System.out.println(NewColor.BLUE.getIndex() +"→"+ NewColor.BLUE.getName());

        System.out.println("——————在自定义编号和属性值之后，测试——————");
        NewColor.setName(4,"黑色");    //重新设置名称
        System.out.println("4 → " + NewColor.getName(4));
        NewColor.setName(7,"黑色");    //重新设置索引编号
        System.out.println("7 → " + NewColor.getName(7));
    }
}

2.枚举的接口

（1）为什么需要接口

所有的枚举事实上都继承自 java.lang.Enum 类。这表明枚举已有了一个 “ 父类 ”，那它不能再继承其他类，Java 语言的设计者是聪明的，他们为用户 “ 关闭了一扇窗 ”，但又 “ 开启了另外一扇窗 ”，那这扇窗就是 Java 中的一个重要概念——接口（ interface ）。

在 Java 的一个类中，既包括数据成员（ 即属性 ），又包括对这些属性的操作（ 即方法 ）。

而在 Java 的一个接口中，在某种程度上，它可视为一个简化版本的 “ 类 ”，其仅包括一系列方法和一些不可更改的静态常量。Java 中的接口不能直接拿来实例化任何对象，因为在其内仅仅提供了方法的声明，即只有方法的特征而没有方法的具体实现，它不具备实例化对象的条件。换句话说，接口 “ 生来 ” 就是要被继承的，在继承中被具体化实现。结构中的这些方法可在不同的地方被不同的类实现，从而可表现出具有不同的 “ 个性化 ” 行为（功能）。

Java 语言中的接口，只是对要实现该接口方法的所有类提出了一个共享的固定格式的协议（ protocol ）。这些协议固定了在其内的静态常量和方法签名（ 方法名 + 参数列表 ）形式，而继承这个接口的类，就可在其类中对这些继承而来的方法，“ 独立自主、自由发挥 ” 地实现这些方法。

Java 语言虽然不支持一个类由多个直接的父类（ 即不支持多继承 ），但一个类却可以实现（ implements ）多个接口。接口弥补了 Java 类不能多继承的缺点，单继承和多接口的双重设计既保持了类的数据安全，也间接实现了多继承。

（2）枚举中如何实现接口

枚举与普通类一样，可以实现一个或多个接口。当一个枚举实现一个接口之后，各个枚举对象都必须非别实现接口中的抽象方法。

举例：

        public interface ColorInterface
        {
            public String getColor();
        }

接口内含一个 getColor() 方法，目的在于得到一个枚举类中的内容。但在接口中的 getColor() 方法，仅有方法的原型，而没有具体的实现。

举例：

//对新建接口抽象方法的调用。对接口中定义的抽象方法的调用，并且在后期声明的枚举类型中，任何一个对象都必须分别实现结构中的抽象方法
enum NewColor implements ColorInterface
{
    红色    //每一个枚举对象都需要具体化从接口中继承而来的方法
    {
        public String getColor()
        {
            return "RED";
        }
    },

    绿色
    {
        public String getColor()
        {
            return "GREED";
        }
    },

    蓝色
    {
        public String getColor()
        {
            return "BLUE";
        }
    };
}

在枚举类型里面实现接口的方法时，必须为每个枚举对象实现一次从接口 ColorInterface 继承而来的方法。其中每个枚举值之间是用逗号 “ , ” 隔开的，最后一个才是用分号 “ ; ” 结尾的。之所以这样做，其实是为了保证枚举类定义对象必须出现在该类的第一行。我们可以将其理解为是一条复合大语句，本质上就是一条语句。

上例的每个枚举值在调用 getColor() 方法时，得到都会有类似的结果——返回颜色对应的英文大写字符串，这是因为每个枚举对象对 getColor() 方法体的实现部分是类似的。事实上，每个枚举值在实现 getColor() 方法时，可以表现出不一致的行为来。

举例：

//通过代码测试上例实现的接口类型
public class TestColor
{
    public static void main(String[] args)
    {
        for(NewColor c:NewColor.values())
        {
            System.out.println(c.ordinal() + "→" + c.name() + ":" + c.getColor());
        }
    }
}

枚举中的任何一个对象都分别实现接口中的方法后，才能测试成功。

3.在枚举中定义抽象方法

枚举可以实现接口。

在接口中定义的方法，由于只有方法原型，没有具体实现，这些方法可视为是 “ 抽象的 ” 方法，不管用不用修饰符 abstract 都是一样。实际上，Java 也可以在枚举中直接定义一个或多个抽象方法。需要注意的是，这种情况下，需要为枚举中的每个对象单独地实现此方法。

举例：

//定义枚举的抽象方法
//直接在没居中定义抽象方法，其中每个对象都必须单独实现此方法
enum NewColor
{
    红色    //每个枚举对象都需实现所定义的抽象方法
    {
        public String getColor()
        {
            retrun "RED";
        }
    },
    绿色
    {
        public String getColor()
        {
            retrun "GRREN";
        }
    },
    蓝色
    {
        public String getColor()
        {
            retrun "BLUE";
        }
    };
    
    public abstract String getColor();    //定义抽象方法
}

public class AbstractEnum
{
    public static void main(String[] args)
    {
        for(NewColor c:NewColor.values())
        {
            System.out.println(c.ordinal() + "→" + c.name() + ":" + c.getColor());
        }
    }
}

上例抽象方法 getColor() 是在枚举类中定义的。在 Java 编程实现上，所谓抽象方法，就是用关键字 abstract 修饰且没有实现主体的方法。这个抽象方法 getColor() 需要在枚举对象中一一给予单独实现，否则编译会出错。

六、本文注意事项

1.枚举使用时的注意事项

Java 为枚举扩展了非常强大的功能，但是在使用过程中，常会错用枚举。以下是 2 点使用过程中的注意事项：

（1）枚举类型不能用 public 和 protected 修饰符修饰构造方法。构造方法的权限只能是 private 或者 friendly，friendly 是当没有修饰符时的默认权限。因为枚举的这种特性，所以枚举对象是无法在程序中通过直接调用其构造方法来初始化的。

（2）定义枚举类型时，如果是简单类型，name最后一个枚举值后可以不加分号。但是如果枚举中包含有方法，那么最后一个枚举值后面代码必须要用分号 “ ； ” 隔开。

2.枚举类不可以被继承

在枚举类内部可以定义一个或多个抽象方法时，这个枚举类不能用 abstract 修饰。如果一个枚举类用 abstract 修饰，那么就说明需要其他类继承这个所谓的 “ 抽象枚举类 ”，而在 Java 中，规定枚举是不能被继承的。因此，枚举不能用 abstract 修饰，只能在每个枚举的实例实现每个抽象方法。