Java学习7 高级类特性

抽象类

• 关键字abstract修饰
• 抽象类不能实例化
• 一个抽象方法一定在抽象类中，但抽象类可以没有抽象方法
• 子类继承抽象类，可以不全部实现抽象父类中的抽象方法，但此时该子类也只能声明为抽象类
• 父类不是抽象类，但在子类中可以添加抽象方法，但子类需声明为抽象类
• 抽象类中可以声明为static属性和方法
• 抽象类的作用包括：①代码重用；②规划

// 抽象类：一个抽象方法一定在抽象类中，但抽象类可以没有抽象方法
public abstract class Animal {
    public abstract void eat();
}

public class Person extends Animal {
    @Override
    public void eat() {
        System.out.println("Eat cooked food.");
    }
}

public abstract class Animal {
    public abstract void eat();
}

/*
 * 子类继承抽象类，可以不全部实现抽象父类中的抽象方法，但此时该子类也只能声明为抽象类
 */
public abstract class Person extends Animal {
}

public class Student extends Person {
    /* 
     * @see com.github.rayluoluo.snippet.s10testabstract.Animal#eat()
     */
    @Override
    public void eat() {
        System.out.println("Eat at school");
    }

    public static void main(String[] args) {
        Animal animal = new Student();
        animal.eat();
    }
}

接口（interface)

• 接口是抽象方法和常量值的定义的集合。
• 接口只包含常量和方法的定义，而没有变量和方法的实现。
• 常量必须是public static final，方法必须是public abstract，修饰符可以部分或全部省略。
• 接口可以被多重实现（一个类可以实现多个接口）
• 接口可以继承其它的接口，并添加新的属性和抽象方法。接口间支持多重继承。

/**
 * 接口：常量必须是public static final，方法必须是public abstract，修饰符可以部分或全部省略。
 */
public interface Interface {
    // 声明常量：public static final 可缺省
    String text = "'public static final' is omitted.";

    // 声明方法：public abstract 可缺省
    void foo();
}

public class Implementation implements Interface {
    // 子类实现父类抽象方法
    public void foo() {
        System.out.println("Interface.foo(): 'public abstract' is omitted.");
    }
}

嵌套类（Nested Class）

• 两种：
  
  • 静态嵌套类(Static Nested Class)：使用static修饰的嵌套类
  • 内部类(Inner Class)：非static的嵌套类
    
    • 普通的内部类：在Java类中、方法或语句块的外部所定义的非static类；
    • 局部内部类（Local Class）：定义在方法或语句块中的类；
    • 匿名内部类（Anonymous Class）：定义在方法或语句块中，该类没有名字、只能在所在位置使用一次。
• 内部类：
  
  • 在内部类中可以直接访问外层类中的成员属性和成员方法，即使是private的；
  • 内部类可以声明为抽象类，因此可以被其它内部类继承；也可以声明为final的；
    
    • 外部类的访问控制有public和默认；而内部类除了可以声明为public、默认之外，还可以声明为private或protected。
    • 内部类中出现变量命名冲突时，可以使用内部类对象的特殊属性”<外部类名>.this”来访问其所依赖外部类对象的成员。
    • 编译后，内部类与外部类一样，也会生成字节码文件；内部类字节码名称为：OuterName$InnerName.class

扩展阅读：幕后英雄的用武之地——浅谈Java内部类的四个应用场景

public class Foo {
    private String name = "Outer";

    // 内部嵌套类也可以声明为private或protected
    private class InnerClass {
        private String name = "Inner";

        public void printName(String name) {
            System.out.println("Arg  Name:" + name);
            System.out.println("InnerName:" + this.name);
            System.out.println("OuterName:" + Foo.this.name);
        }
    };

    public static void main(String[] args) {
        Foo foo = new Foo();
        // 内部类对象的new方法
        Foo.InnerClass inner = foo.new InnerClass();
        inner.printName("Argument");
    }
}

/*Result*/
Arg  Name:Argument
InnerName:Inner
OuterName:Outer

• 匿名内部类（Anonymous Class）
  匿名内部类也就是没有名字的内部类。
  正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。如可以快速实现Thread类和Runnable接口的run()方法。
  但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

参考：java中的匿名内部类总结

枚举类型

• 自动继承了java.lang.Enum类
• 与equals方法结合使用
• 与switch语句结合使用

public class TestEnum {
    // 定义枚举
    public enum Week {
        MON, TUE, WED, THU, FRI, SAT, SUN
    }

    // 与equals结合使用
    public void work(Week day) {
        if (day.equals(Week.SAT)) {
            System.out.println("星期六，购物!");
        }
    }

    // 与switch/case结合使用
    public void work2(Week day) {
        switch (day) {
        case MON:
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("工作日，去上班");
            break;
        case SAT:
            System.out.println("星期六，去购物");
            break;
        case SUN:
            System.out.println("星期天，去礼拜");
            break;
        default:
            System.out.println("ERROR PARAMS");
            break;
        }
    }
}