【2面向对象】6-抽象类

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修饰的方法就是为了让子类重写的

综上所述：

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

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面向对象】5-多态