一、包

包（package）是组织类的一种方式.

使用包的主要目的是保证类的唯一性.
例如.你在代码中写一个 Test 类，然后你同事也可能写了一个 Test 类. 出现了两个同名的类，就会冲突，导致代码不能编译通过.

1.1 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如

public static void main(String[] args) {
    java.util.Date date = new java.util.Date();
    System.out.println(date.getTime());
}

我们可以使用 java.util.Date这种方式引入java.util这个包中的Date类.

但是这种写法比较麻烦，我们可以使用import语句导入包.

import java.util.Date;
public class Test {
	public static void main(String[] args) {
		Date date = new Date();
		// 得到一个毫秒级别的时间戳
		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 都匹配

在这种情况下，需要使用完整的类名指定是那个Date类.

import java.util.*;
import java.sql.*;
public class Test {
	public static void main(String[] args) {
		java.util.Date date = new java.util.Date();
		System.out.println(date.getTime());
	}
}

注意事项： import和 C++ 的#include差别很大. C++ 必须#include来引入其它文件内容，但是 Java 不需要. import只是为了写代码的时候更加方便. import更类似于 c++ 的namespace和using.

1.2 import static 静态导入

使用import static可以导入包中的静态方法和字段.

import static java.lang.System.*;
public class Test {
	public static void main(String[] args) {
		out.println("hello");
	}
}

使用这种方式可以更加方便的写一些代码

import static java.lang.Math.*;
public class Test {
	public static void main(String[] args) {
		double x = 30;
		double y = 40;
		// 静态导入的方式写起来更方便一些.
		// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
		double result = sqrt(pow(x, 2) + pow(y, 2));
		System.out.println(result);
	}
}

但是不太推荐这样使用，不能一眼看出代码中方法的来源。

1.3 将类放在包中

基本规则

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.

• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu.www ).

• 包名要和代码路径相匹配. 例如创建 com.it.demo1 的包, 那么会存在一个对应的路径 com/it/demo1 来存储代码.

• 如果一个类没有 package 语句, 则该类被放到一个默认包中.

1.4 包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.

如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使
用.

下面的代码给了一个示例. Demo1 和 Demo2 是同一个包中, Test 是其他包中.

Demo1.java

package com.bit.demo;
public class Demo1 {
	int value = 0;
}

Demo2.java

package com.bit.demo;
public class Demo2 {
	public static void Main(String[] args) {
		Demo1 demo = new Demo1();
		System.out.println(demo.value);
	}
}

// 执行结果, 能够访问到 value 变量
0

Test.java

import com.bit.demo.Demo1;
public class Test {
	public static void main(String[] args) {
		Demo1 demo = new Demo1();
		System.out.println(demo.value);
	}
}

// 编译出错
Error:(6, 32) java: value在com.bit.demo.Demo1中不是公共的; 无法从外部程序包中对其进行访问

1.5 常见的系统包

1. lang包：系统常用基础类(String、Object)，此包从JDK1.1后自动导入。
2. lang.reflect包：Java反射编程包。
3. net包：进行网络编程开发包。
4. sql包：进行数据库开发的支持包。
5. util包：是Java提供的工具包（集合类）非常重要。
6. io包：I / O编程开发包。

二、继承

2.1 为什么使用继承

代码中创建的类，主要是为了抽象现实中的一些事物（包含属性和方法）.

有时候，客观事物之间就存在一些关联关系，那么在表示成类和对象的时候也会存在一定的关联.

例如，设计一个类表示动物.

class Animal{
    public String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}

class Cat{
    public String name;

    public Cat(String name) {
        this.name = name;
    }
    
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}

class Bird{
    public String name;

    public Bird(String name) {
        this.name = name;
    }

    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
    
    public void fly() {
        System.out.println(this.name + "会飞. 起飞🛫");
    }
}

这个代码，我们可以发现存在很多冗余代码.

仔细分析，我们发现Animal和Cat以及Bird这几个类中存在一定的关联关系：

• 这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
• 这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
• 从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类， 来达到代码重用的效果，减少代码冗余.

此时，Animal 这样被继承的类， 我们称为 父类 , 基类 或 超类，对于像 Cat 和 Bird 这样的类， 我们称为 子类, 派生类.
和现实中的儿子继承父亲的财产类似， 子类也会继承父类的字段和方法， 以达到代码重用的效果.

2.2 语法规则

基本语法 及 注意事项

class 子类 extends 父类{

}

1. 使用 extends 指定父类.
2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
3. 子类会继承父类的所有 public 的字段和方法.
4. 对于父类的 private 的字段和方法, 子类中是无法访问的.
5. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

对于上面的代码，可以使用继承进行改进.
此时我们让 Cat 和 Bird 继承自 Animal 类， 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.

class Animal{
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}

class Cat extends Animal{
    public Cat(String name) {
        //super调用父类的构造方法
        //子类需要先帮父类构造方法
        super(name);
    }
}

class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "会飞. 起飞🛫");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Cat cat = new Cat("小猫咪");
        cat.eat("🐟");
        Bird bird = new Bird("八哥");
        bird.eat("果子");
    }
}

extends 英文愿意为 “扩展”，而我们所写的类的继承，也可以理解为基于父类进行代码上的 “扩展”.

例如. 我们写的 Bird 类，是在 Animal 的基础上扩展出了 fly 方法.

如果我们把 name 改成 private，那么此时子类就不能访问了.
private 私有属性还是不变.

class Bird extends Animal {
	public Bird(String name) {
		super(name);
	}
	public void fly() {
		System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
	}
}

// 编译出错
Error:(19, 32) java: name 在 Animal 中是 private 访问控制

2.3 protected 关键字

刚才我们发现，把字段设为 private，子类不能访问. 但设成 public，又违背了我们 “封装” 的初衷.

两全其美的方法就是 protected 关键字.

1. 对于类的调用者来说，protected 修饰的字段和方法是不能访问的.
2. 对于类的 子类 和 同一个包的其它类 来说，protected 修饰的字段和方法是可以访问的.

// Animal.java
public class Animal {
	protected String name;
	public Animal(String name) {
		this.name = name;
	}
	public void eat(String food) {
		System.out.println(this.name + "正在吃" + food);
	}
}
																
// Bird.java
public class Bird extends Animal {
	public Bird(String name) {
		super(name);
	}
	public void fly() {
		// 对于父类的 protected 字段, 子类可以正确访问
		System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
	}
}

// Test.java 和 Animal.java 不在同一个 包 之中了.
public class Test {
	public static void main(String[] args) {
		Animal animal = new Animal("小动物");
		System.out.println(animal.name); // 此时编译出错, 无法访问 name
	}
}

小结：Java 中对于字段和方法共有四种访问权限.

• private：类内部能访问，类外部不能访问.
• 默认（也叫包访问权限）：类内部能访问，同一个包中的类可以访问，其它类不能访问.
• protected：类内部能访问，子类和同一个包中的类可以访问，其它类不能访问.
• public：都能调用访问.

什么时候用哪种呢？

我们希望类能做到 “封装”，隐藏内部实现细节，只暴露必要的信息给类的调用者，就使用 private.

对于出现子类继承父类的情况，定义的数据只在目前这个包下使用，就使用 protected.

使用 public 的时候，就是权限最宽的时候.

2.4 更复杂的继承关系

刚才我们的例子中，只涉及到 Animal, Cat 和 Bird 三种类.
但是如果情况更复杂一些呢?

针对 Cat 这种情况，我们可能还需要更多的猫~

这时候使用继承方式来表示，就会涉及到更复杂的体系.

// Animal.java
public Animal {
	...
}

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

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

// OrangeCat.java
public Orange extends ChineseGardenCat {
	...
}

......

这样的继承方式称为多层继承，即子类还可以进一步再派生出新的子类.

时刻牢记，我们写的类是现实事物的抽象.
而我们在公司遇到的项目往往业务比较复杂，可能会涉及到一系列复杂的概念，都需要我们使用代码来表示，所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.

但即便如此，我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多，就需要考虑对代码进行重构了.

如果想在语法上进行限制继承，就可以使用 final 关键字.

2.5 final 关键字

曾经我们使用 final 关键字，用于修饰一个变量或者字段的时候，表示常量，是不能被修改的.

fianl int a = 10;
a = 20; //编译出错.

final 关键字也能修饰类，此时表示被修饰的类不能被继承.

final public class Animal{
	...
}

public class Bird extends Animal{
	...
}

//编译出错.
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

final 关键字的功能是 限制 类被继承，“限制” 这件事情意味着 “不灵活”.

在编程中，灵活往往不见得是一件好事. 灵活可能意味着更容易出错.
用 final 修饰的类被继承的时候，就会编译报错，此时就可以提示我们这样的继承是有悖这个类设计的初衷的.

例如，我们平时使用的 String 字符串类，就是用 final 修饰的，不能被继承.

三、组合

和继承类似，组合也是一种表达类之间关系的方式，也能够达到代码重用的效果.

例如表示一个学校：

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

组合并没有涉及到特殊的语法，例如extends关键字，仅仅是将一个类的实例作为另一个类的字段.

这是我们设计类的一种常用方式之一.

3.1 组合和继承的区别

• 对于组合来说，我们可以理解为包含。看代码意思是一个学校 “包含” 多个学生和老师.
• 对于继承来说，是一种延续 + 扩展。从父类继承来的数据，给多个子类使用，减少代码冗余；子类还能在这个基础上，扩展出自己独有的功能.