第七章面对对象核心技术

 封装的特点：

    
  
    
 只能通过规定的方法访问数据。
    
 隐藏类的实例细节，方便修改和实现。
    
 实现封装的具体步骤如下：
    
  
    
 修改属性的可见性来限制对属性的访问，一般设为 private。
    
 为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
    
 在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

 public class PeopleTest {

    
     public static void main(String[] args) {
    
     // 创建Student类对象
    
     People stuPeople = new Student("王丽丽", 23, "女", "410521198902145589", "00001", "计算机应用与技术");
    
     System.out.println("----------------学生信息---------------------");
    
     System.out.println(stuPeople);
    
     // 创建Teacher类对象
    
     People teaPeople = new Teacher("张文", 30, "男", "410521198203128847", 5, "计算机应用与技术");
    
     System.out.println("----------------教师信息----------------------");
    
     System.out.println(teaPeople);
    
     }
    
 }

 使用继承的注意点：

    
 子类一般比父类包含更多的属性和方法。
    
 父类中的 private 成员在子类中是不可见的，因此在子类中不能直接使用它们。
    
 父类和其子类间必须存在“是一个”即“is-a”的关系，否则不能用继承。但也并不是所有符合“is-a”关系的都应该用继承。例如，正方形是一个矩形，但不能让正方形类来继承矩形类，因为正方形不能从矩形扩展得到任何东西。正确的继承关系是正方形类继承图形类。
    
 Java 只允许单一继承（即一个子类只能有一个直接父类），C++ 可以多重继承（即一个子类有多个直接父类）。

 继承的优缺点

    
 在面向对象语言中，继承是必不可少的、非常优秀的语言机制，它有如下优点：
    
 实现代码共享，减少创建类的工作量，使子类可以拥有父类的方法和属性。
    
 提高代码维护性和可重用性。
    
 提高代码的可扩展性，更好的实现父类的方法。
    
  
    
 自然界的所有事物都是优点和缺点并存的，继承的缺点如下：
    
 继承是侵入性的。只要继承，就必须拥有父类的属性和方法。
    
 降低代码灵活性。子类拥有父类的属性和方法后多了些约束。
    
 增强代码耦合性（开发项目的原则为高内聚低耦合）。当父类的常量、变量和方法被修改时，需要考虑子类的修改，有可能会导致大段的代码需要重构。

 在重写方法时，需要遵循下面的规则：

    
 参数列表必须完全与被重写的方法参数列表相同。
    
 返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
    
 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
    
 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。
    
  
    
 另外还要注意以下几条：
    
 重写的方法可以使用 @Override 注解来标识。
    
 父类的成员方法只能被它的子类重写。
    
 声明为 final 的方法不能被重写。
    
 声明为 static 的方法不能被重写，但是能够再次声明。
    
 构造方法不能被重写。
    
 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
    
 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
    
 如果不能继承一个方法，则不能重写这个方法。

  
    
 对于int f( ) { }和void( ) { }两个方法，如果这样调用int result = f();，系统可以识别是调用返回值类型为 int 的方法，但 Java 调用方法时可以忽略方法返回值，如果采用如下方法来调用f();，你能判断是调用哪个方法吗？如果你尚且不能判断，那么 Java 系统也会糊涂。在编程过程中有一条重要规则就是不要让系统糊涂，系统一糊涂，肯定就是你错了。因此，Java 里不能用方法返回值类型作为区分方法重载的依据。

    Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。

 1）向上转型

    
 父类引用指向子类对象为向上转型，语法格式如下：
    
 fatherClass obj = new sonClass();
    
 其中，fatherClass 是父类名称或接口名称，
    
 obj 是创建的对象，sonClass 是子类名称。

 2）向下转型

    
 与向上转型相反，子类对象指向父类引用为向下转型，语法格式如下：
    
 sonClass obj = (sonClass) fatherClass;
    
 其中，fatherClass 是父类名称，obj 是创建的对象，sonClass 是子类名称。

 1）声明一个 class 类的对象，判断 obj 是否为 class 类的实例对象（很普遍的一种用法），如以下代码：

    
 Integer integer = new Integer(1);
    
 System.out.println(integer instanceof  Integer);    // true
    
  
    
 2）声明一个 class 接口实现类的对象 obj，判断 obj 是否为 class 接口实现类的实例对象，如以下代码：
    
 Java 集合中的 List 接口有个典型实现类 ArrayList。
    
 public class ArrayList<E> extends AbstractList<E>
    
     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    
  
    
 所以我们可以用 instanceof 运算符判断 ArrayList 类的对象是否属于 List 接口的实例，如果是返回 true，否则返回 false。
    
 ArrayList arrayList = new ArrayList();
    
 System.out.println(arrayList instanceof List);    // true
    
  
    
 或者反过来也是返回 true
    
 List list = new ArrayList();
    
 System.out.println(list instanceof ArrayList);    // true
    
  
    
 3）obj 是 class 类的直接或间接子类
    
 我们新建一个父类 Person.class，代码如下：
    
 public class Person {
    
 }
    
  
    
 创建 Person 的子类 Man，代码如下：
    
 public class Man extends Person {
    
 }

 包导入

    
 如果使用不同包中的其它类，需要使用该类的全名（包名+类名）。代码如下：
    
 example.Test test = new example.Test();
    
  
    
 其中，example 是包名，Test 是包中的类名，test 是类的对象。
    
  
    
 为了简化编程，Java 引入了 import 关键字，import 可以向某个 Java 文件中导入指定包层次下的某个类或全部类。import 语句位于 package 语句之后，类定义之前。一个 Java 源文件只能包含一个 package 语句，但可以包含多个 import 语句。
    
  
    
 使用 import 导入单个类的语法格式如下：
    
 import 包名+类名;
    
  
    
 上面语句用于直接导入指定类，例如导入前面的 example.Test 类，代码如下：
    
 import example.Test;
    
  
    
 使用 import 语句导入指定包下全部类的用法按如下：
    
 import example.*;
    
  
    
 上面 import 语句中的星号（*）只能代表类，不能代表包，表明导入 example 包下的所有类。

 系统包

    
 Java SE 提供了一些系统包，其中包含了 Java 开发中常用的基础类。在 Java 语言中，开发人员可以自定义包，也可以使用系统包，常用的系统包如表 1 所示。
    
  
    
 表1 Java中常用的系统包
    
 包	说明
    
 java.lang	Java 的核心类库，包含运行 Java 程序必不可少的系统类，如基本数据类型、基本数学函数、
    
 字符串处理、异常处理和线程类等，系统默认加载这个包
    
 java.io	Java 语言的标准输入/输出类库，如基本输入/输出流、文件输入/输出、过滤输入/输出流等
    
 java.util	包含如处理时间的 Date 类，处理动态数组的 Vector 类，以及 Stack 和 HashTable 类
    
 java.awt	构建图形用户界面（GUI）的类库，低级绘图操作 Graphics 类、图形界面组件和布局管理
    
 （如 Checkbox 类、Container 类、LayoutManger 接口等），以及用户界面交互控制和事
    
 件响应（如 Event 类）
    
 java.awt.image	处理和操纵来自网上的图片的 Java 工具类库
    
 java.wat.peer	很少在程序中直接用到，使得同一个 Java 程序在不同的软硬件平台上运行
    
 java.net	实现网络功能的类库有 Socket 类、ServerSocket 类
    
 java.lang.reflect	提供用于反射对象的工具
    
 java.util.zip	实现文件压缩功能
    
 java.awt.datatransfer	处理数据传输的工具类，包括剪贴板、字符串发送器等
    
 java.sql	实现 JDBC 的类库
    
 java.rmi	提供远程连接与载入的支持
    
 java. security	提供安全性方面的有关支持
    
 读者现在只需对这些包有一个大致印象即可，随着教程后面的介绍，读者会逐渐熟悉它们的用法。

 final 修饰变量

    
 final 修饰的变量即成为常量，只能赋值一次，但是 final 所修饰局部变量和成员变量有所不同。
    
 final 修饰的局部变量必须使用之前被赋值一次才能使用。
    
 final 修饰的成员变量在声明时没有赋值的叫“空白 final 变量”。空白 final 变量必须在构造方法或静态代码块中初始化。
    
 注意：final 修饰的变量不能被赋值这种说法是错误的，严格的说法是，final 修饰的变量不可被改变，一旦获得了初始值，该 final 变量的值就不能被重新赋值。

 final修饰方法

    
 final 修饰的方法不可被重写，如果出于某些原因，不希望子类重写父类的某个方法，则可以使用 final 修饰该方法。
    
  
    
 Java 提供的 Object 类里就有一个 final 方法 getClass()，因为 Java 不希望任何类重写这个方法，所以使用 final 把这个方法密封起来。但对于该类提供的 toString() 和 equals() 方法，都允许子类重写，因此没有使用 final 修饰它们。
    
  
    
 下面程序试图重写 final 方法，将会引发编译错误。
    
 public class FinalMethodTest {
    
     public final void test() {
    
     }
    
 }
    
 class Sub extends FinalMethodTest {
    
     // 下面方法定义将出现编译错误，不能重写final方法
    
     public void test() {
    
     }
    
 }
    
 上面程序中父类是 FinalMethodTest，该类里定义的 test() 方法是一个 final 方法，如果其子类试图重写该方法，将会引发编译错误。
    
  
    
 对于一个 private 方法，因为它仅在当前类中可见，其子类无法访问该方法，所以子类无法重写该方法——如果子类中定义一个与父类 private 方法有相同方法名、相同形参列表、相同返回值类型的方法，也不是方法重写，只是重新定义了一个新方法。因此，即使使用 final 修饰一个 private 访问权限的方法，依然可以在其子类中定义与该方法具有相同方法名、相同形参列表、相同返回值类型的方法。
    
  
    
 下面程序示范了如何在子类中“重写”父类的 private final 方法。
    
 public class PrivateFinalMethodTest {
    
     private final void test() {
    
     }
    
 }
    
 class Sub extends PrivateFinalMethodTest {
    
     // 下面的方法定义不会出现问题
    
     public void test() {
    
     }
    
 }
    
 上面程序没有任何问题，虽然子类和父类同样包含了同名的 void test() 方法，但子类并不是重写父类的方法，因此即使父类的 void test() 方法使用了 final 修饰，子类中依然可以定义 void test() 方法。

 final修饰类

    
 final 修饰的类不能被继承。当子类继承父类时，将可以访问到父类内部数据，并可通过重写父类方法来改变父类方法的实现细节，这可能导致一些不安全的因素。为了保证某个类不可被继承，则可以使用 final 修饰这个类。
    
  
    
 下面代码示范了 final 修饰的类不可被继承。
    
 final class SuperClass {
    
 }
    
 class SubClass extends SuperClass {    //编译错误
    
 }
    
 因为 SuperClass 类是一个 final 类，而 SubClass 试图继承 SuperClass 类，这将会引起编译错误。

 final 修饰符使用总结

    
 1. final 修饰类中的变量
    
 表示该变量一旦被初始化便不可改变，这里不可改变的意思对基本类型变量来说是其值不可变，而对对象引用类型变量来说其引用不可再变。其初始化可以在两个地方：一是其定义处，也就是说在 final 变量定义时直接给其赋值；二是在构造方法中。这两个地方只能选其一，要么在定义时给值，要么在构造方法中给值，不能同时既在定义时赋值，又在构造方法中赋予另外的值。
    
 2. final 修饰类中的方法
    
 说明这种方法提供的功能已经满足当前要求，不需要进行扩展，并且也不允许任何从此类继承的类来重写这种方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。在声明类中，一个 final 方法只被实现一次。
    
 3. final 修饰类
    
 表示该类是无法被任何其他类继承的，意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。
    
  
    
 对于 final 类中的成员，可以定义其为 final，也可以不是 final。而对于方法，由于所属类为 final 的关系，自然也就成了 final 型。也可以明确地给 final 类中的方法加上一个 final，这显然没有意义。

 在类内部可定义成员变量和方法，且在类内部也可以定义另一个类。如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类（或称为嵌套类），而类 Outer 则称为外部类（或称为宿主类）。

    
  
    
 内部类可以很好地实现隐藏，一般的非内部类是不允许有 private 与 protected 权限的，但内部类可以。内部类拥有外部类的所有元素的访问权限。
    
  
    
 内部类可以分为：实例内部类、静态内部类和成员内部类，每种内部类都有它特定的一些特点，本节先详细介绍一些和内部类相关的知识。
    
  
    
 在类 A 中定义类 B，那么类 B 就是内部类，也称为嵌套类，相对而言，类 A 就是外部类。如果有多层嵌套，例如类 A 中有内部类 B，而类 B 中还有内部类 C，那么通常将最外层的类称为顶层类（或者顶级类）。

 有关内部类的说明有如下几点。

    
 外部类只有两种访问级别：public 和默认；内部类则有 4 种访问级别：public、protected、 private 和默认。
    
 在外部类中可以直接通过内部类的类名访问内部类。
    
 InnerClass ic = new InnerClass();    // InnerClass为内部类的类名
    
 在外部类以外的其他类中则需要通过内部类的完整类名访问内部类。
    
 Test.InnerClass ti = newTest().new InnerClass();    // Test.innerClass是内部类的完整类名
    
 内部类与外部类不能重名。
    
  
    
 提示：内部类的很多访问规则可以参考变量和方法。另外使用内部类可以使程序结构变得紧凑，但是却在一定程度上破坏了 Java 面向对象的思想。

 局部内部类是指在一个方法中定义的内部类。示例代码如下：

    
 纯文本复制
    
 public class Test {
    
     public void method() {
    
     class Inner {
    
         // 局部内部类
    
     }
    
     }
    
 }
    
 局部内部类有如下特点：
    
  
    
 1）局部内部类与局部变量一样，不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
    
  
    
 2）局部内部类只在当前方法中有效。
    
 3）局部内部类中不能定义 static 成员。
    
  
    
 4）局部内部类中还可以包含内部类，但是这些内部类也不能使用访问控制修饰符（public、private 和 protected）和 static 修饰符修饰。
    
  
    
 5）在局部内部类中可以访问外部类的所有成员。
    
  
    
 6）在局部内部类中只可以访问当前方法中 final 类型的参数与变量。如果方法中的成员与外部类中的成员同名，则可以使用 <OuterClassName>.this.<MemberName> 的形式访问外部类中的成员。

 匿名类是指没有类名的内部类，必须在创建时使用 new 语句来声明类。其语法形式如下：

    
  
    
 new <类或接口>() {
    
     // 类的主体
    
 };

  
    
 1）匿名类和局部内部类一样，可以访问外部类的所有成员。如果匿名类位于一个方法中，则匿名类只能访问方法中 final 类型的局部变量和参数。
    
 public static void main(String[] args) {
    
     int a = 10;
    
     final int b = 10;
    
     Out anonyInter = new Out() {
    
     void show() {
    
         // System.out.println("调用了匿名类的 show() 方法"+a);    // 编译出错
    
         System.out.println("调用了匿名类的 show() 方法"+b);    // 编译通过
    
     }
    
     };
    
     anonyInter.show();
    
 }
    
 从 Java 8 开始添加了 Effectively final 功能，在 Java 8 及以后的版本中代码第 6 行不会出现编译错误，详情可点击《Java8新特性之Effectively final》进行学习。
    
  
    
 2）匿名类中允许使用非静态代码块进行成员初始化操作。
    
 Out anonyInter = new Out() {
    
     int i; {    // 非静态代码块
    
     i = 10;    //成员初始化
    
     }
    
     public void show() {
    
     System.out.println("调用了匿名类的 show() 方法"+i);
    
     }
    
 };
    
 3）匿名类的非静态代码块会在父类的构造方法之后被执行。

 静态内部类是指使用 static 修饰的内部类。示例代码如下：

    
 public class Outer {
    
     static class Inner {
    
     // 静态内部类
    
     }
    
 }
    
 上述示例中的 Inner 类就是静态内部类。静态内部类有如下特点。
    
  
    
 1）在创建静态内部类的实例时，不需要创建外部类的实例。
    
 public class Outer {
    
     static class Inner {
    
     }
    
 }
    
 class OtherClass {
    
     Outer.Inner oi = new Outer.Inner();
    
 }
    
 2）静态内部类中可以定义静态成员和实例成员。外部类以外的其他类需要通过完整的类名访问静态内部类中的静态成员，如果要访问静态内部类中的实例成员，则需要通过静态内部类的实例。
    
 public class Outer {
    
     static class Inner {
    
     int a = 0;    // 实例变量a
    
     static int b = 0;    // 静态变量 b
    
     }
    
 }
    
 class OtherClass {
    
     Outer.Inner oi = new Outer.Inner();
    
     int a2 = oi.a;    // 访问实例成员
    
     int b2 = Outer.Inner.b;    // 访问静态成员
    
 }
    
 3）静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则需要通过外部类的实例去访问。
    
 纯文本复制
    
 public class Outer {
    
     int a = 0;    // 实例变量
    
     static int b = 0;    // 静态变量
    
     static class Inner {
    
     Outer o = new Outer;
    
     int a2 = o.a;    // 访问实例变量
    
     int b2 = b;    // 访问静态变量
    
     }
    
 }

 实例内部类是指没有用 static 修饰的内部类，有的地方也称为非静态内部类。示例代码如下：

    
 public class Outer {
    
     class Inner {
    
     // 实例内部类
    
     }
    
 }
    
 上述示例中的 Inner 类就是实例内部类。实例内部类有如下特点。
    
  
    
 1）在外部类的静态方法和外部类以外的其他类中，必须通过外部类的实例创建内部类的实例。
    
 public class Outer {
    
     class Inner1 {
    
     }
    
     Inner1 i = new Inner1(); // 不需要创建外部类实例
    
     public void method1() {
    
     Inner1 i = new Inner1(); // 不需要创建外部类实例
    
     }
    
     public static void method2() {
    
     Inner1 i = new Outer().new inner1(); // 需要创建外部类实例
    
     }
    
     class Inner2 {
    
     Inner1 i = new Inner1(); // 不需要创建外部类实例
    
     }
    
 }
    
 class OtherClass {
    
     Outer.Inner i = new Outer().new Inner(); // 需要创建外部类实例
    
 }
    
 2）在实例内部类中，可以访问外部类的所有成员。
    
 public class Outer {
    
     public int a = 100;
    
     static int b = 100;
    
     final int c = 100;
    
     private int d = 100;
    
     public String method1() {
    
     return "实例方法1";
    
     }
    
     public static String method2() {
    
     return "静态方法2";
    
     }
    
     class Inner {
    
     int a2 = a + 1; // 访问public的a
    
     int b2 = b + 1; // 访问static的b
    
     int c2 = c + 1; // 访问final的c
    
     int d2 = d + 1; // 访问private的d
    
     String str1 = method1(); // 访问实例方法method1
    
     String str2 = method2(); // 访问静态方法method2
    
     }
    
     public static void main(String[] args) {
    
     Inner i = new Outer().new Inner(); // 创建内部类实例
    
     System.out.println(i.a2); // 输出101
    
     System.out.println(i.b2); // 输出101
    
     System.out.println(i.c2); // 输出101
    
     System.out.println(i.d2); // 输出101
    
     System.out.println(i.str1); // 输出实例方法1
    
     System.out.println(i.str2); // 输出静态方法2
    
     }
    
 }
    
 提示：如果有多层嵌套，则内部类可以访问所有外部类的成员。
    
  
    
 3）在外部类中不能直接访问内部类的成员，而必须通过内部类的实例去访问。如果类 A 包含内部类 B，类 B 中包含内部类 C，则在类 A 中不能直接访问类 C，而应该通过类 B 的实例去访问类 C。
    
  
    
 4）外部类实例与内部类实例是一对多的关系，也就是说一个内部类实例只对应一个外部类实例，而一个外部类实例则可以对应多个内部类实例。
    
  
    
 如果实例内部类 B 与外部类 A 包含有同名的成员 t，则在类 B 中 t 和 this.t 都表示 B 中的成员 t，而 A.this.t 表示 A 中的成员 t。
    
 public class Outer {
    
     int a = 10;
    
     class Inner {
    
     int a = 20;
    
     int b1 = a;
    
     int b2 = this.a;
    
     int b3 = Outer.this.a;
    
     }
    
     public static void main(String[] args) {
    
     Inner i = new Outer().new Inner();
    
     System.out.println(i.b1); // 输出20
    
     System.out.println(i.b2); // 输出20
    
     System.out.println(i.b3); // 输出10
    
     }
    
 }
    
 5）在实例内部类中不能定义 static 成员，除非同时使用 final 和 static 修饰。