头歌实践-Java继承与多态

第1关：练习-Java继承和多态之final关键字

/**
 * 按照代码文件中提供的注释完成 Demo 类的编写，使得程序正常输出。
 */
class DemoTest{
    int i = 10;
}
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********* Begin *********/

// 将Demo类改为 final形式
final class Demo{
    // 定义一个final、static常量，名为PI，值为3.14
	final static double PI=3.14;
    // 声明一个final类型的DemoTest对象，命名为demoTest
	 final DemoTest demoTest = new DemoTest();//这里声明时应该初始化
	
    // 声明一个不为final类型的DemoTest对象，命名为demoTest2
	DemoTest demoTest2;
    // 声明一个final型的数组，类型为int，值为 1,2,3，命名为a
	final int []a=new int[]{1,2,3};
    // 删除主函数中错误的代码，使得程序能够正确输出
    public static void main(String[] args) {
        Demo demo = new Demo();
        //demo.demoTest = new Test();
        //demo.PI = 20;//final变量一经定义赋值则不可以改变
        System.out.println(demo.PI);
        demo.demoTest2 = new DemoTest();
        System.out.println(demo.demoTest2.i);
        for (int i = 0; i < demo.a.length; i++){
            demo.a[i] = 9;
            System.out.println(demo.a[i]);
        }
    }
}
/********** End **********/

第2关：学习-Java继承和多态之对象类型的转换

任务描述

本关任务：使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用。

相关知识

在之前的学习任务中，我们学习了基本类型之间的转换，这里我们来为大家介绍对象间的类型转换。

Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。如果把引用类型转换为子类类型，则称为向下转型；**如果把引用类型转换为父类类型，则称为向上转型。**注意：两者必须为父子关系。

向上转型

把子类对象赋值给父类类型的变量（隐式转换，不用进行强制类型转换），被称为向上转型。

本质：父类的引用指向了子类的对象。

语法：

父类类型 引用名 = new 子类类型() ;

例如：狗是动物的一种，那么也可以将狗看成一个动物对象。

class Animal{
    public void info(){
        System.out.println("我是动物");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗在吃东西");
    }
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        animal.info();
    }
}

执行结果：

我是动物

狗对象可以调用该方法，那么同样猫也可以调用该方法，这就做到了在父类中定义一个方法可以完成各个子类的功能。由于向上转型是一个从较具体类到较抽象类的转换，所以它总是安全的，因为我们可以说狗是动物，但是不能说动物是狗。

向上转型的特点如下：

1. 向上转型对象不能操作子类新增的成员变量（失掉了这部分属性），不能使用子类新增的方法（失掉了一些功能）；

2. 向上转型对象可以操作子类继承或重写的成员变量，也可以使用子类继承的或重写的方法；

3. 如果子类重写了父类的某个方法后，当对象的向上转型对象调用这个方法时一定是调用了这个重写的方法，因为程序在运行时知道，这个向上转型对象的实体是子类创建的，只不过损失了一些功能而已。

向下转型

向下转型是指子类引用父类对象，就是将父类对象能转换成子类对象，这时需要满足两个条件：一是必须执行强制类型转换；二是必须确保父类对象是子类的一个实例，否则抛出异常。

语法：

子类类型 引用名 = （子类类型）父类引用;

class Animal{
    public void info(){
        System.out.println("我是动物");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗在吃东西");
    }
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型
        Dog animal1 = (Dog) animal; // 向下转型
        animal1.eat();
    }
}

执行结果：

狗在吃东西

向下转型的特点如下：

1. 向下转型对象可以操作父类及子类成员变量和成员方法；

2. 向下转型对象访问重写父类的方法时，操作的是子类的方法；

3. 向下转型必须进行强制类型转换；

4. 向下转型必须保证父类对象引用的是该子类的对象，如果引用的是父类的其他子类对象，会抛出类型不匹配异常。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中完成猫类和动物类的转换，以及彼此方法和属性的调用，具体要求如下：

把猫类对象赋值给动物类；
将动物类引用转换为猫类对象；
输出 Animal 类的 name 变量；
输出 Animal 类的 staticName 变量；
输出 Cat 类的 eat() 方法；
输出 Animal 类的 staticEat() 方法；
调用 Cat 类的 str 变量；
调用 Cat 类的 eatMethod() 方法。

/**
 * 使用对象类型的转换，根据编程提示，完成猫类和动物类的转换，以及彼此方法和属性的调用
 * 	把猫类对象赋值给动物类；
	将动物类引用转换为猫类对象；
	输出 Animal 类的 name 变量；
	输出 Animal 类的 staticName 变量；
	输出 Cat 类的 eat() 方法；
	输出 Animal 类的 staticEat() 方法；
	调用 Cat 类的 str 变量；
	调用 Cat 类的 eatMethod() 方法。
 */
 // 定义动物类
class Animal{
	// 定义动物类的属性
    public String name = "动物";
    public static String staticName = "可爱的动物";
    // 定义动物类的行为方法
    public void eat() {
        System.out.println("动物吃饭");
    }
    public static void staticEat() {
        System.out.println("可爱的动物正在在吃饭");
    }
}
// 定义猫类，该类继承动物类
public class Cat extends Animal{
	// 定义猫类的属性
    public String name = "猫";
    public String str = "可爱的小猫";
    public static String staticName = "我是喵星人";
    // 定义猫类的行为方法
    public void eat() {
        System.out.println("猫吃饭");
    }
    public static void staticEat() {
        System.out.println("喵星人在吃饭");
    }
    public void eatMethod() {
        System.out.println("猫喜欢吃鱼");
    }

    public static void main(String[] args) {
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********* Begin *********/
        // 向上转型，把猫类对象赋值给动物类
    	Animal animal =new Cat();
        // 向下转型，将动物类引用转换为猫类对象
    	Cat cat2=(Cat) animal;
        // 输出Animal类的name变量
    	System.out.println(animal.name);
        // 输出Animal类的staticName变量
    	//直接通过类名访问静态变量
    	System.out.println(Animal.staticName);
        // 输出Cat类的eat()方法
    	animal.eat();
        // 输出Animal类的staticEat()方法
    	Animal.staticEat();
        // 调用Cat类的str变量
    	System.out.println(cat2.str);
        // 调用Cat类的eatMethod()方法
    	cat2.eatMethod();
        /********** End **********/
    }
}

第3关：练习-Java继承和多态之方法重载

任务描述

本关任务：定义名为 print 的静态方法，携带一个参数，无论该参数是 int 型、double 型还是字符串型，都可以将该参数进行打印。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。

/**
 * 任务：定义名为 print 的静态方法，携带一个参数，
 * 无论该参数是 int 型、double 型还是字符串型，都可以将该参数进行打印。
 */
public class Print {
    // 请在下面的Begin-End之间编写正确的代码
    /********** Begin **********/
	static void print(int num) {
		System.out.println(num);
	}
	static void print(double num) {
		System.out.println(num);
	}
	static void print(String str) {
		System.out.println(str);
	}
	
	public static void main(String []args) {
		Print.print(16);
		Print.print(16.0);
		Print.print("16");
	}

    /********** End **********/
}

第4关：练习-Java继承和多态之方法重写

任务描述

本关任务：计算球的表面积。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，按照提示编写程序代码。

/**
 * 重写 Shape 中的 area 方法，计算球的表面积。
 */

class Shape {
    private double r; //球的半径
    // 球的体积
    public double area(){
        double s = (double)3/4*Math.PI*Math.pow(r,3);
        return s;
    }
}
public class Sphere extends Shape{

    private double r; //球的半径
    
    public Sphere(double r) {
        this.r = r;
    }
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********* Begin *********/
    // 重写 Shape 中的 area 方法，计算球的表面积，将计算结果返回
    public double area(){
        double s = (double)4*Math.PI*Math.pow(r,2);
        return s;
    }
    
    public static void main(String []args) {
    	Sphere sphere=new Sphere(2);
    	System.out.println("球的表面积是："+sphere.area());
    	
    }
    /********** End **********/
}