第六章.面向对象（下）

Java 8增强的包装类：

8中基本数据类型——8中包装类：

byte                           Byte

short                          Short

int　　　　　　　　  Integer

long　　　　　　　   Long

char　　　　　　　  Character

float　　　　　　      Float

double　　　　　　  Double

boolean　　　　　　Boolean

除了int和char例外，其余基本数据类型对应的包装类都是将其首字母大写

Java1.5提供了自动装箱（Autoboxing）和自动拆箱（AutoUnboxing）功能

　　自动装箱：可以把一个基本类型变量直接赋值给对应的包装类变量，或赋值给Object变量。

　　自动拆箱：允许直接把包装类对象直接赋值给一个对应的基本类型变量。

public class AutoBoxingUnboxing{
    public static void main(String[] args){
        //直接把一个基本类型变量赋给Integer对象
        Integer inObj = 5;
        //直接把一个boolean类型变量赋给一个Object类型的变量
        Object boolObj = true;
        //直接把一个Integer对象赋给int类型的变量
        int it = inObj;
        if(boolObj instanceof Boolean){
            //先把Object对象强制类型转换为Boolean类型，再赋值给boolean变量
            boolean b = (Boolean) boolObj;
            System.out.println(b);
        }
    }
}

　　Java还提供了基本类型变量的包装类和字符串之间的转换：

　　　　包装类（除了Character之外）提供了 parseXxx(String s)静态方法，可将字符串转换为基本数据类型

　　　　String类提供了多个重载valueOf()方法，用于将基本类型转变为字符串

public class Primitive2String{
    public static void main(String[] args){
        String intStr = "123";
        //把一个特定字符串转换成int变量
        int it1 = Integer.parseInt(intStr);
        int it2 = new Integer(intStr);
        System.out.println(it2);
        String floatStr = "4.56";
        //把一个特定字符串转换成float变量
        float ft1 = Float.parseFloat(floatStr);
        float ft2 = new Float(floatStr);
        System.out.println(ft2);
        //把一个float变量转换成String变量
        String ftStr = String.valueOf(2.345f);
        System.out.println(ftStr);
        //把一个double变量变成String变量
        String dbStr = String.valueOf(3.344);
        System.out.println(dbStr);
        //把一个boolean变量转换为String变量
        String boolStr = String.valueOf(true);
        System.out.println(boolStr.toUpperCase());
    }
}

　　　　把基本类型转换为String类型，更简便的方法是：

　　　　　　String intStr = 5 + "";

　　　　包装类的实例可以与数值类型进行比较：

　　　　　　Integer a = new Integer(6);

　　　　　　//输出true

　　　　　　System.out.println("6的包装类实例是否大于5.0：" + (a > 5.0));

 处理对象：

　　Object类中的方法：

　　　　1.toString()：

　　　　　　java中System.out.println(p);//p是Person类的一个引用，该语句等价于System.out.println(p.toString());

　　　　　　java中所有对象都可以和字符串进行连接运算：String pStr = p + "";//等价于String pStr = p.toString() + “”;

　　　　　　Object类提供的toString()方法总是返回该对象实现类的“类名 + @ + hashCode”，用户要自己重写Object类中的toString()方法来实现类的”自我描述”功能。

　　　　2.==和equals()方法

　　　　　　测试两个变量是否相等的两种方式：== 和 equals()

　　　　　　若两个变量是基本类型变量，且都是数值类型（不一定要求数据类型严格相同），则只要两个变量的值相等，就将返回true；

　　　　　　若两个变量是引用类型变量，只有它们指向同一个对象时，==判断才会返回true。==不可用于比较类型上没有父子关系的两个对象。

public class EqualTest{
    public static void main(String[] args){
        System.out.println("hello" == new EqualTest());
    }
}

　　　　　　Object类中的equals()方法和==没有任何区别，要求两个引用变量指向同一个对象才会返回true。若希望采用自定义的相等标准，需要重写。

　　　　　　String类重写了equals()方法，判断两个字符串相等的标准是：只要两个字符串包含的字符序列相同，通过equals()比较将返回true，否则将返回false。

下面是一个重写了equals()方法的Person类：

class Person{
    private String name;
    private String idStr;
    public Person(){}
    public Person(String name, String idStr){
        this.name = name;
        this.idStr = idStr;
    }
    
    public String getIdStr(){
        return idStr;
    }
    
    //重写equals()方法
    public boolean equals(Object obj){
        //若两个对象为同一个对象
        if(this == obj)
            return true;
        //只有当obj是Person对象
        if(obj != null && obj.getClass() == Person.class){
            Person personObj = (Person) obj;
            //并且当前对象的idStr与obj对象的idStr相等时才可判断两个对象相等
            if(this.getIdStr().equals(personObj.getIdStr()))
                return true;
        }
        return false;
    } 
}

public class OverrideEqualsRight{
    public static void main(String[] args){
        Person p1 = new Person("孙悟空", "1234");
        Person p2 = new Person("孙悟空", "1234");
        Person p3 = new Person("孙悟饭", "4321");
        //p1和自身相比
        System.out.println("p1和p1是否相等？" + p1.equals(p1));
        //p1和p2的idStr相等，所以输出true
        System.out.println("p1和p2是否相等？" + p1.equals(p2));
        //p2和p3的idStr不相等，所以输出false
        System.out.println("p2和p3是否相等？" + p2.equals(p3));
    }
}

　　　这里判断obj是否为Person类的实例使用的是obj.getClass() == Person.class//使用了反射基础

　　　不适用instanceof运算符，是因为对于instanceof运算符而言，前操作数只要是后操作数的实例或其子类的实例时，都将返回true；而我们要判断两个对象是否是同一个类的

　　　实例，所以不能使用instanceof运算符。

单例（Singleton）类：

　　一个类始终只能创建一个实例，则这个类被称为单例类：

class Singleton{
    //使用一个类变量来缓存曾经创建的实例
    private static Singleton instance;
    
    //对构造器使用private修饰，隐藏该构造器
    private Singleton(){}
    
    //提供一个静态方法，用于返回Singleton实例
    //该方法可以加入自定义控制，保证只产生一个Singleton对象
    public static Singleton getInstance(){
        //若instance为null，则表明还不曾创建Singleton对象
        //若instance不为null，则表明已经创建了Singleton对象
        if(instance == null){
            //创建一个Singleton对象，并将其缓存起来
            instance= new Singleton();
        }
        
        return instance;
    }
}

public class SingletonTest{
    public static void main(String[] args){
        //创建Singleton对象不能通过构造器
        //只能通过getInstance()方法来得到实例
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        System.out.println(s1 == s2);//将输出true
    }
}

final修饰符：

　　final关键字可用于修饰类、变量和方法，表示它修饰的类、方法和变量不可改变。

　　final修饰变量，一旦该变量获得了初始值就不可被改变

　　java程序规定：final修饰的成员变量必须有程序员显式地指定初始值，系统不会对final成员进行隐式初始化，不要再未初始化final成员前，访问final成员

public class FinalErrorTest{
    //定义一个final修饰的实例变量
    //系统不会对final成员变量进行默认初始化
    final int age;
    {
        //age没有初始化，所以此处代码将引起错误
        System.out.println(age);
        age = 6;
        System.out.println(age);
    }
    
    public static void main(String[] args){
        new FinalErrorTest();
    }
}

　　final修饰的类变量、实例变量：

　　　　类变量：必须在静态初始化块中指定初始值或生命该类变量时指定初始值，二选一

　　　　实例变量：必须在非静态初始化块、声明该实例变量或构造器中指定初始值，三选一

public class FinalVariableTest{
    //定义成员变量是指定初始值，合法
    final int a = 6;
    //下面变量将在构造器或初始化块中分配初始值
    final String str;
    final int c;
    final static double d;
    //既没有指定初始值，有没有在初始化块、构造器中指定初始值
    //下面定义的ch实例变量是不合法的
    final char ch;
    //初始化块，可对没有指定初始值的实例变量指定初始值
    {
        //在初始化块中为实例变量指定初始值，合法
        str = "hello";
        //定义a实例变量时已经指定了默认值
        //不能为a重新赋值，因此下面赋值语句非法
        a = 9;
    }
    //静态初始化块，可对没有指定初始值的类变量指定初始值
    static{
        //在静态初始化块中为类变量指定初始值，合法
        d = 5.6;
    }
    //构造器中，可对没有指定初始值，有没有在初始化块中
    //指定初始值的实例变量指定初始值
    public FinalVariableTest(){
        //若在初始化块中已经对str指定了初始值
        //那么在构造器中不能对final变量重新赋值，下面的赋值语句非法
        str = "java";
        c = 5;
    }
    public void changeFinal(){
        //普通方法不能为final修饰的成员变量赋值
        d = 1.2;
        //不能在普通方法中为final成员变量指定初始值
        ch = 'a';
    }
    public static void main(String[] args){
        FinalVariableTest ft = new FinalVariableTest();
        System.out.println(ft.a);
        System.out.println(ft.c);
        System.out.println(ft.d);
    }
}

　　final修饰的方法：

　　　　不可被重写

　　final修饰的类：

　　　　不可被继承

　　　　不可变类：创建该类的实例后，该实例的实例变量是不可改变的。Java提供的8个包装类和Java.lang.String类都是不可变类。

　　　　final修饰引用变量时，仅表示这个引用变量类型是不可被重新赋值的，但引用类型变量所指向的实例依然可以改变。若不可变类中包含的成员变量是引用变量，那么

　　　　这个引用变量的对象是可变的，则这个不可变类是失败的不可变类：

//这是一个可变类，因为Person类中的name引用的对象是可以更改的
class Name{
    private String firstName;
    private String lastName;
    public Name(){}
    public Name(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    public String getFirstName(){
        return firstName;
    }
    public void setFirstName(String firstName){
        this.firstName = firstName;
    }
    public String getLastName(){
        return lastName;
    }
    public void setLastName(String lastName){
        this.lastName = lastName;
    }
}

public class Person{
    private final Name name;
    public Person(Name name){
        this.name = name;
    }
    public Name getName(){
        return name;
    }
    public static void main(String[] args){
        Name n = new Name("悟空", "孙");
        Person p = new Person(n);
        //Person对象的name得firstName值为“悟空”
        System.out.println(p.getName().getFirstName());
        //改变Person对象的name的firstName值
        n.setFirstName("八戒");
        //Person对象的name的firstName值被改为“八戒”
        System.out.println(p.getName().getFirstName());
    }
}

　　　　将上面的可变类改为不可变类：

//这是一个可变类，因为Person类中的name引用的对象是可以更改的
class Name{
    private String firstName;
    private String lastName;
    public Name(){}
    public Name(String firstName, String lastName){
        this.firstName = firstName;
        this.lastName = lastName;
    }
    
    public String getFirstName(){
        return firstName;
    }
    public void setFirstName(String firstName){
        this.firstName = firstName;
    }
    public String getLastName(){
        return lastName;
    }
    public void setLastName(String lastName){
        this.lastName = lastName;
    }
}

public class Person{
    private final Name name;
    public Person(Name name){
        //设置name实例变量为临时创建的Name对象，该对象的firstName和lastName
        //与传入的name参数的firstName和lastname相同
        this.name = new Name(name.getFirstName(), name.getLastName());
    }
    public Name getName(){
        //返回一个匿名对象，该对象的firstName和lastName
        //与该对象里的name的firstName和lastName相同
        return new Name(name.getFirstName(), name.getLastName());
    }
    public static void main(String[] args){
        Name n = new Name("悟空", "孙");
        Person p = new Person(n);
        //Person对象的name得firstName值为“悟空”
        System.out.println(p.getName().getFirstName());
        //改变Person对象的name的firstName值
        n.setFirstName("八戒");
        //Person对象的name的firstName值被改为“八戒”
        System.out.println(p.getName().getFirstName());
    }
}

　　　　上面的Person类就是一个不可变类，即使再怎么更改n.setFirstName()和n.setLastName()，也不会改变Person类中name引用的对象的值。

　　缓存实例的不可变类：

class CacheImmutale{
    private static int MAX_SIZE = 10;
    //使用数组来缓存已有的实例
    private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
    //记录缓存实例在缓存中的位置，cache[pos - 1]是最新缓存的实例
    private static int pos = 0;
    private final String name;
    private CacheImmutale(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public static CacheImmutale valueOf(String name){
        //遍历已缓存的对象
        for(int i = 0; i < MAX_SIZE; i++){
            //如果已有相同实例，则直接返回该缓存的实例
            if(cache[i] != null && cache[i].getName().equals(name)){
                return cache[i];
            }
        }
        //若缓存池已满
        if(pos == MAX_SIZE){
            //把缓存的第一个对象覆盖，即把刚刚生成的对象放在缓存池的最开始位置
            cache[0] = new CacheImmutale(name);
            //把pos设为1
            pos = 1;
        }else{
            //把新创建的对象缓存起来，pos加1
            cache[pos++] = new CacheImmutale(name);
        }
        return cache[pos - 1];
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj != null && obj.getClass() == CacheImmutale.class){
            CacheImmutale ci = (CacheImmutale) obj;
            return name.equals(ci.getName());
        }
        return false;
    }
    public int hashCode(){
        return name.hashCode();
    }
}

public class CacheImmutaleTest{
    public static void main(String[] args){
        CacheImmutale c1 = CacheImmutale.valueOf("hello");
        CacheImmutale c2 = CacheImmutale.valueOf("hello");
        //下面代码将输出true
        System.out.println(c1 == c2);
    }
}

 

　　再来看看java.lang.Integer中Integer类构造器和valueOf方法的差异：

public class IntegerCacheTest{
    public static void main(String[] args){
        //生成新的Integer对象
        Integer in1 = new Integer(5);
        //生成新的Integer对象，并缓存该对象
        Integer in2 = Integer.valueOf(5);
        //直接从缓存中取出Integer对象
        Integer in3 = Integer.valueOf(5);
        System.out.println(in1 == in2);//输出false
        System.out.println(in2 == in3);//输出true
        //由于Integer只缓存-128~127之间的值
        //因此200对应的Integer对象没有被缓存
        Integer in4 = Integer.valueOf(200);
        Integer in5 = Integer.valueOf(200);
        System.out.println(in4 == in5);//输出false
    }
}

 抽象类：

　　关键字abstract

　　不可被实例化，即使抽象类中不包含抽象方法

　　抽象类包含成员变量、方法（普通方法和抽象方法）、构造器（不用于创建实例，而是被其子类调用）、初始化块、内部类（接口、枚举）5钟成分。

　　只能被当做父类被子类继承

　　只能定义为抽象类的三种情况：

　　　　1.直接定义了一个抽象方法

　　　　2.继承了一个抽象父类，但是没有完全实现父类中的抽象方法

　　　　3.实现了一个接口，但是没有完全实现接口中的抽象方法

抽象方法：

　　public abstract double abstractClass();//记得最后加上分号

　　必须由不是抽象类的子类提供实现。

　　final修饰符不能和abstract修饰符一起使用

　　static修饰符也不能和abstract修饰符一起使用去修饰某个方法（静态方法属于类本身，可由类名调用，若为abstract则会调用错误，所以不能一起使用）

　　static和abstract可以一起修饰内部类

　　abstract修饰的方法必须被其子类重写才有意义，否则方法永远不会有方法体，所以abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法。

　　模板模式：设计模式之一

abstract class SpeedMeter{
    //转速
    private double turnRate;
    public SpeedMeter(){}
    //把返回车轮半径的方法定义成抽象方法
    public abstract double getRadius();
    public void setTurnRate(double turnRate){
        this.turnRate = turnRate;
    }
    //定义计算速度的通用算法
    public double getSpeed(){
        //速度等于 车轮半径 * 2 * PI * 转速
        return java.lang.Math.PI * 2 * getRadius() * turnRate;
    }
}

public class CarSpeedMeter extends SpeedMeter{
    public double getRadius(){
        return 0.28;
    }
    
    public static void main(String[] args){
        CarSpeedMeter csm = new CarSpeedMeter();
        csm.setTurnRate(15);
        System.out.println(csm.getSpeed());
    }
}

　　　　抽象父类的普通方法getSpeed()依赖于一个抽象方法getRadius()获得车轮半径，从而计算出速度。

　　模板模式在面向对象的软件中经常使用，简单规则：

　　　　1.抽象父类可以只定义需要使用的某些方法，把不能实现部分抽象成抽象方法，留给其子类去实现

　　　　2.父类中可能包含需要调用其他系列方法的方法，这些被调用方法既可以有父类实现，也可以有其子类实现。

接口：

　　接口中不能包含普通方法，所有方法都是抽象方法

　　Java 8对接口进行改进，允许在接口中定义默认方法，默认方法可以提供方法实现。

　　一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

　　修饰符可以是public或省略，若省略public访问控制符，则默认采用包权限访问控制符，即只有在相同包结构下才可以访问该接口。

　　接口不能包含构造器和初始化块定义。

　　接口可以包含成员变量（只能是静态变量）、方法（只能是抽象实例方法、类方法或默认方法）、内部类（包括内部接口、枚举）定义。

　　接口中定义成员变量时，不管是否使用public static final修饰符，接口的成员变量总是使用这三个修饰符来修饰，且接口中没有构造器和初始化块，因此接口中成员变量只能

　　在定义时指定默认值：

　　　　//系统自动为接口里定义的成员变量增加public static final修饰符，下面两行代码定义在接口中：

　　　　int MAX_SIZE = 50;

　　　　public static final int MAX_SIZE = 50;

　　　　上面两行代码结果是完全一样的

　　在接口中系统自动为普通方法增加public abstract修饰符，接口中普通方法不能有方法实现，但是类方法、默认方法可以有方法实现。

接口的继承：

interface interfaceA{
    public static final int PROP_A = 5;
    public abstract void testA();
}

interface interfaceB{
    public static final int PROP_B = 6;
    public abstract void testB();
}

interface interfaceC extends interfaceA, interfaceB{
    public static final int PROP_C = 7;
    public abstract void testC();
}

public class InterfaceExtendsTest{
    public static void main(String[] args){
        System.out.println(interfaceC.PROP_A);
        System.out.println(interfaceC.PROP_B);
        System.out.println(interfaceC.PROP_C);
    }
}

　　实现接口类：

public interface Output{
    //接口里定义的成员变量只能是常量
    public static final int MAX_CACHE_LINE = 50;
    //接口里定义的普通方法只能是public的抽象方法
    public abstract void out();
    public abstract void getData(String msg);
    //在接口中定义默认方法，需要使用default修饰
    default void print(String... msgs){
        for(String msg : msgs){
            System.out.println(msg);
        }
    }
    //在接口中定义默认方法要使用default修饰
    default void test(){
        System.out.println("默认的test()方法");
    }
    //在接口中定义类方法，需要使用static修饰
    static String staticTest(){
        return "接口里的类方法";
    }
}

//定义一个Product接口
interface Product{
    int getProduceTime();
}

//让Printer类实现Output和Product接口
public class Printer implements Output, Product{
    private String[] printData = new String[MAX_CACHE_LINE];
    //用以记录当前需打印的作业数
    private int dataNum = 0;
    
    public void out(){
        //只要还有作业，就继续打印
        while(dataNum > 0){
            System.out.println("打印机打印：" + printData[0]);
            //把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1 , printData, 0, --dataNum);
        }
    }
    
    public void getData(String msg){
        if(dataNum >= MAX_CACHE_LINE){
            System.out.println("输出队列已满，添加失败");
        }else{
            //把打印数据添加到队列里，已保存数据的数量加1
            printData[dataNum++] = msg;
        }
    }
    
    public int getProduceTime(){
        return 45;
    }
    
    public static void main(String[] args){
        //创建一个Printer对象，当成Output使用
        Output o = new Printer();
        o.getData("轻量级Java EE企业应用实战");
        o.getData("疯狂Java讲义");
        o.out();
        o.getData("疯狂Android讲义");
        o.getData("疯狂Ajax讲义");
        o.out();
        //调用Output接口中定义的默认方法
        o.print("孙悟空", "猪八戒", "白骨精");
        o.test();
        //创建一个Printer对象，当成Product使用
        Product p = new Printer();
        System.out.println(p.getProduceTime());
        //所有接口类型的引用变量都可直接赋给Object类型的变量
        Object obj = p;
    }
}

 　　　　实现接口方法时，必须使用public访问控制符。

　　　　接口不能显示继承任何类，但所有接口类型的引用变量都可以直接赋给Object类型的引用变量

　　　　抽象类和接口都不能被实例化

接口和抽象类的区别：

　　接口里只能包含抽象方法、静态方法和默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法

　　接口里只能定义静态常量不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量

　　接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作

　　接口中不能包含初始化块；但抽象类则完全可以包含初始化块

　　一个类只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口弥补Java单继承的不足。

简单工厂模式：

Computer类组合一个输出设备，有两个选择：

　　1.直接让Computer类组合一个Printer实现类

　　2.让Computer类组合一个Output接口

　　简单工厂模式建议采用Output接口，有什么好处看代码：

Output.java接口：

public interface Output{
    //接口里定义的成员变量只能是常量
    public static final int MAX_CACHE_LINE = 50;
    //接口里定义的普通方法只能是public的抽象方法
    public abstract void out();
    public abstract void getData(String msg);
    //在接口中定义默认方法，需要使用default修饰
    default void print(String... msgs){
        for(String msg : msgs){
            System.out.println(msg);
        }
    }
    //在接口中定义默认方法要使用default修饰
    default void test(){
        System.out.println("默认的test()方法");
    }
    //在接口中定义类方法，需要使用static修饰
    static String staticTest(){
        return "接口里的类方法";
    }
}

Printer.java打印类：

//定义一个Product接口
interface Product{
    int getProduceTime();
}

//让Printer类实现Output和Product接口
public class Printer implements Output, Product{
    private String[] printData = new String[MAX_CACHE_LINE];
    //用以记录当前需打印的作业数
    private int dataNum = 0;
    
    public void out(){
        //只要还有作业，就继续打印
        while(dataNum > 0){
            System.out.println("打印机打印：" + printData[0]);
            //把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1 , printData, 0, --dataNum);
        }
    }
    
    public void getData(String msg){
        if(dataNum >= MAX_CACHE_LINE){
            System.out.println("输出队列已满，添加失败");
        }else{
            //把打印数据添加到队列里，已保存数据的数量加1
            printData[dataNum++] = msg;
        }
    }
    
    public int getProduceTime(){
        return 45;
    }
    
    public static void main(String[] args){
        //创建一个Printer对象，当成Output使用
        Output o = new Printer();
        o.getData("轻量级Java EE企业应用实战");
        o.getData("疯狂Java讲义");
        o.out();
        o.getData("疯狂Android讲义");
        o.getData("疯狂Ajax讲义");
        o.out();
        //调用Output接口中定义的默认方法
        o.print("孙悟空", "猪八戒", "白骨精");
        o.test();
        //创建一个Printer对象，当成Product使用
        Product p = new Printer();
        System.out.println(p.getProduceTime());
        //所有接口类型的引用变量都可直接赋给Object类型的变量
        Object obj = p;
    }
}

Computer.java电脑类：

public class Computer{
    private Output out;
    public Computer(Output out){
        this.out = out;
    }
    
    //定义一个模拟获取字符串输入的方法
    public void keyIn(String msg){
        out.getData(msg);
    }
    
    //定义一个模拟打印的方法
    public void print(){
        out.out();
    }
}

OutputFactory.java打印工场类：

public class OutputFactory{
    public Output getOutput(){
        return new Printer();
        //return new BetterPrinter();
    }
    
    public static void main(String[] args){
        OutputFactory of = new OutputFactory();
        Computer c = new Computer(of.getOutput());
        c.keyIn("轻量级Java EE企业应用实战");
        c.keyIn("疯狂Java讲义");
        c.print();
    }
}

将Computer电脑类的打印类换成BetterPrinter：将OutputFactory工厂类的getOutput()方法中return new Printer();换为return new BetterPrinter();

public class BetterPrinter implements Output{
    private String[] printData = new String[MAX_CACHE_LINE * 2];
    //用以记录当前需打印的作业数
    private int dataNum = 0;
    public void out(){
        //只要还有作业，就继续打印
        while(dataNum > 0){
            System.out.println("高速打印机正在打印：" + printData[0]);
            //把作业队列整体前移一位，并将剩下的作业数减1
            System.arraycopy(printData, 1, printData, 0, --dataNum);
        }
    }
    
    public void getData(String msg){
        if(dataNum >= MAX_CACHE_LINE * 2){
            System.out.println("输出队列已满，添加失败");
        }else{
            //把打印数据添加到队列里，以保存数据的数量加1
            printData[dataNum++] = msg;
        }
    }
}

按以上代码来看，简单工厂模式可以随时将实现了Output接口的打印类替换Computer类中的引用out，相当于Computer随时替换打印机。

通过上面方式，即可把所有生成Output对象的逻辑集中在OutputFactory工厂类中管理，而所有需要使用Output对象的类只需要与Output接口耦合，而不是与具体的实现类耦合。

即使系统中有很多类使用了Printer对象，只要OutputFactory类的getOutput()方法生成的Output对象是BetterPrinter对象，则它们全部都会改为使用BetterPrinter对象，而所有程序无需修改，只需要修改OutputFactory工厂类的getOutput()方法实现即可。

命令模式：

　　某个方法需要完成某一个行为，但这个行为的具体实现无法确定，必须等到执行该方法时才可以确定。如：某方法要遍历一个数组的全部元素，但是对这些元素要进行什么

　　操作，需要在调用该方法的时候指定具体的处理行为。即数组中的元素要加、减、乘、除只有在调用遍历数组方法后才能确定。

　　考虑使用一个Command接口定义处理数组元素的方法，用这个方法来封装“处理行为”：

Command.java:

public interface Command{
    //接口里定义的process方法用于封装“处理行为”
    void process(int[] target);
}

PrintCommand.java:

public class PrintCommand implements Command{
    public void process(int[] target){
        for(int tmp : target){
            System.out.println("迭代输出目标数组的元素 ：" + tmp);
        }
    }
}

AddCommand.java:

public class AddCommand implements Command{
    public void process(int[] target){
        int sum = 0;
        for(int tmp : target){
            sum += tmp;
        }
        System.out.println("数组元素的总和是：" + sum);
    }
}

Command.java:

public class CommandTest{
    public static void main(String[] args){
        ProcessArray pa = new ProcessArray();
        int[] target = {3, -4, 6, 4};
        //第一次处理数组，具体处理行为取决于PrintCommand
        pa.process(target, new PrintCommand());
        System.out.println("------------------");
        //第二次处理数组，具体处理行为取决于AddCommand
        pa.process(target, new AddCommand());
    }
}

运行结果：

上述命令模式，通过一个Command接口，定义一个process()方法，该方法接收两个参数，一个

是数组，一个是对数组的操作方法对象，这样就实现了处理行为在调用方法时确定，而我们可以随时可以改变处理行为，因为我们只要把想要的处理行为实现Command接口，并创建一个对象传入process方法就可以了。

 内部类：

　　定义在其他类内部的类被称为内部类。

　　内部类提供了良好的封装，不允许同一个包中的其他类访问该类。

　　内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员。但外部类不能访问内部类的实现细节。

　　匿名内部类适合用于创建仅需要一次使用的类。对于上面介绍的命令模式，当需要传入一个Command对象时，重新专门定义PrintCommand和AddCommand两个实现类可能

　　没有太大的意义，因为这两个实现类可能仅需要使用一次。所以我们可以使用匿名类。

　　内部类比外部类多了三个修饰符：private、protected、static

　　非静态内部类不能拥有静态成员

　　非静态内部类：

　　　　内部类都被作为成员内部类定义，而不是作为局部内部类。成员内部类是一种与成员变量、方法、构造器和初始化块相似的类成员；局部内部类和匿名内部类不是类成员

　　　　成员内部类分为：静态内部类和非静态内部类

public class Cow{
    private double weight;
    //外部类的两个重载的构造器
    public Cow(){}
    public Cow(double weight){
        this.weight = weight;
    }
    
    //定义一个非静态内部类
    private class CowLeg{
        //非静态内部类的两个实例变量
        private double length;
        private String color;
        //非静态内部类的两个重载的构造器
        public CowLeg(){}
        public CowLeg(double length, String color){
            this.length = length;
            this.color = color;
        }
        
        //非静态内部类的实例方法
        public void info(){
            System.out.println("当前牛的颜色是：" + color + "，高：" + length);
            //直接访问外部类的private修饰的成员变量
            System.out.println("本牛腿所在奶牛中：" + weight);
        }
    }
    
    public void test(){
        CowLeg cl = new CowLeg(1.12, "黑白相同");
        cl.info();
    }
    
    public static void main(String[] args){
        Cow cow = new Cow(378.9);
        cow.test();
    }
}

　　　　当外部类成员变量、内部类成员变量与内部类里方法的局部变量同名：

public class DiscernVariable{
    private String prop = "外部类的实例变量";
    private class InClass{
        private String prop = "内部类的实例变量";
        
        public void info(){
            String prop = "局部变量";
            //通过“外部类类名.this.varName”访问外部类实例变量
            System.out.println(DiscernVariable.this.prop);
            
            //通过“this.varName”访问内部类实例的变量
            System.out.println(this.prop);
            
            //直接访问局部变量
            System.out.println(prop);
        }
    }
    
    public void test(){
        InClass in = new InClass();
        in.info();
    }
    
    public static void main(String[] args){
        new DiscernVariable().test();
    }
}

 　　　　外部类访问非静态内部类的成员，必须显示创建非静态内部类对象来调用访问实例成员：

public class Outer{
    private int outProp = 9;
    class Inner{
        private int inProp = 5;
        public void accessOuterProp(){
            //非静态内部类可以直接访问外部类的private成员变量
            System.out.println("外部类的outProp值：" + outProp);
        }
    }
    
    public void accessInnerProp(){
        //外部类不能直接访问非静态内部类的实例变量
        //下面代码出现编辑错误
        //System.out.println("内部类的inProp值：" + inProp);
        //若访问内部类的实例变量，必须显示创建内部类对象
        System.out.println("内部类的inProp值：" + new Inner().inProp);
    }
    
    public static void main(String[] args){
        //执行下面代码，之创建了外部类对象，还未创建内部类对象
        Outer out = new Outer();
        out.accessInnerProp();
    }
}

　　　　非静态内部类对象必须寄生在外部类对象里，所以，若存在一个非静态内部类对象，则一定存在一个被它寄生的外部类对象，但外部类对象存在，非静态内部类对象不一定

　　　　存在。

　　　　静态成员不能访问非静态成员，外部类静态方法、静态代码块不能访问非静态内部类。

　　　　Java不允许在非静态内部类中定义静态成员：　

　　　　　　1、既然是非静态内部类，说明该类只被包含它的那个外部类使用，是专用的，所以定义成静态的没有意义

　　　　　　2、Java的装载过程是先加载类，然后初始化静态元素（Java编译器会使所有的静态元素在使用前被分配好内存空间）然后非静态的只有在使用的时候才分配内存

　　　　　　　  空间，而内部类是作为外部类的成员存在的，所以非静态的内部类必须等到外部类实例化后才会存在，所以非静态内部类的静态成员（如果合法的话）在类加载

　　　　　　　  时并没有被初始化，这与Java的编译原则相违背，但如果内部类是静态内部类，则其中可以定义静态元素。

　　静态内部类：

　　　　静态内部类可包含静态成员、非静态成员。不可访问外部类的实例成员，只能访问外部类成员。

　　　　静态内部类是外部类的类相关，不是外部类的对象相关。当静态内部类存在时，并不存在一个被它寄生的外部类对象。

　　　　外部类依然不能直接访问静态内部类的成员，但可以使用静态内部类的类名作为调用者来访问静态内部类的类成员。

　　　　Java允许在接口中定义内部类，默认使用public static修饰符，即接口中只能是静态内部类。

使用内部类：

 　　定义类的作用就是定义变量、创建实例、作为父类被继承。

　　但使用内部类定义变量和创建实例与外部类有些差异：

　　　　1.在外部类中使用内部类：

　　　　　　不要在外部类的静态成员（包括静态方法和静态初始化块）中使用非静态内部类，因为静态成员不能访问非静态成员

　　　　2.在外部类以外使用非静态内部类：

　　　　　　注意修饰符private、protected、默认、public的作用

class Out{
    //定义一个内部类，不使用访问控制符
    //即只有同一个包中的其他类可访问该内部类
    class In{
        public In(String msg){
            System.out.println(msg);
        }
    }
}

public class CreateInnerInstance{
    public static void main(String[] args){
        Out.In in = new Out().new In("测试信息");
        /*
        上面代码可以改为如下三行代码
        使用“OutterClass.InnerClass”的形式定义内部类变量
        Out.In in;
        创建外部类实例，非静态内部类实例将寄生在该事例中
        Out out = new Out();
        通过外部类实例和new来调用内部类构造器创建非静态内部类实例
        in = out.new In("测试信息");
        */
    }
}

　　　　　　上面代码可以看出非静态内部类的构造器必须使用外部类对象来调用。若需要在外部类以外的地方创建非静态内部类的子类，则需注意上面的规则：非静态内部类的

　　　　　　构造器必须通过其外部类对象来调用。

　　　　　　当创建一个子类时，子类构造器总会调用父类的构造器，因此在创建非静态内部类的子类时，必须保证让子类构造器可以调用非静态内部类的构造器，调用非静态内

　　　　　　部类的构造器时，必须存在一个外部类对象：

public class SubClass extends Out.In{
    //显示定义SubClass的构造器
    public SubClass(Out out){
        //通过传入的Out对象显示调用In的构造器
        out.super("hello");
    }
}

　　　　3.在外部类以外使用静态内部类：

class StaticOut{
    //定义一个静态内部类，不使用访问控制符
    //即同一个包中的其他类可以访问该内部类
    static class StaticIn{
        public StaticIn(){
            System.out.println("静态内部类的构造器");
        }
    }
}

public class CreateStaticInnerInstance{
    public static void main(String[] args){
        StaticOut.StaticIn in = new StaticOut.StaticIn();
        /*
        上面代码可以改为如下两行代码
        使用OuterClass.InnerClass的形式定义内部类变量
        StaticOut.StaticIn in;
        通过new来调用内部类构造器创建静态内部类变量
        in = new StaticOut.StaticIn();
        */
    }
}

　　　　　　在外部类以外创建内部类的子类：

public class StaticSubClass extends StaticOut.StaticIn{
    public StaticSubClass(){
        super();
    }
}

局部内部类：

　　若把内部类放在方法中定义，则这个内部类就是一个局部内部类

　　局部内部类不能在外部类方法以外的地方使用，因此局部内部类也不能使用访问控制符和static修饰符修饰。

public class LocalInnerClass{
    public static void main(String[] args){
        //定义局部内部类
        class InnerBase{
            int a;
        }
        
        //定义局部内部类的子类
        class InnerSub extends InnerBase{
            int b;
        }
        
        //创建局部内部类的对象
        InnerSub is = new InnerSub();
        is.a = 5;
        is.b = 6;
        System.out.println("InnerSub对象的a 和 b 实例变量是：" + is.a + "," + is.b);
    }
}

Java8改进的匿名内部类：

　　匿名内部类适合创建那种只需要一次使用的类。

　　创建匿名内部类时会立即创建一个该类的实例，匿名内部类不能重复使用

　　匿名内部类的两条规则：

　　　　1.匿名内部类不能是抽象类，因为系统创建匿名内部类时，会立即创建匿名内部类的对象

　　　　2.匿名内部类不能定义构造器。由于匿名内部类没有类名，所以无法定义构造器，但是匿名内部类可以定义初始化块，可通过实例初始化块完成构造器需要完成的事情。

　　最常用的匿名内部类的方式是需要创建某个接口类型的对象：

interface Product{
    public double getPrice();
    public String getName();
}

public class AnonymousTest{
    public void test(Product p){
        System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
    }
    
    public static void main(String[] args){
        AnonymousTest ta = new AnonymousTest();
        //调用test()方法时，需要传入一个Product参数
        //此处传入其匿名实现类的实例
        ta.test(new Product(){
            public double getPrice(){
                return 567.8;
            }
            
            public String getName(){
                return "AGP显卡";
            }
        });
    }
}

　　上面的匿名内部类代码等价于下面的代码：

class AnonymousProduct implements Product{
    public double getPrice(){
        return 567.8;
    }
            
    public String getName(){
        return "AGP显卡";
    }
}
ta.test(new AnonymousProduct());

　　匿名内部类通过继承父类来实现：

abstract class Device{
    private String name;
    public abstract double getPrice();
    public Device(){}
    public Device(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
}

public class AnonymousInner{
    public void test(Device d){
        System.out.println("购买了一个" + d.getName() + "，花掉了" + d.getPrice());
    }
    
    public static void main(String[] args){
        AnonymousInner ai = new AnonymousInner();
        //调用有参数的构造器创建Device匿名实现类的对象
        ai.test(new Device("电子示波器"){
            public double getPrice(){
                return 67.8;
            }
        });
        //调用无参数的构造器创建Device匿名实现类的对象
        Device d = new Device(){
            //初始化块
            {
                System.out.println("匿名内部类的初始化块...");
            }
            //实现抽象方法
            public double getPrice(){
                return 56.2;
            }
            //重写父类的实例方法
            public String getName(){
                return "键盘";
            }
        };
        ai.test(d);
    }
}

　　　　当创建匿名内部类时，必须实现接口或抽象父类里的所有抽象方法。若有需要也可以重写父类中的普通方法，如上面代码中的getName。

　　　　Java8之前，要求被局部内部类、匿名内部类访问的局部变量必须使用final修饰，从Java 8开始该限制被取消，但是若局部变量被匿名类访问，那·么该局部变量相当于自

　　　　动使用了final修饰。

Java8 新增的Lambda表达式：

 　　Lambda表达式：

interface Eatable{
    void taste();
}
interface Flyable{
    void fly(String weather);
}
interface Addable{
    int add(int a, int b);
}

public class LambdaQs{
    //调用该方法需要Eatable对象
    public void eat(Eatable e){
        System.out.println(e);
        e.taste();
    }
    
    //调用该方法需要Flyable对象
    public void drive(Flyable f){
        System.out.println("我正在驾驶" + f);
        f.fly("【碧空如洗的晴日】");
    }
    
    //调用该方法需要Addable对象
    public void test(Addable add){
        System.out.println("5与3的和为：" + add.add(5, 3));
    }
    
    public static void main(String[] args){
        LambdaQs lq = new LambdaQs();
        //Lambda表达式的diamante块只有一条语句，可以省略花括号
        lq.eat(()->System.out.println("苹果的味道不错！"));
        //Lambda表达式的形参列表只有一个形参，可以省略圆括号
        lq.drive(weather -> {
            System.out.println("今天天气是：" + weather);
            System.out.println("直升机飞行平稳");
        });
        //Lambda表达式的代码块只有一条语句，可以省略花括号
        //代码块中只有一条语句，即使该表达式需要返回值，也可以省略return关键字
        lq.test((a, b) -> a + b);
    }
}

　　　　从上面语法格式可以看出，Lambda表达式主要作用就是代替匿名内部类的繁琐语法，它由三部分组成：

　　　　　　1.形参列表：形参列表允许省略形参类型，若形参列表中只有一个参数，甚至连形参列表中的圆括号也可以省略。

　　　　　　2.箭头（->）：必须通过英文中划线和大于符号组成

　　　　　　3.代码块：若代码块中只包含一条语句，Lambda表达式允许省略代码块的花括号。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式

　　　　　　   需要返回值，而它的代码块中仅有一条省略了return的语句，Lambda表达式会自动返回这条语句的值。代码块返回一个目标对象。

Lambda表达式与函数式接口：

　　Lambda表达式的类型，也被称为“目标类型（target type）”，Lambda表达式的目标类型必须是“函数式接口（functional interface）”。

　　函数式接口：只包含一个抽象方法的接口。函数式接口可以包含多个默认方法，类方法，但只能声明一个抽象方法。

　　Java 8专门提供了@FunctionalInterface注解，用于告诉编译器——检查该接口必须是函数式接口，否则编译器会报错。

　　Lambda表达式的两个限制：

　　　　1.Lambda表达式的目标类型必须是明确的函数式接口

　　　　2.Lambda表达式只能为函数式接口创建对象。Lambda表达式只能实现一个方法，因此只能为只有一个抽象方法的接口（函数式接口）创建对象。

　　为了保证Lambda表达式的目标类型是一个明确的函数式接口，有如下三种方式：

　　　　1.将Lambda表达式赋值给函数式接口类型的变量

　　　　2.将Lambda表达式作为函数式接口类型的参数传给某个方法中的形参

　　　　3.使用函数式接口对Lambda表达式进行强制类型转换

　　需要说明的是，同样的Lambda表达式的目标类型完全可能是变化的——唯一的要求是：Lambda表达式实现的匿名方法与目标类型（函数式接口）中唯一的抽象方法有相同的

　　形参列表。

　　Java8 在 java.util.function包下定义了大量的函数式接口，典型有以下4类接口：

　　　　1.XxxFunction

　　　　2.XxxConsumer

　　　　3.XxxxPredicate

　　　　4.XxxSupplier

枚举类：

　　Java 5新增了一个关键字enum（与class、interface关键字地位相同），用来定义枚举类。

　　枚举类是特殊的类，可以有自己的成员变量、方法、可有一个或多个接口，可有自己的构造器。

　　枚举类和普通类的区别：

　　　　1.枚举类可实现一个或多个接口，使用enum定义的枚举类默认继承java.lang.Enum类，而不是Object类，因此枚举类不能显示继承其他父类。其中java.lang.Enum类实现

　　　　   了java.lang.Serializable和java.lang.Comparable两个接口

　　　　2.使用enum定义、非抽象的枚举类默认使用final修饰，因此枚举类不能派生子类。

　　　　3.枚举类的构造器只能使用private修饰，若省略了控制器的访问控制符，则默认使用private修饰。

　　　　4.枚举类的所有实例必须在枚举类的第一行显式列出，否则该枚举类永远不能产生实例。列出的这些实例系统会自动添加public static final修饰。

　　枚举类默认提供values()方法，可很方便的遍历所有的枚举值。

public class EnumTest{
    public void judge(SeasonEnum s){
        //switch语句里的表达式可以是枚举值
        switch(s){
            case SPRING:
            System.out.println("春暖花开，正好踏青");
            break;
            case SUMMER:
            System.out.println("夏日炎炎，适合游泳");
            break;
            case FALL:
            System.out.println("秋高气爽，进步及时");
            break;
            case WINTER:
            System.out.println("冬日雪飘，围炉赏雪");
            break;
        }
    }
    
    public static void main(String[] args){
        //枚举类默认有一个values()方法，返回该枚举类的所有实例
        for(SeasonEnum s : SeasonEnum.values()){
            System.out.println(s);
        }
        //使用枚举实例时，可通过EnumClass.variable形式来访问
        new EnumTest().judge(SeasonEnum.SPRING);
    }
}

java.lang.Enum类中的方法：

　　1.int compareTo(E o)：比较顺序，同一个枚举实例只能与相同类型的枚举实例进行比较。若该枚举对象位于指定枚举对象之后，返回正整数；若该枚举对象位于指定枚举对象

　　   之前，则返回负整数，否则返回零

　　2.String name()：返回此实例的名称。

　　3.int ordinal()：返回枚举值在枚举类中的索引值（就是枚举值在枚举声明中的位置，第一个枚举值的索引值为零）

　　4.String toString()：返回枚举常量的名称，与name()方法相似，但toString()方法更常用。

　　5.public static<T extends Enum<T>> T valueOf(Class<T> enumType, String name)：这是一个静态方法，用于返回指定枚举类中指定名称的枚举值。名称必须与在该枚举类中

　　　声明枚举值时所用的标识符完全匹配，不允许使用额外的空白字符。

枚举类的成员变量、方法和构造器：

public enum Gender{
    MALE,FEMALE;
    //定义一个public修饰的实例变量
    public String name;
}

public class GenderTest{
    public static void main(String[] args){
        //通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender g = Enum.valueOf(Gender.class, "FEMALE");
        //直接为枚举值的name实例变量赋值
        g.name = "女";
        //直接访问枚举值的name实例变量
        System.out.println(g + "代表：" + g.name );
    }
}

public enum Gender{
    MALE,FEMALE;
    //定义一个public修饰的实例变量
    private String name;
    
    public void setName(String name){
        switch(this){
            case MALE:
            if(name.equals("男")){
                this.name = name;
            }else{
                System.out.println("参数错误");
                return;
            }
            break;
            
            case FEMALE:
            if(name.equals("女")){
                this.name = name;
            }else{
                System.out.println("参数错误");
                return;
            }
            break;
        }
    }
    
    public String getName(){
        return this.name;
    }
}

public class GenderTest{
    public static void main(String[] args){
        //通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender g = Gender.valueOf("FEMALE");
        //直接为枚举值的name实例变量赋值
        g.setName("女");
        //直接访问枚举值的name实例变量
        System.out.println(g + "代表：" + g.getName());
        //此时设置name值时会提示参数错误
        g.setName("男");
        System.out.println(g + "代表：" + g.getName());
    }
}

public enum Gender{
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男"),FEMALE("女");
    //定义一个public修饰的实例变量
    private final String name;
    //枚举类的构造器只能使用private修饰
    private Gender(String name){
        this.name = name;
    }
    
    public String getName(){
        return this.name;
    }
}

public class GenderTest{
    public static void main(String[] args){
        //通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender nv = Gender.valueOf("FEMALE");
        System.out.println(nv + "代表：" + nv.getName());
        
        Gender nan = Gender.valueOf("MALE");
        System.out.println(nan + "代表：" + nan.getName());
    }
}

最后一次的代码设计才合理，这样将枚举类设计成不可变类。

实现接口的枚举类：

public enum Gender implements GenderDesc{
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男"),FEMALE("女");
    //定义一个public修饰的实例变量
    private final String name;
    //枚举类的构造器只能使用private修饰
    private Gender(String name){
        this.name = name;
    }
    
    public String getName(){
        return this.name;
    }
    
    //增加下面的info()方法，实现GenderDesc接口必须实现的方法

    public void info(){
        System.out.println("这是一个用于定义性别的枚举类");
    }    
}

public interface GenderDesc{
    void info();
}

public class GenderTest{
    public static void main(String[] args){
        //通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender nv = Gender.valueOf("FEMALE");
        System.out.println(nv + "代表：" + nv.getName());
        nv.info();
        
        Gender nan = Gender.valueOf("MALE");
        System.out.println(nan + "代表：" + nan.getName());
        nan.info();
    }
}

这样每个枚举值在调用info()方法都有相同的行为方式，若想要不同的枚举值在调用该方法呈现不同的行为方式：

public enum Gender implements GenderDesc{
    //此处的枚举值必须调用对应的构造器来创建
    MALE("男")
    //花括号部分实际上是一个类体部分
    {
        public void info(){
            System.out.println("这个枚举值代表男性");
        }
    },//这里有个逗号
    FEMALE("女")
    {
        public void info(){
            System.out.println("这个枚举值代表女性");
        }
    };//这里有个分号
    //定义一个public修饰的实例变量
    private final String name;
    //枚举类的构造器只能使用private修饰
    private Gender(String name){
        this.name = name;
    }
    
    public String getName(){
        return this.name;
    }    
}

public interface GenderDesc{
    void info();
}

public class GenderTest{
    public static void main(String[] args){
        //通过Enum的valueOf()方法来获取指定枚举类的枚举值
        Gender nv = Gender.valueOf("FEMALE");
        System.out.println(nv + "代表：" + nv.getName());
        nv.info();
        
        Gender nan = Gender.valueOf("MALE");
        System.out.println(nan + "代表：" + nan.getName());
        nan.info();
    }
}

上面代码中MALE和FEMALE两个枚举值后紧跟一对花括号，这两个枚举值时Gender枚举类的两个匿名子类实例。因为在编译的时候会生成Gender.class、Gender$1.class和

Gender$2.class三个文件。证明，MALE和FEMALE实际上使Gender匿名子类的实例，而不是Gender类的实例。

包含抽象方法的枚举类：

public enum Operation{
    PLUS{
        public double eval(double x, double y){
            return x + y;
        }
    },//这里有逗号
    
    MINUS{
        public double eval(double x, double y){
            return x - y;
        }
    },//这里有逗号
    
    TIMES{
        public double eval(double x, double y){
            return x * y;
        }
    },//这里有逗号
    
    DIVIDE{
        public double eval(double x, double y){
            return x / y;
        }
    };
    
    //为枚举类定义一个抽象方法
    //这个抽象方法由不同的枚举值提供不同的实现
    public abstract double eval(double x, double y);
    public static void main(String[] args){
        System.out.println(Operation.PLUS.eval(3, 4));
        System.out.println(Operation.MINUS.eval(3, 4));
        System.out.println(Operation.TIMES.eval(3, 4));
        System.out.println(Operation.DIVIDE.eval(3, 4));
    }
}

枚举类定义抽象方法时不能使用abstract关键字将枚举类定义成抽象类（因为系统自动会为它添加abstract关键字），但因为枚举类需要显示创建枚举值，而不是作为父类，所以定义每个枚举值时必须为抽象方法提供实现，否则将出现编译错误。

对象与垃圾回收：

　　在垃圾回收机制回收任何对象之前，总会先调用它的finalize()方法，该方法可能使该对象重新复活（让一个引用变量重新引用该对象），从而导致垃圾回收机制取消回收。

强制垃圾回收：

　　1.调用System类的gc()静态方法：System.gc()

　　2.调用Runtime对象的gc()实例方法：Runtime.getRuntime().gc()

public class GcTest{
    public static void main(String[] args){
        for(int i = 0; i < 4; i++){
            new GcTest();
            //下面两行diamante的作用完全相同，强制系统进行垃圾回收
            //System.gc();
            Runtime.getRuntime().gc();
        }
    }
    
    public void finalize(){
        System.out.println("系统正在清理GcTest对象的资源...");
    }
}

finalize()方法：Java提供的默认机制清理对象资源方法

　　该方法定义在Object类中的实例方法，方法原型：

　　　　protected void finalize() throws Throwable//Throwable可抛出任何异常

　　finalize()方法四个特点：

　　　　1.永远不要主动调用某个对象的finalize()方法，该方法应交给垃圾回收机制调用

　　　　2.finalize()方法何时被调用，是否被调用具有不确定性，不要把finalize()方法当成一定会被执行的方法

　　　　3.当JVM执行可恢复对象的finalize()方法时，可能使该对象或系统中其他对象重新变成可达状态

　　　　4.当JVM执行finalize()方法时出现异常时，垃圾回收机制不会报告异常，程序继续执行。

GitHub网站代码链接：https://github.com/lanshanxiao/-Java-/tree/master/%E7%AC%AC%E5%85%AD%E7%AB%A0