java中的抽象类和接口

一人の城一人

已于 2022-02-14 11:11:32 修改

阅读量249

点赞数

分类专栏： java基础文章标签： java 开发语言后端

于 2021-11-22 17:17:38 首次发布

本文链接：https://blog.csdn.net/qq_54199667/article/details/121476002

版权

java基础专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

1. 抽象类概述

举个例子，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。

1.1 抽象类特点

抽象类特点

•抽象类和抽象方法必须用abstract关键字修饰

格式

•abstract class 类名 {}

•public abstract void eat();

•抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

•抽象类不能实例化

•抽象方法没有方法体

public abstract void mathod();

•那么，抽象类如何实例化呢?

•按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

•抽象类的子类

•要么是抽象类

•要么重写抽象类中的所有抽象方法

1.2 抽象类的成员特点

成员变量

•可以是变量

•也可以是常量

构造方法

•有构造方法，但是不能实例化

•那么，构造方法的作用是什么呢?

•用于子类访问父类数据的初始化

成员方法

•可以有抽象方法限定子类必须完成某些动作

•也可以有非抽象方法提高代码复用性

1.3 小问题

package com.wsy.abst;
/*
一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
	A:可以。
	B:不让创建对象。

abstract不能和哪些关键字共存?
	private	冲突
	final	冲突	
	static	无意义
*/
abstract class AbstractDemo4 {
	public static void main(String[] args) {
		
	}
	//抽象方法必须被子类重写不应该被私有化
	//private abstract void show();
			
	//被final修饰的方法不能被重写
	//final abstract void show();
			
	//被static修饰的方法可以直接类名调用但是抽象方法没有方法体,调用无意义
	//static abstract void show();
}

1.4 案例

猫狗案例

package com.wsy.abst;
/*猫狗案例
	具体事物；猫,狗
	共性：姓名，年龄，吃饭
	分析：从具体到抽象
	猫：
		成员变量：姓名,年龄
		构造方法；无参,带参
		成员方法；吃饭(猫吃鱼)
	狗：
		成员变量：姓名,年龄
		构造方法；无参,带参
		成员方法；吃饭(狗吃骨头)
		
	因为 有共性的内筒，所以就提取一个父类，Animal
	但是由于吃饭的方法不一样，所以吃饭的方法是抽象的
	而抽象方法必须写在抽象类中
	
	抽象动物类；
		成员变量；姓名,年龄
		构造方法；无参,带参
		成员方法；吃饭
	狗类：
		继承自Animal(动物)类
		重写吃饭();
	猫类：
		继承自Animal(动物)类
		重写吃饭();
*/
		
public class AbstractTest {
	public static void main(String[] args) {
		//方式一创建子类对象
		DogDemo3 d = new DogDemo3();
		d.setName("小黑");
		d.setAge(1);
		System.out.println("这只狗的姓名是:"+d.getNAme()+",它今年"+d.getAge()+"岁了");
		d.eat();
		//有参构造初始化父类成员变量
		DogDemo3 d1 = new DogDemo3("旺财",2);
		System.out.println("这只狗的姓名是:"+d1.getNAme()+",它今年"+d1.getAge()+"岁了");
		d1.eat();
		System.out.println("_______________________");
		
		//方拾二 多态的使用
		AnimalDemo3 a = new DogDemo3();
		a.setName("小白");
		a.setAge(2);
		System.out.println("这只狗的姓名是:"+a.getNAme()+",它今年"+a.getAge()+"岁了");
		a.eat();
		//有参构造初始化父类成员变量
		DogDemo3 a1 = new DogDemo3("大白",3);		
		System.out.println("这只狗的姓名是:"+a1.getNAme()+",它今年"+a1.getAge()+"岁了");
		a1.eat();
		System.out.println("_______________________");

	}

}

//创建动物类
abstract class AnimalDemo3 {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//有参无参构造方法
	public AnimalDemo3() {
		
	}
	public AnimalDemo3(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//get()set()方法
	public String getNAme() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//抽象方法
	public abstract void eat();
	
}

//创建狗类
class DogDemo3 extends AnimalDemo3 {
	public DogDemo3() {
		
	}
	public DogDemo3(String name,int age) {
		super(name,age);
	}
	
	public void eat() {
		System.out.println("吃骨头");
	}
}

//创建猫类
class CatDemo3 extends AnimalDemo3 {
	public void eat() {
		System.out.println("吃鱼");
	}
}

师生案例

package com.wsy.abst;

/*老师案例:
	具体事物：基础班学员，就业班学员，
	共性：姓名，年龄，班级,吃饭，学习
	
	分析：
		基础班学员：
			成员变量：姓名，年龄，班级
			成员方法：学习，吃放
		就业班学员：
		 	成员变量：姓名，年龄，班级
		 	成员方法:学习，吃饭
		 	
		 创建一个学员类：
		 	成员变量：姓名，年龄，班级
		 	成员方法：学习，吃放
*/
public class AbstractTest1 {
	public static void main(String[] args) {
		
		//基础班测试  多态的方式
		Student s = new BasicStudent();
		s.setName("马云");
		s.setAge(22);
		s.setGrand("1111");
		System.out.println("这个学生叫"+s.getName()+",今年"+s.getAge()+"岁,学号是"+s.getGrand());
		s.eat();
		s.study();
		System.out.println("________________________________");
		
		s = new BasicStudent("孙悟空",18,"9999");
		System.out.println("这个学生叫"+s.getName()+",今年"+s.getAge()+"岁,学号是"+s.getGrand());
		s.study();
		s.eat();
		System.out.println("________________________________");

		//就业班测试
		Student s1 = new WorkStudent();
		s1.setName("贝吉塔");
		s1.setAge(18);
		s1.setGrand("9998");
		System.out.println("这个学生叫"+s1.getName()+",今年"+s1.getAge()+"岁,学号是"+s1.getGrand());
		s1.study();
		s1.eat();
		System.out.println("________________________________");
		Student s2 = new WorkStudent("孙悟饭",16,"8888");
		System.out.println("这个学生叫"+s2.getName()+",今年"+s2.getAge()+"岁,学号是"+s2.getGrand());
		s2.study();
		s2.eat();
	}
}

//定义抽象学员类
abstract class Student {
	//学员名字
	private String name;
	//学员年龄
	private int age;
	//学员班级
	private String grand;
	
	//有参无参构造方法
	public Student() {
		
	}
	public Student(String name,int age,String grand) {
		this.name = name;
		this.age = age;
		this.grand = grand;
	}
	//get()set()方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public String getGrand() {
		return grand;
	}
	public void setGrand(String grand) {
		this.grand = grand;
	}
	
	//学习方法
	public abstract void study();
	
	//吃饭方法
	public void eat() {
		System.out.println("学习累了去吃饭");
	}
}

//创建具体的基础学员类
class BasicStudent extends Student {
	//有参无参构造方法
	public BasicStudent() {
		
	}
	public BasicStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	//学习的方法
	public void study() {
		System.out.println("基础班学习的是JAVASE");
	}
}

//创建具体的就业班学生类
class WorkStudent extends Student {
	//有参无参构造方法
	public WorkStudent() {
		
	}
	public WorkStudent(String name,int age,String grand) {
		super(name,age,grand);
	}
	//学习的方法
	public void study() {
		System.out.println("就业班学习的是JAVAEE");
	}
}

员工案例

package com.wsy.abst;
/*假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
分析；
	普通员工类
		成员方法:姓名，工号，工资
		成员方法:工作
	经理类
		成员变量:姓名，工号，工资，奖金
		成员方法:工作


*/

//测试类
public class AbstractDemo3 {
	public static void main(String[] args) {
		//普通员工 多态的方式
		Employee e = new Programmer();
		e.setName("小王");
		e.setId("9527");
		e.setSalary(8000);
		Employee.print(e);
		e.work();
		System.out.println("___________________________________");
		e = new Programmer("老王","6666",10000);
		Employee.print(e);
		e.work();
		System.out.println("___________________________________");

		//经理
		//创建子类对象
		Manager m = new Manager();
		m.setName("赵四");
		m.setId("02");
		m.setSalary(20000);
		m.setBonus(10000);
		Manager.print(m);
		m.work();
		System.out.println("___________________________________");

		m = new Manager("王五","01",100000,20000);
		Manager.print(m);
		m.work();
	}
}

//员工类
abstract class Employee {
	//员工姓名
	private String name;
	//员工工号
	private String id;
	//员工工资
	private int salary;
	
	//有参无参构造函数
	public Employee() {
		
	}
	public Employee(String name,String id,int salary) {
			this.name = name;
			this.id  = id;
			this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	
	//工作方法
	public abstract void work();
	
	//打印方法
	public static void print(Employee s) {
		System.out.println("员工名称:"+s.getName()+",工号是:"+s.getId()+",工资:"+s.getSalary());

	}
}

//普通员工类
class Programmer extends Employee {
	public Programmer() {
		
	}
	public Programmer(String name,String id,int salary) {
		super(name,id,salary);
	}
	public void work() {
		System.out.println("按着需求敲代码");
	}
}

//经理类
class Manager extends Employee {
	//奖金
	public int bonus;
	public Manager() {
		
	}
	public Manager(String name,String id,int salary,int bonus) {
		super(name,id,salary);
		this.bonus = bonus;
	}
	
	public int getBonus() {
		return bonus;
	}
	public void setBonus(int bonus) {
		this.bonus = bonus;
	}
	
	public void work() {
		System.out.println("跟客户谈需求");
	}
	
	//打印方法
	public static void print(Manager m) {
		System.out.println("经理名称:"+m.getName()+",工号是:"+m.getId()+",工资:"+m.getSalary()+",奖金:"+m.getBonus());

	}
}

2. 接口概述

继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了，对不。但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的，对不。所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

2.1 接口的特点

•接口不是类用关键字interface定义

•格式：interface 接口名 {}

•类实现接口用implements表示

•格式：class 类名 implements 接口名 {}

•接口不能实例化

•那么，接口如何实例化呢?

•按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

•接口的子类

•要么是抽象类

•要么重写接口中的所有抽象方法

2.2 接口的成员特点

成员变量:

只能是常量，并且是静态的
默认的修饰符:public static final
最好手动给出
构造方法:

接口没有构造方法
成员方法:

接口内的所有方法都是抽象方法
默认权限修饰符:public abstract
最好手动给出

3. 类与类,类与接口以及接口与接口的关系

类与类**

•继承关系，只能单继承，但是可以多层继承

类与接口

•实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口

•继承关系，可以单继承，也可以多继承

4. 接口和抽象类的区别

共同点：

都有抽象方法都不能被实例化

一个类要继承抽象类就需要重写所有的抽象方法，一个类要实现接口也要重写所有的抽象方法

不同点：

接口不是类用interface定义而抽象类是用abstract修饰的类
接口里面只能有抽象方法，抽象类中既可以有抽象方法也可以有非抽象方法
一个类可以实现多个接口，但是只能继承一个类
接口里面的变量都是final修饰的常量，抽象类没有限制

成员区别

•抽象类变量,常量;有抽象方法;抽象方法,非抽象方法

•接口常量;抽象方法

关系区别

•类与类继承，单继承

•类与接口实现，单实现，多实现

•接口与接口继承，单继承，多继承

设计理念区别

•抽象类被继承体现的是：”is a”的关系。共性功能

•接口被实现体现的是：”like a”的关系。扩展功能

4.1 案例

师生案例

package com.wsy.inter;
/*
老师和学生案例,加入抽烟的额外功能

具体:
	老师：姓名,年龄,吃饭,睡觉
	学生：姓名,年龄,吃饭,睡觉
	
	由于有共性提取成一个父类 People
	
	人类：
		姓名,年龄
		吃饭();
		睡觉(){};
		
	由于部分人会抽烟所以需要接口扩展功能
*/

public class InterfaceTest1 {
	public static void main(String[] args) {
		
		//定义会吸烟的学生对象
		SmokeStudent ss = new SmokeStudent();
		ss.setName("李建国");
		ss.setAge(18);
		System.out.println("这个学生叫"+ss.getName()+",今年"+ss.getAge()+"岁");
		ss.eat();
		ss.sleep();
		ss.PeopleSmoke();
		System.out.println("__________________________________");
		
		//用构造函数初始化赋值
		ss = new SmokeStudent("张三",19);
		System.out.println("这个学生叫"+ss.getName()+",今年"+ss.getAge()+"岁");
		ss.eat();
		ss.sleep();
		ss.PeopleSmoke();
		System.out.println("__________________________________");

		
		//定义会吸烟的老师对象
		SmokeTeacher st = new SmokeTeacher();
		st.setName("李四");
		st.setAge(18);
		System.out.println("这个老师叫"+st.getName()+",今年"+st.getAge()+"岁");
		st.eat();
		st.sleep();
		st.PeopleSmoke();
		System.out.println("__________________________________");
		
		//用构造函数初始化赋值
		st = new SmokeTeacher("王五",19);
		System.out.println("这个老师叫"+st.getName()+",今年"+st.getAge()+"岁");
		st.eat();
		st.sleep();
		st.PeopleSmoke();
	}
}
 
//定义人类
abstract class People {
	private String name;
	private int age;
	
	//定义有参无参构造函数
	public People() {
		super();
	}

	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//定义get()set()方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
//	吃饭
	public abstract void eat();
//	睡觉
	public void sleep() {
		System.out.println("躺着睡");
	}	
}

//定义接口提供吸烟(Smoke)的功能
interface Smoke {
	//抽烟的抽象方法
	public abstract void PeopleSmoke();
}

//定义老师类 teacher
class Teacher extends People {
	
	//有参无参构造函数
	public Teacher() {
		
	}
	public Teacher(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("经常自己做饭吃");
	}
}

//定义学生类 student
class Student extends People {
	
	//有参无参构造函数
	public Student() {
		
	}
	public Student(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("经常点外卖");
	}
}

//定义会抽烟的老师类
class SmokeTeacher extends Teacher implements Smoke {
	
	public SmokeTeacher() {
		
	}
	public SmokeTeacher(String name,int age) {
		super(name,age);
	}
	
	public void PeopleSmoke() {
		System.out.println("这个老师会抽烟");
	}
}

//定义会抽烟的学生类
class SmokeStudent extends Student implements Smoke {
	
	public SmokeStudent() {
		
	}
	public SmokeStudent(String name,int age) {
		super(name,age);
	}
	
	public void PeopleSmoke() {
		System.out.println("这个学生会抽烟");
	}
}

猫狗案例

package com.wsy.inter;
/*
 * 猫狗案例:加入跳高(jump)的额外功能
 * 
 *	分析：从具体到抽象
 *		猫：
 *			姓名，年龄
 *			吃饭，睡觉
 *		狗：
 *			姓名，年龄
 *			吃饭，睡觉
 *	由于有共性所以抽取一个父类Animal
 *		Animal：
 *			姓名，年龄
 *			吃饭();
 *			睡觉(){};
 *		要求加入跳高的额外功能所以另建一个接口实现跳高功能
 */
public class InterfaceTest {
	public static void main(String[] args) {
		
		//定义会跳高的猫类对象A
		JumpCat jc = new JumpCat();
		jc.setName("叮当");
		jc.setAge(2);
		System.out.println("这只猫叫"+jc.getName()+",它今年"+jc.getAge()+"岁了");
		jc.eat();
		jc.sleep();
		jc.jump();
		System.out.println("________________________________");
		
		jc = new JumpCat("布偶",3);
		System.out.println("这只猫叫"+jc.getName()+",它今年"+jc.getAge()+"岁了");
		jc.eat();
		jc.sleep();
		jc.jump();
		System.out.println("________________________________");

		//定义会跳高的狗类对象
		JumpDog jd = new JumpDog("大白",3);
		System.out.println("这只狗叫"+jd.getName()+",它今年"+jd.getAge()+"岁了");
		jd.eat();
		jd.sleep();
		jd.jump();
		System.out.println("________________________________");

		
		jd = new JumpDog();
		jd.setName("大黄");
		jd.setAge(2);
		System.out.println("这只狗叫"+jd.getName()+",它今年"+jd.getAge()+"岁了");
		jd.eat();
		jd.sleep();
		jd.jump();
	}
}

//定义动物类
abstract class AnimalTest1 {
	private String name;
	private int age;
	
	//定义有参无参构造函数
	public AnimalTest1() {
		
	}
	public AnimalTest1(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//定义get()set()方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//由于吃的食物不同所以定义为抽象放法
	public abstract void eat();
	
	//睡觉
	public void sleep() {
		System.out.println("睡觉的方法");
	}
}

//定义跳高接口
interface Extend {
	//跳高功能
	public abstract void jump();
}

//具体狗类
class DogTest1 extends AnimalTest1 {
	
	//有参无参构造函数
	public DogTest1() {
		
	}
	public DogTest1(String name,int age) {
		super(name,age);
	}
	
	//重写吃饭的方法
	public void eat() {
		System.out.println("狗吃骨头");
	}
	
}

//具体猫类
class CatTest1 extends AnimalTest1 {
	//有参无参构造函数
	public CatTest1() {
		
	}
	public CatTest1(String name,int age) {
		super(name,age);
	}
	//重写吃饭的方法
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
}

//会跳高的狗
class JumpDog extends DogTest1 implements Extend {
	//有参无参构造函数
	public JumpDog() {
		
	}
	public JumpDog(String name,int age) {
		super(name,age);
	}
	
	//实现接口中的方法
	public void jump() {
		System.out.println("这只狗会跳高");
	}
}

//会跳高的猫
class JumpCat extends CatTest1 implements Extend {
	
	//有参无参构造函数
	public JumpCat() {
		
	}
	public JumpCat(String name,int age) {
		super(name,age);
	}
	
	//实现接口中的方法
	public void jump() {
		System.out.println("这只猫会跳高");
	}
}

t1 {

//有参无参构造函数
public DogTest1() {
	
}
public DogTest1(String name,int age) {
	super(name,age);
}

//重写吃饭的方法
public void eat() {
	System.out.println("狗吃骨头");
}

}

//具体猫类
class CatTest1 extends AnimalTest1 {
//有参无参构造函数
public CatTest1() {

}
public CatTest1(String name,int age) {
	super(name,age);
}
//重写吃饭的方法
public void eat() {
	System.out.println("猫吃鱼");
}

}

//会跳高的狗
class JumpDog extends DogTest1 implements Extend {
//有参无参构造函数
public JumpDog() {

}
public JumpDog(String name,int age) {
	super(name,age);
}

//实现接口中的方法
public void jump() {
	System.out.println("这只狗会跳高");
}

}

//会跳高的猫
class JumpCat extends CatTest1 implements Extend {

//有参无参构造函数
public JumpCat() {
	
}
public JumpCat(String name,int age) {
	super(name,age);
}

//实现接口中的方法
public void jump() {
	System.out.println("这只猫会跳高");
}

}

一人の城一人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java中的抽象类和接口

文章目录1. 抽象类概述1.1 抽象类特点1.2 抽象类的成员特点1.3 小问题1.4 案例猫狗案例师生案例员工案例2. 接口概述2.1 接口的特点2.2 接口的成员特点3. 类与类,类与接口以及接口与接口的关系4. 接口和抽象类的区别4.1 案例师生案例猫狗案例1. 抽象类概述举个例子，我说动物，你知道我说的是什么动物吗?只有看到了具体的动物，你才知道，这是什么动物。所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，我们也可以推想，不同的动物吃的东西应该
复制链接

扫一扫