【12】JAVASE-面向对象-抽象类【从零开始学JAVA】

用户4919348

发布于 2024-05-25 14:03:52

390

发布于 2024-05-25 14:03:52

文章被收录于专栏：波波烤鸭波波烤鸭

Java零基础系列课程-JavaSE基础篇

Lecture：波哥

Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机，Java 仍是企业和开发人员的首选开发平台。

六、抽象类

1.抽象类的相关的概念

被abstract关键字修饰的类，就被称为抽象类

被abstract关键字修饰的方法，被称为抽象方法，抽象方法是没有方法体的,抽象方法必须定义在抽象类中

Abstract methods do not specify a body
The abstract method eat in type Pet can only be defined by an abstract class

package com.bobo.oop09;

/**
 * 宠物类
 * @author dpb
 *
 */
public abstract class Pet {
	
	String name;
	
	/**
	 * 父类中的这个方法 我们可以仅仅定义为一个声明，具体的实现交给子类去实现即可
	 */
	public abstract void eat();

}

格式：

// 抽象类
abstract class 类名{}

// 抽象方法
abstract 返回值类型 方法名(参数列表);

2.抽象类的特点

1.抽象类和抽象方法一定要使用abstract关键字

2.抽象类中不一定有抽象方法

/**
 * 抽象中不一定有抽象方法
 *    抽象方法一定要在抽象类中
 * @author dpb
 *
 */
public abstract class Person {

}

3.没有抽象方法的抽象类的存在意义是什么？ —> 抽象类不能被实例化

不让外界创建对象

Cannot instantiate the type Person

4.抽象类虽然不能被实例化，但是我们可以利用多态的思想类赋值

public class OOPDemo01 {

	public static void main(String[] args) {
		//Person p = new Person();
		// Pet抽象  Dog是Pet的子类 Dog是一个普通类
		Pet p1 = new Dog();
		p1.eat();
	}
}

5.作为抽象类的子类应该怎么办

父类

public abstract class Person {

	public abstract void say();
}

子类有两个选择：

1.把子类自身也变为抽象类

2.子类实现父类中的所有的抽象方法

6.抽象类中可以包含哪些内容

成员变量，成员方法，常量，构造方法，静态方法，代码块，静态代码块都可以

抽象类本身是不能够被实例化的，所以抽象类就是一个用类给子类服务的类

package com.bobo.oop09;

/**
 * 抽象中不一定有抽象方法
 *    抽象方法一定要在抽象类中
 * @author dpb
 *
 */
public abstract class Person {
	
	// 普通的成员变量  定义的变量是给子类使用的
	String name;
	// final修饰的变量  常量
	final String COUNTRY = "中国";
	// 静态常量
	static final int MAX_VALUE = 99999;
	
	// 普通方法
	public void sleep(){
		
	}
	
	// 静态方法
	public static void play(){
		
	}
	// 构造方法
	public Person(){
		
	}
	
	{
		// 代码块也可以
	}
	
	static {
		// 静态代码块
	}
	
	public Person(String name){
		this.name = name;
	}

	public abstract void say();
	
	public abstract void run();
}

7.static,final,private是否可以修饰抽象方法

static和abstract：是不能够共存的。static是为方便调用，abstract为了给子类重写的，没有方法体

final和abstract：是相互冲突的，final修饰的方法不能被重写，而abstract修饰的方法就是为了让子类重写的。

private和abstract：也是冲突的，private修饰的方法不能够被继承，也就不能够被重写了，而abstract修饰的方法就是为了让子类重写的

综上所述：

抽象类的所有的抽象方法都是用来给子类重写的
抽象类的所有的非抽象方法也是用来给子类使用的
抽象类的构造方法是用来给子类初始化父类继承过来的成员
抽象类的成员变量也是用来给子类使用的
抽象类就是一个彻头彻尾的服务类

3.课堂案例

编写交通工具类，具有前进run()功能，子类有自行车、小轿车、地铁，重写父类方法，主人有属性name,age属性，方法回家goHome(交通工具)，需要使用交通工具，使用抽象类来描述

package com.bobo.oop10;

public class OOPDemo01 {

	/**
	 * 编写交通工具类，具有前进run()功能，子类有自行车、小轿车、地铁，重写父类方法，
	 * 主人有属性name,age属性，方法回家goHome(交通工具)，需要使用交通工具，使用抽象类来描述
	 * @param args
	 */
	public static void main(String[] args) {
		Master master = new Master();
		Traffic bicycle = new Bicycle();
		Traffic car = new Car();
		Traffic subway = new Subway();
		master.goHome(bicycle);
		master.goHome(car);
		master.goHome(subway);

	}

}
// 交通工具类  抽象类
abstract class Traffic{
	
	String brand;
	
	String color;
	// 定义的一个抽象方法  供子类实现的
	public abstract void run();
	
}

class Bicycle extends Traffic{

	@Override
	public void run() {
		System.out.println("骑着自行车回家咯....");
	}
	
}

class Car extends Traffic{

	@Override
	public void run() {
		System.out.println("开着小车回家啦...");
		
	}
	
}

class Subway extends Traffic{

	@Override
	public void run() {
		System.out.println("太远了，做地铁回家...");
	}
	
}

// 主人类
class Master{
	private String name;
	
	private int age;
	
	// 回家的方法
	public void goHome(Traffic traffic){
		traffic.run();
	}

	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 Master(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Master() {
		super();
	}
}

static,final,abstract的比较

4.作业讲解

1、使用多态实现计算器的加减乘除，根据运算符不同实例化不同子类进行计算(运算符可键盘接收输入) 例如：加法有num1、num2属性，方法：计算求和减法有num1、num2属性，方法：计算求差

package com.bobo.oop01;

import java.util.Scanner;

public class OOPDemo01 {

	/**
	 * 使用多态实现计算器的加减乘除，根据运算符不同实例化不同子类进行计算(运算符可键盘接收输入)
	         例如：加法有num1、num2属性，方法：计算求和
              减法有num1、num2属性，方法：计算求差
	 * @param args
	 */
	public static void main(String[] args) {
		Calculate cal = null;
		Scanner in = new Scanner(System.in);
		System.out.println("请输入操作符:");
		String operator = in.next();
		switch (operator) {
			case "+":
				cal = new Add(20, 30);
				break;
			case "-":
				cal = new Subtraction(100, 30);
				break;
			default:
				break;
		}
		double res = cal.operation();
		System.out.println(res);
	}

}

// 创建一个计算的方法
abstract class Calculate{
	
	public int num1;
	
	public int num2;
	
	
	public Calculate(int num1, int num2) {
		this.num1 = num1;
		this.num2 = num2;
	}


	/**
	 * 操作两个数
	 *    可以声明为一个抽象方法
	 * @param num1
	 * @param num2
	 * @return
	 */
	public abstract double operation();
}

// 加法
class Add extends Calculate{

	public Add(int num1, int num2) {
		super(num1, num2);
	}

	@Override
	public double operation() {
		// TODO Auto-generated method stub
		return this.num1 + this.num2;
	}

	
}
// 减法
class Subtraction extends Calculate{

	public Subtraction(int num1, int num2) {
		super(num1, num2);
		// TODO Auto-generated constructor stub
	}

	@Override
	public double operation() {
		// TODO Auto-generated method stub
		return this.num1 - this.num2;
	}
	
}

2.西游记中，3个徒弟，共同的方法（吃斋，念佛，取经），孙悟空自己的方法（除妖），猪八戒自己的方法（牵马），沙和尚自己的方法（挑行李）, 编写程序使用多态分别调用孙悟空、猪八戒、沙和尚的所有方法

package com.bobo.oop01;


public class OOPDemo02 {

	/**
	 * 2.西游记中，3个徒弟，共同的方法（吃斋，念佛，取经），
		孙悟空自己的方法（除妖），
		猪八戒自己的方法（牵马），
		沙和尚自己的方法（挑行李）,
		编写程序使用多态分别调用孙悟空、猪八戒、沙和尚的所有方法
	 * @param args
	 */
	public static void main(String[] args) {
		
		Heshang swk = new Swk();
		swk.chizhai();
		swk.nianfu();
		swk.qujing();
		((Swk)swk).chuyao();
		Heshang zbj = new Zbj();
		zbj.chizhai();
		zbj.nianfu();
		zbj.qujing();
		((Zbj)zbj).qianma();
		Heshang shs = new Shs();
		shs.chizhai();
		shs.qujing();
		shs.nianfu();
		((Shs)shs).tiaoxingli();
	}

}
/**
 * 和尚类  抽象类
 * @author dpb
 *
 */
abstract class Heshang{
	
	public abstract void chizhai();
	
	public abstract void nianfu();
	
	public abstract void qujing();
}

class Swk extends Heshang{

	@Override
	public void chizhai() {
		// TODO Auto-generated method stub
		System.out.println("孙悟空 吃斋");
	}

	@Override
	public void nianfu() {
		// TODO Auto-generated method stub
		System.out.println("孙悟空 念佛");
	}

	@Override
	public void qujing() {
		// TODO Auto-generated method stub
		System.out.println("孙悟空 取经");
	}
	
	public void chuyao(){
		System.out.println("孙悟空 打妖怪");
	}
	
	
}

class Zbj extends Heshang{

	@Override
	public void chizhai() {
		// TODO Auto-generated method stub
		System.out.println("猪八戒 吃斋");
	}

	@Override
	public void nianfu() {
		// TODO Auto-generated method stub
		System.out.println("猪八戒 念佛");
	}

	@Override
	public void qujing() {
		// TODO Auto-generated method stub
		System.out.println("猪八戒 取经");
	}
	public void qianma(){
		System.out.println("猪八戒 牵马");
	}
}

class Shs extends Heshang{

	@Override
	public void chizhai() {
		// TODO Auto-generated method stub
		System.out.println("沙和尚 吃斋");
	}

	@Override
	public void nianfu() {
		// TODO Auto-generated method stub
		System.out.println("沙和尚 念佛");
	}

	@Override
	public void qujing() {
		// TODO Auto-generated method stub
		System.out.println("沙和尚 取经");
	}
	
	public void tiaoxingli(){
		System.out.println("沙和尚 挑行李");
	}
	
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-05-24，如有侵权请联系 cloudcommunity@tencent.com 删除

java