第5关：抽象类
任务描述
本关任务：掌握抽象类的定义及用法。
相关知识
为了完成本关任务，你需要掌握：1.抽象类的概念；2.如何定义抽象类。
抽象类的概念
前面对类的继承进行了初步的讲解。通过继承，可以从原有的类派生出新的类。原有的类称为基类或父类，而新的类则称为派生类或子类。通过这种机制，派生出的新的类不仅可以保留原有的类的功能，而且还可以拥有更多的功能。
除了上述的机制之外，Java也可以创建一种类专门用来当作父类，这种类称为“抽象类”。抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。
如何定义抽象类
抽象类的定义规则：
- 抽象类和抽象方法都必须用abstract关键字来修饰；
- 抽象类不能被实例化，也就是不能用new关键字去产生对象；
- 抽象方法只需声明，而不需实现；
- 含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
抽象类的定义格式：
abstract class 类名称 // 定义抽象类
{
声明数据成员;
访问权限 返回值的数据类型 方法名称（参数...）//定义一般方法
{
...
}
abstract 返回值的数据类型 方法名称（参数...）;
//定义抽象方法，在抽象方法里，没有定义方法体
}
注意：
- 在抽象类定义的语法中，方法的定义可分为两种：一种是一般的方法，它和先前介绍过的方法没有什么两样；另一种是“抽象方法”，它是以
abstract关键字为开头的方法，此方法只声明了返回值的数据类型、方法名称与所需的参数，但没有定义方法体。 - 抽象类也可以像普通类一样，有构造方法、一般方法、属性，更重要的是还可以有一些抽象方法，留给子类去实现，而且在抽象类中声明构造方法后，在子类中必须明确调用。
编程要求
根据提示，在右侧编辑器补充代码：
声明一个名为Person的抽象类，在Person类中声明了三个属性name、age和occupation和一个抽象方法talk()；
声明一个Student类和一个Worker类，都继承自Person类，添加带有三个参数的构造方法；
分别实例化Student类与Worker类的对象，分别调用各自类中被复写的talk()方法打印输出信息；
具体输出要求请看测试说明。
测试说明
测试输入： 无
预期输出：
学生——>姓名：张三，年龄：20，职业：学生！
工人——>姓名：李四，年龄：30，职业：工人！
实现代码
package case5;
public class abstractTest {
public static void main(String[] args) {
/********* begin *********/
// 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
Student student = new Student("张三",20,"学生");
Worker worker = new Worker("李四",30,"工人");
// 分别调用各自类中被复写的talk()方法 打印信息。
System.out.println(student.talk());
System.out.println(worker.talk());
/********* end *********/
}
}
// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
/********* begin *********/
String name;
int age;
String occupation;
//abstract void talk(){ //此处错误，talk()方法返回值类型是String，同上一关一样。
//} //并且定义抽象方法，没有方法体，即不加这一对{}。
public abstract String talk();
/********* end *********/
}
// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {
/********* begin *********/
public Student(String name,int age,String occupation){
this.name = name;
this.age = age;
this.occupation = occupation;
}
public String talk(){ //复写父类g抽象类方法时，去掉abstract修饰，其余的修饰完全相同
// System.out.println("学生->姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！");//此处直接返回String类型，而不写输出语句。
return "学生——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！";
}
/********* end *********/
}
// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
/********* begin *********/
public Worker(String name,int age,String occupation){
this.name = name;
this.age = age;
this.occupation = occupation;
}
public String talk(){
return "工人——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！";
}
/********* end *********/
}
实验分析
- talk()方法同第4关一样，返回值类型是String类型，是一句话
- 构造方法没有返回值
- 子类复写父类的抽象方法时，去掉abstract修饰
- 抽象方法没有方法体，不用写{}。
第6关：final关键字的理解与使用
任务描述
本关任务：理解并能正确使用final关键字。
相关知识
为了完成本关任务，你需要掌握：1.final关键字的使用； 2.final关键字修饰类、成员变量和成员方法。
final关键字的使用
在Java中声明类、属性和方法时，可使用关键字final来修饰。
- final标记的类不能被继承；
- final标记的方法不能被子类复写；
- final标记的变量（成员变量或局部变量）即为常量，只能赋值一次。
final关键字修饰类、成员变量和成员方法
1.final类
final用来修饰一个类，意味着该类成为不能被继承的最终类。出于安全性的原因和效率上的考虑，有时候需要防止一个类被继承。例如，Java类库中的String类，它对编译器和解释器的正常运行有着很重要的作用，不能轻易改变它，因此把它修饰为final类，使它不能被继承，这就保证了String类的惟一性。同时，如果你认为一个类的定义己经很完美，不需要再生成它的子类，这时也应把它修饰为final类。
定义一个final类的格式如下:
final class ClassName{
...
}
注意：声明为final的类隐含地声明了该类的所有方法为final方法。
下面的结论是成立的：声明一个类既为abstract，又为final是非法的，因为抽象类必须被子类继承来实现它的抽象方法。下面是一个final类的例子:
final class A{
...
}
class B extends A{//错误！不能继承A
...
}
2.final修饰成员变量
变量被声明为final后，成为常值变量(即常量)，一旦被通过某种方式初始化或赋值，即不能再被修改。通常static与final一起使用来指定一个类常量。例如:
static final int SUNDAY=0;
把final变量用大写字母和下划线来表示，这是一种编码规定。
3.final修饰成员方法
用final修饰的方法为最终方法，不能再被子类重写，可以被重载。
尽管方法重写是Java非常有力的特征，但有时却需要避免这种情况的发生。为了不允许一个方法被重写，在方法的声明中指定final属性即可。例如:
class A{
final void method(){}
}
class B extends A{//定义A类的一个子类B
void method(){}//错误，method()不能被重写
}
该例中，因为method()方法在A中被声明为final，所以不能在子类B中被重写。如果这样做，将导致编译错误。
方法被声明为final有时可以提高性能：编译器可以自由地内联调用它们，因为它“知道”它们不会被子类重写。
编程要求
根据提示，在右侧编辑器Begin-End处补充代码:
仔细阅读代码，在右侧编辑器中调整代码使程序能正确编译运行;
具体输出要求请看测试说明。
测试说明
测试输入：无
预期输出：
speedlimit=120
running safely with 100kmph
running safely with 100kmph
实现代码
package case6;
public class finalTest {
public static void main(String args[]) {
Bike1 obj = new Bike1();
obj.run();
Honda honda = new Honda();
honda.run();
Yamaha yamaha = new Yamaha();
yamaha.run();
}
}
//不可以修改 final 变量的值
// final方法,不可以重写
//// 不可以扩展 final 类
//请在此添加你的代码
/********** Begin *********/
class Bike1 {
/*final */int speedlimit = 90; //去掉final就好了
void run() {
speedlimit = 120;
System.out.println("speedlimit=120");
}
}
class Bike2 {
/*final */void run() {
System.out.println("running");
}
}
class Honda extends Bike2 {
void run() {
System.out.println("running safely with 100kmph");
}
}
/*final */class Bike3 {
}
class Yamaha extends Bike3 {
void run() {
System.out.println("running safely with 100kmph");
}
}
/********** End **********/
第7关：接口
任务描述
本关任务：掌握接口相关的知识。
相关知识
为了完成本关任务，你需要掌握：
1.接口的定义；
2.接口的实现；
3.接口的扩展。
接口的定义
接口（interface）是Java所提供的另一种重要技术，它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同：
- 接口里的数据成员必须初始化，且数据成员均为常量；
- 接口里的方法必须全部声明为
abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。
接口定义的语法如下：
interface 接口名称 // 定义抽象类
{
final 数据类型 成员名称 = 常量； //数据成员必须赋初值
abstract 返回值的数据类型 方法名称（参数...）;
//抽象方法，注意在抽象方法里，没有定义方法主体
}
接口与一般类一样，本身也具有数据成员与方法，但数据成员一定要赋初值，且此值将不能再更改，方法也必须是“抽象方法”。也正因为方法必须是抽象方法，而没有一般的方法，所以抽象方法声明的关键字abstract是可以省略的。
相同的情况也发生在数据成员身上，因数据成员必须赋初值，且此值不能再被更改，所以声明数据成员的关键字final也可省略。事实上只要记得：
接口里的“抽象方法”只要做声明即可，而不用定义其处理的方式；
数据成员必须赋初值。
接口的实现
在Java中接口是用于实现多继承的一种机制，也是Java设计中最重要的一个环节，每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中的常量。
既然接口里只有抽象方法，它只要声明而不用定义处理方式，于是自然可以联想到接口也没有办法像一般类一样，再用它来创建对象。利用接口打造新的类的过程，称之为接口的实现（implementation）。
接口实现的语法：
class 类名称 implements 接口A,接口B //接口的实现
{
...
}
接口的扩展
接口是Java实现多继承的一种机制，一个类只能继承一个父类，但如果需要一个类继承多个抽象方法的话，就明显无法实现，所以就出现了接口的概念。一个类只可以继承一个父类，但却可以实现多个接口。
接口与一般类一样，均可通过扩展的技术来派生出新的接口。原来的接口称为基本接口或父接口，派生出的接口称为派生接口或子接口。通过这种机制，派生接口不仅可以保留父接口的成员，同时也可加入新的成员以满足实际的需要。
同样的，接口的扩展（或继承）也是通过关键字extends来实现的。有趣的是，一个接口可以继承多个接口，这点与类的继承有所不同。
接口扩展的语法：
interface 子接口名称 extends 父接口1,父接口2...
{
...
}
编程要求
根据提示，在右侧编辑器补充代码：
声明一Person接口，并在里面声明三个常量：name、age、occupation，并分别赋值；
声明一Student类，此类实现Person接口，并复写Person中的talk()方法；
实例化一Student的对象s，并调用talk()方法，打印信息；
具体输出要求请看测试说明。
测试说明
测试输入：无
预期输出：
学生——>姓名：张三，年龄：18，职业：学生！
实现代码
package case7;
public class interfaceTest {
public static void main(String[] args) {
// 实例化一Student的对象s，并调用talk()方法，打印信息
/********* begin *********/
Student s = new Student();
System.out.println(s.talk());
/********* end *********/
}
}
// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
/********* begin *********/
final String name = "张三";
final int age = 18;
String occupation = "学生"; //final可以省略，因为接口中的属性都是常量，不可以更改。
public abstract String talk(); //抽象方法没有方法体。这条语句中abstract也可以省略
/********* end *********/
}
// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
/********* begin *********/
public String talk(){
return "学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！";
}
/********* end *********/
}
第8关：什么是多态，怎么使用多态
任务描述
本关任务：掌握对象的多态性。
相关知识
为了完成本关任务，你需要掌握：1.什么是多态；2.多态的实现条件；3.多态的实现形式。
什么是多态
所谓多态：就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：
多态性是对象多种表现形式的体现。
现实中，比如我们按下F1键这个动作：
如果当前在Flash界面下弹出的就是AS 3的帮助文档；
如果当前在Word下弹出的就是Word帮助；
在Windows下弹出的就是Windows帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的实现条件
多态的三个条件:
- 继承的存在(继承是多态的基础，没有继承就没有多态)；
- 子类重写父类的方法(多态下调用子类重写的方法)；
- 父类引用变量指向子类对象(子类到父类的类型转换)。
子类转换成父类时的规则: - 将一个父类的引用指向一个子类的对象，称为向上转型(
upcasting)，自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法，不是父类的方法。 此时通过父类引用变量无法调用子类特有的方法； - 如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型，此时必须进行强制类型转换。
以下是一个多态实例的演示，详细说明请看注释：
public class TestAnimalDemo {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型,创建一个Animal类的对象，但创建的方法是Animal类的子类（Cat类）的方法。
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat) a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat) a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog) a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
输出结果：
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
可以用 instanceof 判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。instanceof 的语法格式为:
对象 instanceof 类(或接口)
它的返回值是布尔型的，或真(true)、或假(false)。
多态的实现形式
在Java中有两种形式可以实现多态：继承和接口。
- 基于继承实现的多态
基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。
基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。
如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。 - 基于接口实现的多态
继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可能是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
在接口的多态中，指向接口的引用必须是指定实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。
继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
编程要求
根据提示，在右侧编辑器补充代码：
声明一个Animal类，此类中定义eat()方法；
声明Dog类、Cat类、Lion类，均继承自Animal类，并复写了eat()方法；
运用多态方式实例化子类对象并调用eat()方法打印输出信息；
具体输出要求请看测试说明。
测试说明
测试输入：无
预期输出：
eating bread...
eating rat...
eating meat...
实现代码
package case8;
public class TestPolymorphism {
public static void main(String[] args) {
// 以多态方式分别实例化子类对象并调用eat()方法
/********* begin *********/
Animal a = new Dog();
a.eat();
Animal b = new Cat();
b.eat();
Animal c = new Lion();
c.eat();
/********* end *********/
}
}
// Animal类中定义eat()方法
abstract class Animal { //定义为abstract类
/********* begin *********/
/*public void eat(){ //父类中方法不写方法体，可定义为抽象类
}*/
abstract void eat(); //定义为abstract方法
/********* end *********/
}
// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
/********* begin *********/
public void eat(){
System.out.println("eating bread...");
}
/********* end *********/
}
// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
/********* begin *********/
public void eat(){
System.out.println("eating rat...");
}
/********* end *********/
}
// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
/********* begin *********/
public void eat(){
System.out.println("eating meat...");
}
/********* end *********/
}
实验分析：
- 向上转型：创建一个Animal类的对象，但创建的方法是Animal类的子类（Cat类）的方法。
- 含有抽象方法的类要定义为抽象类。