Java基础语法：9.面线对象编程（1）

在学习面向对象编程中主要掌握以下概念包、继承、组合、多态、抽象类、接口。

一、包
1、包的概念及作用
包(package) 是组织类的一种方式，使用包的主要目的是保证类的唯一性。
2、导入包中的类

import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
//或者使用java.util.Date date = new java.util.Date();可以不用import语句导入（不推荐）
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
//因此使用import语句时尽量显式的指定要导入的类名。

注意：import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using。
3、包的访问权限控制
我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用。
4、常见的系统包
a、java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
b、java.lang.reflect:java 反射编程包;
c、java.net:进行网络编程开发包。
d、java.sql:进行数据库开发的支持包。
e、java.util:是java提供的工具程序包。(集合类等) 非常重要
f、java.io:I/O编程开发包。

二·、继承
1、什么是继承？
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
2、语法规则
基本语法

class 子类 extends 父类 {
}

注意：
使用 extends 指定父类.
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
子类会继承父类的所有 public 的字段和方法.
对于父类的 private 的字段和方法, 子类中是无法访问的.
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用。
3、protected 关键字
对于类的调用者来说, protected 修饰的字段和方法是不能访问的。
对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的。
4、Java 中对于字段和方法共有四种访问权限
private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问。
什么时候下用哪一种呢?
我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用public.另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 写代码时需要根据类提供的字段方法到底给 “谁” 使用来给出访问权限。
5、 更复杂的继承关系
a、多层继承

// Animal.java
public Animal {
...
}
// Cat.java
public Cat extends Animal {
...
}
// ChineseGardenCat.java
public ChineseGardenCat extends Cat {
...
}
// OrangeCat.java
public OrangeCat extends ChineseGardenCat {
...
}
......

这样的继承方式称为多层继承, 即子类还可以进一步的再派生出新的子类。
我们写的类是现实事物的抽象. 而真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.如果想从语法上进行限制继承, 就可以使用 final 关键字。
b、final 关键字
我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改)，final 关键字也能修饰类, 此时表示被修饰的类就不能被继承。

final public class Animal {
...
}
public class Bird extends Animal {
...
}//此时运行这个代码，就会报错。

final 关键字的功能是 限制 类被继承
“限制” 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.使用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的。我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承。

三、组合
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果
例如：

public class Student {
...
}
public class Teacher {
...
}
public class School {
public Student[] students;
public Teacher[] teachers;
}

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.这是我们设计类的一种常用方式之一。
组合表示 has - a 语义
在刚才的例子中, 我们可以理解成一个学校中 “包含” 若干学生和教师.
继承表示 is - a 语义
在上面的 “动物和猫” 的例子中, 我们可以理解成一只猫也 “是” 一种动物。