Java头歌实践-抽象类和接口_本关任务:掌握抽象类的定义及用法。

Java头歌实践-抽象类和接口

学习-Java继承和多态之abstract类

任务描述

本关任务：根据所学知识，完成抽象类的定义与使用。

相关知识

Java 语言提供了两种类，分别为具体类和抽象类。前面学习接触的类都是具体类。这里介绍一下抽象类。

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，那么这样的类称为抽象类。

在 Java 中抽象类的语法格式如下：

<abstract>class<class_name> {
    <abstract><type><method_name>(parameter-list);
}
1
2
3

其中，abstract 表示该类或该方法是抽象的；class_name 表示抽象类的名称；method_name 表示抽象方法名称，parameter-list 表示方法参数列表。

例子：

// 这是一个抽象类public abstract class Test {}
1

如果一个方法使用 abstract 来修饰，则说明该方法是抽象方法，抽象方法只有声明没有实现。需要注意的是 abstract 关键字只能用于普通方法，不能用于 static 方法或者构造方法中。

注意抽象方法是没有方法体的（也就是方法后面是没有大括号的）。凡是继承这个抽象类的实体子类，都必须要实现这个抽象方法。

public abstract class Test {    
    public abstract void eat(); // 抽象方法    
    public void sleep(){        
        System.out.println("我正在睡觉"); 
        //普通方法  
    }
}
1
2
3
4
5
6
7

抽象方法的 3 个特征如下：

• 抽象方法没有方法体，必须使用 abstract 关键字来修饰；
• 抽象方法必须存在于抽象类中；
• 子类重写父类时，必须重写父类所有的抽象方法。

注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。

抽象类的定义和使用规则如下：

• 抽象类和抽象方法都要使用 abstract 关键字声明。
• 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0n 个抽象方法，以及 0n 个具体方法；
• 抽象类不能实例化，也就是不能使用 new 关键字创建对象，只能被继承；
• 继承一个抽象类，必须重写其抽象方法，否则该类也会被抽象化。

我们来看一个例子：

我们先定义一个抽象的动物类，抽象类作为一个父类，可以定义抽象方法，也可以定义一般方法。

// 抽象类 Animal
public abstract class Animal {    
	public abstract void eat(); // 抽象方法    
    public abstract void sleep();// 抽象方法    
    public void Smile(){        
        System.out.println("每个动物都会微笑");    
    }
}
1
2
3
4
5
6
7
8

再定义一个狗类，子类 Dog 继承了抽象类，那么就必须将其抽象方法实现。

class Dog extends Animal{    
    // 重写父类的抽象方法 eat()    
    @Override    
    public void eat() {        
        System.out.println("狗爱吃骨头");    
    }    
    // 重写父类的抽象方法 sleeep()    
    @Override    
    public void sleep() {        
        System.out.println("小狗要睡觉");    
    }    
    public static void main(String[] args){        
        Dog dog=new Dog();  
        // 实例化一个Dog对象        
        dog.eat();        
        dog.sleep();        
        dog.Smile();    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果：

狗爱吃骨头小狗要睡觉每个动物都会微笑
1

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中完成抽象类的定义与使用，具体要求如下：

• 定义员工抽象类 Employee，其中包含 2 个受保护的变量和两个抽象方法；
  1. 两个变量：姓名 name（String），和工资 salary（double）；
  2. 抽象方法 work()，无返回值，表示工作内容；
  3. 抽象方法 info()，无返回值，表示员工信息。
• 定义一个公开的经理类 Manager，该类继承员工类，除了有员工类的基本属性外，还有岗位级别 gender（String）私有属性。
  1. 一个有参构造方法；
  2. 重写 work() 方法，输出：“我负责对施工项目实施全过程、全面管理。”；
  3. 重写 info() 方法，输出：“姓名：xx，工资：xx，岗位级别：xx”。

// 定义员工抽象类 Employee，其中包含 2 个受保护的变量和两个抽象方法

    // 两个受保护的变量：姓名 name（String），和工资 salary（double）；

    //抽象方法 work，无返回值，表示工作内容

    //抽象方法 info，无返回值，表示员工信息
abstract class Employee{
	protected String name;
	protected double salary;
	abstract void work();
	abstract void info();
}

//定义一个公开的经理类 Manager，该类继承员工类，除了有员工类的基本属性外，还有岗位级别 gender（String）私有属性。

// 定义一个有参构造方法

// 重写 work() 方法，输出：“我负责对施工项目实施全过程、全面管理。”；

// 重写 info() 方法，输出：“姓名：xx，工资：xx，岗位级别：xx”。
class Manager extends Employee{
	public Manager(String name,double salary,String gender) {
		this.name=name;
		this.salary=salary;
		this.gender=gender;
	}
	private String gender;
	@Override
	void info() {
		System.out.println("姓名："+name+"，工资："+salary+"，岗位级别："+gender);	
	}
	@Override
	void work() {
		System.out.println("我负责对施工项目实施全过程、全面管理。");	
	 	
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

练习-Java继承和多态之接口

任务描述

本关任务： 编写一个学校接待方面的程序，招待不同身份的人的食宿问题。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中编写一个学校接待方面的程序，具体要求如下：

• 定义一个公开的接口类 Person，该类实现两个功能，第一个为 eat()，实现输出吃饭的功能，无返回值，第二个为 sleep()，实现睡觉的功能，无返回值。
• 定义一个 Student 类并实现 Person 接口，实现两个方法：
  1. eat()：输出：“学生去食堂吃饭。”；
  2. sleep()：输出：“学生在宿舍睡觉。”。
• 定义一个 Teacher 类并实现 Person 接口，实现两个方法：
  1. eat()：输出：“老师去教师食堂吃饭。”；
  2. sleep()：输出：“老师在学校公寓睡觉。”。

// 定义一个接口类 Person
interface Person{
	// 定义 eat()，实现输出吃饭的功能，无返回值
	public void eat();
	// 定义 sleep()，实现睡觉的功能，无返回值
	public void sleep();
}
    

// 定义一个 Student 类并实现 Person 接口
class Student implements Person{
    // 实现 eat()：输出：“学生去食堂吃饭。”；
	@Override
	public void eat() {
		System.out.println("学生去食堂吃饭。");	
	}
    // 实现 sleep()：输出：“学生在宿舍睡觉。”。
	@Override
	public void sleep() {
		System.out.println("学生在宿舍睡觉。");		
	}
}

// 定义一个 Teacher 类并实现 Person 接口
class Teacher implements Person{
    // 实现 eat()：输出：“老师去教师食堂吃饭。”；
	@Override
	public void eat() {
		System.out.println("老师去教师食堂吃饭。");	
		
	}
    // 实现 sleep()：输出：“老师在学校公寓睡觉。”。
	@Override
	public void sleep() {
		System.out.println("老师在学校公寓睡觉。");
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

学习-Java继承和多态之接口

任务描述

本关任务：编写程序，实现两个数的求和运算和比较。

相关知识

Java 接口（Interface），是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

它是抽象类的延伸，可以看做是纯粹的抽象类，它的所有方法都没有执行体，是由全局常量和公共的抽象方法所组成。也是解决 Java 无法使用多继承的一种手段。

接口的定义

Java 接口的定义方式与类基本相同，当声明一个接口时，我们使用 interface 这个关键字，在接口中的所有方法都必须只声明方法标识，而不要去声明具体的方法体，因为具体的方法体的实现是由继承该接口的类来去实现的，因此，接口并不用管具体的实现。接口中的属性默认为 public static Final，一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。

接口定义的语法格式如下：

[public] interface interface_name [extends interface1_name[, interface2_name,…]] 
{    
    // 接口体，其中可以包含定义常量和声明方法    
    [public] [static] [final] type constant_name = value;    
    // 定义常量    
    [public] [abstract] returnType method_name(parameter_list);   
    // 声明方法
}
1
2
3
4
5
6
7
8

• interface_name 表示接口的名称；
• extends 表示接口的继承关系；
• interface1_name 表示要继承的接口名称；
• constant_name 表示变量名称，一般是 static 和 final 型的；
• returnType 表示方法的返回值类型；
• parameter_list 表示参数列表，在接口中的方法是没有方法体的。

注意：一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

例子：

public interface Test {    
    // 在接口中定义的任何字段都被 static 和 final 修饰    
    final int a = 10;    
    // 方法必须被定义为 public 和 abstract 形式，即使不声明，也将隐式地声明为公有的（public）和抽象的（abstract）。    
    void display();
}
1
2
3
4
5
6

一个接口不能够实现另一个接口，但它可以继承多个其他接口。子接口可以对父接口的方法和常量进行重写。

实现接口

接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用 extends 关键字，实现则使用 implements 关键字。因为一个类可以实现多个接口，这也是 Java 为单继承灵活性不足所作的补充。类实现接口的语法格式如下：

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] 
{    
    // 主体
}
1
2
3
4

• superclass_name：需要继承的父类名称；
• interface1_name：要实现的接口名称。

例子：

// 定义一个动物接口
interface Animal {    
public static final int num = 5;    
    public abstract void eat();
}
// 定义一个猫类，实现动物接口
class Cat implements Animal {    
    @Override    
    public void eat() {        
        System.out.println("猫吃东西");    
    }
}
public class Test{    
    public static void main(String[] args) {        
        Cat cat = new Cat(); 
        // 实例化一个猫对象        
        cat.eat();    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果：

猫吃东西
1

实现接口需要注意以下几点：

• 实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔；
• 一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后；
• 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

接口的特点

1. Java 接口中的成员变量默认都是 public，static，final 类型的(都可省略)，必须被显示初始化，即接口中的成员变量为常量；
2. Java 接口中的方法默认都是 public，abstract 类型的(都可省略)，没有方法体，不能被实例化；
3. Java 接口中只能包含 public，static，final 类型的成员变量和 public，abstract 类型的成员方法；
4. 接口中没有构造方法，不能被实例化；
5. 一个接口不能实现(implements)另一个接口，但它可以继承多个其它的接口；
6. Java 接口必须通过类来实现它的抽象方法；
7. 当类实现了某个 Java 接口时，它必须实现接口中的所有抽象方法，否则这个类必须声明为抽象类；
8. 不允许创建接口的实例(实例化)，但允许定义接口类型的引用变量，该引用变量引用实现了这个接口的类的实例；
9. 一个类只能继承一个直接的父类，但可以实现多个接口，间接的实现了多继承。

Java 中接口和继承的区别：

1. 不同的修饰符修饰(接口：interface)，(继承：extends)；
2. 在面向对象编程中可以有多继承！但是只支持接口的多继承，不支持‘继承’的多继承；
3. 在接口中只能定义全局常量，和抽象方法，而在继承中可以定义属性方法，变量，常量等；
4. 某个接口被类实现时，在类中一定要实现接口中的抽象方法，而继承想调用哪个方法就调用哪个方法。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中实现两个数的求和运算和比较，具体要求如下：

• 定义一个接口类 Compute，该类实现两个功能，第一个为 sum()，实现两个数的相加，返回值为 int，第二个为 max()，比较两个数的大小，携带两个参数，类型为 int，返回值为 int。
• 定义一个公开的 ComputeClass 类并实现 Compute 接口，有两个属性，分别表示两个数，类型为 int；
• 类中定义一个有参构造器，实现接口类的两个方法，两个方法分别返回两数相加之和和两数中的最大值。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。 可在右侧“测试结果”区查看具体的测试集详情。

测试输入：

trueok
1

预期输出：

两者是否相等：false
1

    /**
     * 编写程序，实现两个数的求和运算和比较
     */
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********** Begin **********/
    // 定义一个接口类 Compute
    interface Compute {
        // 第一个为 sum()，实现两个数的相加，返回值为 int
        public int sum();
        // 第二个为 max()，比较两个数的大小，携带两个参数，类型为int，返回值为int
        public int max(int a,int b);
    }
    // 定义一个公开的 ComputeClass 类并实现 Compute 接口
    public class ComputeClass implements Compute {
        // 有两个属性，分别表示两个数，类型为 int
        private int num1;
        private int num2;
        // 有参构造方法
        public ComputeClass(int num1,int num2) {
            this.num1 = num1;
            this.num2 = num2;
        }
        // 实现接口中的求和方法
        @Override
        public int sum() {
            return num1 + num2;
        }
        // 实现接口中的获取较大数的方法
        @Override
        public int max(int a,int b) {
            return a>b?a:b;
        }
    }
    /********** End **********/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35