抽象方法和抽象类
当父类的某些方法,需要声明,但是又不确定如何实现时,可以用abstract关键字修饰该方法这个方法就变成了抽象方法。
同理用abstract修饰类该类就是抽象类。抽象方法只能存在抽象类中
- 用abstract修饰一个类,那么该类就是抽象类
- 用abstract修饰一个方法,这个方法就是抽象方法。抽象方法没有方法体
- 抽象类的价值定位是在于设计,设计好之后让子类去实现
抽象方法
举例说明:
现在有一个Animal类,这是一个动物类,所有的动物都有一个行为,就是吃。所以定义一个eat方法,但是由于现在不知道它是什么动物 ,所以不知道它吃什么。也就是父类的不确定性,此时就需要使用abstract修饰eat方法,使其可以不被实现,也就是不用写方法体。
abstract class Animal{
private String name;
public abstract void eat();
}
上面将Animal类变成了一个抽象类,将eat变成了一个抽象方法。所以eat可以不用具体实现,没有方法体。
那么一般抽象类的抽象方法一般是由子类去实现的。
抽象类注意事项
- 抽象类不能被实例化
- 抽象类可以没有抽象方法,但是抽象方法必须在抽象类中
- 一旦方法被声明为abstract抽象方法,那么该类必须也声明abstract为抽象类
- abstract只能修饰类和方法,不能修饰其他
- 抽象类本质上还是一个类,也可以有任意成员:非抽象方法,构造器,静态属性…
- 抽象方法不能有主体
- 如果一个类继承了抽象类,则该类必须实现抽象类的所有抽象方法,除非该类也声明为一个抽象类
就相当于老板布置了目标,交给主管,主管比较懒不想完成,所以又交给了底层员工。总之只要继承了抽象类,只有也变成抽象类,或者实现抽象方法。两条路
- 抽象方法不能和 private final static关键字一起使用,因为抽象方法需要子类重写实现,但是这三个关键字会 阻止子类重写
private :除了本类,其他地方无法调用。自然子类无法进行重写
final:final声明在方法就是意味着 这是最终的了,不可以被改动。子类也无法重写
static:因为抽象类是无法被实例化的,也就是无法被分配内存。而static在加载的时候就已经会分配内存。于此static和abstract会产生冲突。所以无法一起使用
抽象类练习
- abstract final class A{}能编译通过吗 ?
不能,因为final修饰的方法,子类不可以重写
- abstract public static void test2();能编译通过吗 ?
不能,因为static和abstract会产生冲突
- abstract private void test3();能编译通过吗 ?
不能,因为private修饰的,子类无法重写
- 编写一个Employee类,声明为抽象类,包含如下三个属性:name id salary 提供构造器和抽象方法work(),对于Manager类来说,他即是员工,还具有奖金bonus的属性。请设计CommonEmployee类和Manager类,要求类中提供必要的方法进行属性访问,实现work()。
public class test12 {
public static void main(String[] args) {
Manager wang = new Manager("王中",2333,10000,2999);
wang.work();
CommonEmployee li = new CommonEmployee("李三",899,9000);
li.work();
}
}
abstract class Employee{
private String name;
private int id;
private double sal;
public abstract void work();
public Employee(String name, int id, double sal) {
this.name = name;
this.id = id;
this.sal = sal;
}
public String getName() {
return name;
}
public int getId() {
return id;
}
public double getSal() {
return sal;
}
}
class Manager extends Employee{
private double bonus;
public Manager(String name, int id, double sal, double bonus) {
super(name, id, sal);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理:"+getName()+"正在工作中");
}
}
class CommonEmployee extends Employee{
public CommonEmployee(String name, int id, double sal) {
super(name, id, sal);
}
@Override
public void work(){
System.out.println("普通员工:"+getName()+"正在工作中");
}
}
抽象类体现实践
- 设计一个类Template
- 编写一个抽象方法job
- 编写一个Time()方法可以计算job方法完成的时间是多少
- A类和B类都是Template的子类,A类的job方法计算1+…70000,B类的job计算1+…80000
- 计算一下A和B的job方法完成需要多少时间
System.currentTimeMills();可以获取时间,分别获取两次,相减即可获得差
public class Test {
public static void main(String[] args) {
A a = new A();
a.Time();
B b = new B();
b.Time();
}
}
abstract class Template{
public abstract void job();
public void Time(){
long start = System.currentTimeMillis();
job();
long end = System.currentTimeMillis();
System.out.println("完成时间为:"+(end - start));
}
}
class A extends Template{
@Override
public void job(){
for (int i = 1; i <=700000 ; i++) {
i+=i;
}
}
}
class B extends Template{
@Override
public void job(){
for (int i = 1; i <=900000 ; i++) {
i+=i;
}
}
}