java知识点拾遗（深入面向对象）-CFANZ编程社区

抽象类

抽象方法：

使用abstract修饰的方法，没有方法体，只有声明。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类：

包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限定子类的设计，使子类之间更加通用。

要点：

有抽象方法的类只能定义成抽象类。
抽象类不能实例化。
抽象类可以包含属性，方法，构造方法，但构造方法不能用来new实例，只能用来被子类调用。
抽象类只能用来被继承。
抽象方法必须被子类实现。

接口

定义接口的说明：

访问修饰符只能是public或默认。
接口名和类名采用相同命名机制。
接口可以多重继承。
接口中的属性只能是常量。总是public static final修饰（不写也是）。
接口中的方法只能是public abstract。省略也是public abstract。

要点：

接口中所有的方法都是抽象的。
接口的多态只体现在其定义的抽象方法上，不体现在实现类的非抽象方法上。
接口不能创建实例，但可以声明引用变量类型。
一个类实现了接口，必须实现接口中的所有方法，并且这些方法只能是public的。
JDK1.7之前，接口中只能包含静态常量，抽象方法，不能有普通属性，构造方法，普通方法。
JDK1.8之后，接口中可包含普通的静态方法。

内部类

成员内部类

可以使用private，default，protected，public进行修饰。
类文件形如：OuterClass$InnerClass.class

java知识点拾遗（深入面向对象）_类对象

分为：

a 非静态内部类

1) 非静态内部类必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

2) 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。

3) 非静态内部类不能有静态方法，静态属性和静态初始化块。

4) 外部类的静态方法，静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义的变量，创建的实例。

5) 成员变量访问要点：
  ~ 内部类里方法的局部变量：变量名。
  ~ 内部类属性：this.变量名。
  ~ 外部类属性：外部类名.this.变量名。

测试非静态内部类代码：

public class TestInnerClass {
  public static void main(String[] args) {
    // 创建内部类对象。
    // 内部类对象是依托外部类对象的。有内部类对象必然已经存在外部类对象。
    Outer.Inner inner = new Outer().new Inner();
    inner.show();
  }
}

class Outer {
  private int age = 10;

  public void testouter() {

  }

  class Inner {
    int age = 20;

    public void show() {
      int age = 30;

      System.out.println("外部类的成员变量age：" + Outer.this.age);
      System.out.println("内部类的成员变量age：" + this.age);
      System.out.println("局部变量age：" + age);
    }
  }
}

b 静态内部类

使用要点：
1) 当一个静态内部类对象存在，并一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。

2) 静态内部类看作外部类的一个静态成员。因此，外部类的方法中可以通过：“静态内部类.名字”的方式访问静态内部类的静态成员，通过" new 静态内部类() "访问静态内部类的实例。

测试静态内部类代码：

public class TestStaticInnerClass {
  public static void main(String[] args) {
    Outer2.Inner2 inner = new Outer2.Inner2();
    inner.show();
  }
}

class Outer2 {

  static class Inner2 {
    public void show() {
      System.out.println("显示一下");
    }
  }
}

c 匿名内部类
适合只需要使用一次的类。必须借助父类或者接口来实现。
形式如下：

new 父类构造器（）{
  ...
}
或者
new 实现接口() {
  ...
}

匿名内部类没有访问修饰符。
匿名内部类没有构造方法（没有类名）。

匿名内部类测试代码：

public class TestAnony {

  public static void invoke(AnonymouseClass a) {
    a.show();
  }

  public static void main(String[] args) {
    invoke(new AnonymouseClass() {

      @Override
      public void show() {
        System.out.println("实现匿名内部类");
      }
    });
  }
}

interface AnonymouseClass {
  void show();
}

d 局部内部类
定义在方法内部，作用域只限于本方法。
局部内部类测试代码：

public class Test2 {
  public void show() {
    // 作用域只限于本方法
    class Inner {
      public void foo() {
        System.out.println("局部内部类");
      }
    }

    new Inner().foo();
  }

  public static void main(String[] args) {
    new Test2().show();
  }
}