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

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

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

public abstract class Test {    

    public abstract void eat(); // 抽象方法    

    public void sleep(){        

        System.out.println("我正在睡觉"); 

        //普通方法  

    }

}

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

• 抽象方法没有方法体，必须使用 abstract 关键字来修饰；

• 抽象方法必须存在于抽象类中；

• 子类重写父类时，必须重写父类所有的抽象方法。

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

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

• 抽象类和抽象方法都要使用 abstract 关键字声明。

• 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0~n 个抽象方法，以及 0~n 个具体方法；

• 抽象类不能实例化，也就是不能使用 new 关键字创建对象，只能被继承；

• 继承一个抽象类，必须重写其抽象方法，否则该类也会被抽象化。

我们来看一个例子：

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

// 抽象类 Animal

public abstract class Animal {    

	public abstract void eat(); // 抽象方法    

    public abstract void sleep();// 抽象方法    

    public void Smile(){        

        System.out.println("每个动物都会微笑");    

    }

}

再定义一个狗类，子类 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();    

    }

}

执行结果：

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

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 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("我负责对施工项目实施全过程、全面管理。");	

	 	

	}

	

}

练习-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("老师在学校公寓睡觉。");

		

	}

}

学习-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);   

    // 声明方法

}

• 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();

}

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

实现接口

读者福利

由于篇幅过长，就不展示所有面试题了，感兴趣的小伙伴

更多笔记分享

找小编（vip1024c）领取
在接口中定义的任何字段都被 static 和 final 修饰

final int a = 10;    

// 方法必须被定义为 public 和 abstract 形式，即使不声明，也将隐式地声明为公有的（public）和抽象的（abstract）。    

void display();

}

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



##### []( )实现接口


# **读者福利**

**由于篇幅过长，就不展示所有面试题了，感兴趣的小伙伴**

[外链图片转存中...(img-xws5W8OZ-1721717134212)]

[外链图片转存中...(img-3TzjsI6Z-1721717134212)]

[外链图片转存中...(img-dq7C7lku-1721717134213)]

**更多笔记分享**

[外链图片转存中...(img-3oi9HlRs-1721717134213)]

> **找小编（vip1024c）领取**