面向对象编程OOP(3)之抽象类、接口和内部类

1、抽象类

包含抽象方法的类，必须设计成抽象类！

1.1 抽象方法

只声明了方法，同时使用了abstract修饰，没有方法体！必须要子类来重写！

1.2 抽象类的使用要点

    1.    通过抽象类，可以避免子类设计的随意性。

    2.    有抽象方法的类只能定义能抽象类

    3.    抽象类不能实例化，及不能用new来实例化抽象类。

    4.    抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

    5.    抽象类只能用来继承。

    6.    抽象方法必须被子类实现。

普通类：只有具体实现！

 抽象类：具体实现和规范(抽象方法) 都有！

 接口：只有规范！

2、接口

2.1 为什么需要接口?接口和抽象类的区别?

       接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

       抽象类还提供某些具体实现，接口不提供任何实现，接口中所有方法都是抽象方法。接口是完全面向规范的，规定了一批类具有的公共方法规范。

       从接口的实现者角度看，接口定义了可以向外部提供的服务。

       从接口的调用者角度看，接口定义了实现者能提供那些服务。

       接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的系统之间模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

2.2 接口的定义

2.2.1 格式

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {

常量定义

方法定义

}

2.2.2 接口的特性

访问修饰符：只能是public或默认。

接口名：和类名采用相同命名机制

extends：接口可以多继承

常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

2.3 接口的使用要点

    1.    子类通过implements来实现接口中的规范

    2.    接口不能创建实例，但是可用于声明引用变量类型。

    3.    一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

    4.    接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。

    5.    常量必然是：public static final。  我们不加这些修饰符，也是这样。

    6.    方法必然是：public abstract。  我们不加这些修饰符，也是这样。

    7.    接口完全支持多继承。和类的继承类似，子接口扩展某个父接口，将会获得父接口中所定义的一切。

 

3、内部类

一般情况，我们把类定义成独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类。

3.1 内部类的作用

    1.    内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。

    2.    内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

 内部类的使用场合：

    由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类在只为所在外部类提供服务的情况下优先使用。

3.2 内部类的分类

3.2.1 成员内部类

（可以使用private、proteted、public任意进行修饰。 类文件：外部类$内部类.class）

a)    非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

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

ii.    非静态内部类可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。

iii.    非静态内部类不能有静态方法、静态属性、静态初始化块。

iv.    静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

v.    成员变量访问要点：

    1.    内部类里方法的局部变量：变量名

    2.    内部类属性：this.变量名

    3.    外部类属性：外部类名.this.变量名

vi.    内部类的访问：

    1.    外部类中定义内部类：  new InnerClass()

    2.    外部类以外的地方使用非静态内部类： 
 Outer.inner  varname = OuterObject.new Inner()

Face.Nose nose =  new Face().new Nose();
Face f2 = new Face();
Face.Nose nose2 = f2.new Nose();

b) 静态内部类

i.    定义方式：

static  class   ClassName {
    //类体
}

ii.    使用要点：

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

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

    3.    在外部类的外面创建静态内部类：

Face.TestStaticInner  aInner = new  Face.TestStaticInner();

 3.2.2 匿名内部类

    适合那种只需要使用一次的类。比如：键盘监听操作等等。语法：

new  父类构造器(实参类表) 实现接口 () {
    //匿名内部类类体！
}

3.2.3 局部内部类

定义在方法内部。作用域只限于本方法。用的非常少。