【JavaSE】抽象类基本使用
【摘要】 【JavaSE】抽象类基本使用
1. 先看一个问题
-
小结:
当父类的某些方法,需要声明,但是又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类。 -
当父类的一些方法不能确定时,可以用
abstract
关键字来修饰该方法,这个方法就是抽象方法,用abstract
来修饰该类就是抽象类。 -
如何把
Animal
做成抽象类,并让子类Cat
类实现。
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
//思考:这里 eat 方法实现了,其实没什么意义
//即:父类方法不确定性的问题
// ==> 考虑将该方法设计为抽象方法(abstract)
// ==> 所谓抽象方法就是没有实现的方法,就是指没有方法体
// ==> 当一个类中存在抽象方法,需要将该类声明为 abstract 类
// ==> 一般,抽象类会被继承,有其子类来实现抽象方法
/*public void eat() {
System.out.println("这是一个动物,但是不知道吃什么...");
}*/
public abstract void eat();
}
2. 抽象类快速入门
- 当父类的一些方法不能确定时,可以用
abstract
关键字来修饰该方法,这个方法就是抽象方法,用abstract
来修饰该类就是抽象类。 - 如何把
Animal
做成抽象类,并让子类Cat
类实现
abstract class Animal
String name;
int age;
abstract public void cry() {
}
3. 抽象类的介绍
- 用
abstract
关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名 {
}
- 用abstract关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型方法名(参数列表); //没有方法体
- 抽象类的价值更多作用是在于设计,是设计者设计好后,让子类继承并实现抽象类()
- 抽象类,是考官比较爱问的知识点,在框架和设计模式使用较多
4. 抽象类使用的注意事项和细节讨论1
AbstractDetail01.java
- 抽象类不能被实例化
- 抽象类不一定要包含 abstract方法。也就是说,抽象类可以没有abstract方法,还可以有实现的方法。
- 一旦类包含了abstract方法,则这个类必须声明为abstract
- abstract 只能修饰类和方法,不能修饰属性和其它的。
public class AbstractDetail01 {
public static void main(String[] args) {
//1.抽象类,不能被实例化
//new A();
}
}
//2.抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法,还可以有实现的方法。
abstract class A {
public void hi() {
System.out.println("hi");
}
}
//3.一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
public abstract void hi();
}
//4.abstract 只能修饰类和方法,不能修饰属性和其它的
class C {
// public abstract int n1 = 1;
}
5. 抽象类使用的注意事项和细节讨论2
AbstractDetail02.java
- 抽象类可以有任意成员【抽象类本质还是类】,比如:非抽象方法、构造器、静态属性等等
- 抽象方法不能有主体,即不能实现,如图所示
abstract void aaa() { } //错误
-
如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类。
-
抽象方法不能使用
private、final
和static
来修饰,因为这些关键字都是和重写相违背的
public class AbstractDetail02 {
public static void main(String[] args) {
System.out.println("hello");
}
}
//5.抽象类的本质还是类,所以可以有类的各种成员
abstract class D {
public int n1 = 10;
public static String name = "兮动人";
public void hi() {
System.out.println("hi");
}
public abstract void hello();
public static void ok() {
System.out.println("ok");
}
}
//7.如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类
abstract class E {
public abstract void hi();
}
abstract class F extends E {
}
class G extends E {
@Override
public void hi() { //这里相等于G子类实现了父类E的抽象方法,所谓实现方法,就是有方法体
}
}
//8.抽象方法不能使用private、final 和 static来修饰,因为这些关键字都是和重写相违背的
abstract class H {
// private abstract void hi();//抽象方法
}
6. 练习
- 题1,思考:
abstract final class A()
能编译通过吗?
错误,final是不能继承 - 题2,思考:
abstract public static void test2();
能编译通过吗?
错误,static关键字和方法重写无关. - 题3,思考:
abstract private void test3();
能编译通过吗?
错误,private的方法不能重写 - 编写一个
Employee
类,声明为抽象类,包含如下三个属性:name,id,salary.
提供必要的构造器和抽象方法:work()
。对于Manager
类来说,他既是员工,还具有奖金(bonus
)的属性。请使用继承的思想,设计CommonEmployee
类和Manager
类,要求类中提供必要的方法进行属性访问,实现work()
,提示"经理/普通员工名字工作中…”,OOP的继承+抽象类
- 抽象类:Employee
abstract public class Employee {
String name;
int id;
double salary;
public Employee(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public abstract void work();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
- 经理:Manager
public class Manager extends Employee{
private double bonus;
public Manager(String name, int id, double salary) {
super(name, id, salary);
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理" + getName() + "工作中...");
}
}
- 普通员工:CommonEmployee
public class CommonEmployee extends Employee{
public CommonEmployee(String name, int id, double salary) {
super(name, id, salary);
}
@Override
public void work() {
System.out.println("普通员工" + getName() + "工作中...");
}
}
- 测试:
public class AbstractExercise01 {
public static void main(String[] args) {
Manager xdr = new Manager("xdr", 01, 80000);
xdr.work();
CommonEmployee jack = new CommonEmployee("jack", 02, 10000);
jack.work();
}
}
7. 抽象类最佳实践–模板设计模式
7.1 基本介绍
- 抽象类体现的就是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。
7.2 模板设计模式能解决的问题
- 当功能内部一部分实现是确定,一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。
- 编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板模式.
7.3 最佳实践
- 需求:
- 有多个类,完成不同的任务job
- 要求统计得到各自完成任务的时间
- 请编程实现 TestTemplate.java
- 先用传统的方法实现
任务1:计算1+2+…+800000 所需时间
public class AA {
public void job() {
//开始的时间
long start = System.currentTimeMillis();
long num = 0;
for (int i = 0; i < 800000; i++) {
num += i;
}
//结束的时间
long end = System.currentTimeMillis();
System.out.println("AA执行时间" + (end - start));
}
}
任务2:计算12…*800000 所需时间
public class BB {
public void job() {
//开始的时间
long start = System.currentTimeMillis();
long num = 0;
for (int i = 0; i < 800000; i++) {
num *= i;
}
//结束的时间
long end = System.currentTimeMillis();
System.out.println("BB执行时间" + (end - start));
}
}
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.job();
BB bb = new BB();
bb.job();
}
}
- 把公用的方法提取出来
AA
public class AA {
public void calculateTime() {
//开始的时间
long start = System.currentTimeMillis();
job();
//结束的时间
long end = System.currentTimeMillis();
System.out.println("执行时间" + (end - start));
}
public void job() {
long num = 0;
for (int i = 0; i < 800000; i++) {
num += i;
}
}
}
BB
public class BB {
public void calculateTime() {
//开始的时间
long start = System.currentTimeMillis();
job();
//结束的时间
long end = System.currentTimeMillis();
System.out.println("执行时间" + (end - start));
}
public void job() {
long num = 0;
for (int i = 0; i < 800000; i++) {
num *= i;
}
}
}
- 测试:
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime();
BB bb = new BB();
bb.calculateTime();
}
}
- 分析问题,使用模板设计模式来实现
- 定义一个抽象模板类Template
- 把 job 任务方法定义为 抽象方法
- 把 calculateTime 方法提取出来放在抽象类的模板中,调用 job 抽象方法
- AA、BB 分别继承抽象类 Template,分别实现抽象类中的 job 方法
AA
public class AA extends Template{
public void job() { //实现了Template类抽象方法job
long num = 0;
for (int i = 0; i < 800000; i++) {
num += i;
}
}
}
BB
public class BB extends Template {
public void job() {
long num = 0;
for (int i = 0; i < 800000; i++) {
num *= i;
}
}
}
Template:抽象模板类
abstract public class Template {
public abstract void job();//抽象方法
public void calculateTime() {//实现方法,调用job抽象方法
//开始的时间
long start = System.currentTimeMillis();
job();//动态绑定机制
//结束的时间
long end = System.currentTimeMillis();
System.out.println("执行时间" + (end - start));
}
}
测试:
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime();
BB bb = new BB();
bb.calculateTime();
}
}
【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱:
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论(0)