Java入门——继承和多态（上）

包

包是组织类的一种方式. 使用包的主要目的是保证类的唯一性.

例如, 你在代码中写了一个 Test 类. 然后你的舍友也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过.

导入包中的类

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

public class Test {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 都匹配

在这种情况下需要使用完整的类名

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 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);}
}

将类放到包中

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.csdn.demo1 ).
包名要和代码路径相匹配. 例如创建 com.csdn.demo1 的包, 那么会存在一个对应的路径 com/csdn/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

1) 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2) 在弹出的对话框中输入包名, 例如 com.csdn.demo1

3) 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

4) 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

5) 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

包的访问权限控制

我们已经了解了类中的 public 和 private.

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

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

Demo1.java

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

Demo2.java

package com.csdn.demo; public class Demo2 { public static void Main(String[] args) { Demo1 demo = new Demo1(); System.out.println(demo.value); } 
} 
// 执行结果, 能够访问到 value 变量

Test.java

import com.csdn.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.csdn.demo.Demo1中不是公共的; 无法从外部程序包中对其进行访问

常见的系统包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reﬂect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

继承

语法规则

基本语法

class 子类 extends 父类 { }

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

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 Test { public static void main(String[] args) { Cat cat = new Cat("小黑"); cat.eat("猫粮"); Bird bird = new Bird("圆圆"); bird.fly(); } 
}

extends 英文原意指 "扩展". 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 "扩展". 例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 ﬂy 方法.

如果我们把 name 改成 private, 那么此时子类就不能访问了.

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

protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷. 两全其美的办法就是 protected 关键字.

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

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

private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问

更复杂的继承关系

刚才我们的例子中, 只涉及到 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 { ... 
} 
......

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

时刻牢记, 我们写的类是现实事物的抽象.

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

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

如果想从语法上进行限制继承, 就可以使用 ﬁnal 关键字

ﬁnal 关键字

曾经我们学习过 ﬁnal 关键字, 修饰一个变量或者字段的时候, 表示常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错

ﬁnal 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

final public class Animal { ... 
} public class Bird extends Animal { ... 
} // 编译出错 
Error:(3, 27) java: 无法从最终com.csdn.Animal进行继承

ﬁnal 关键字的功能是限制类被继承 "限制" 这件事情意味着 "不灵活".

在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.

是用 ﬁnal 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.