抽象类的引出
当父类的某些方法需要声明,但是又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类。
package com.pero.abstract_;
/**
* 抽象类的引出
*
* @version 1.0
* @author Pero
*/
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal{
private String name;
public Animal(String name){
this.name = name ;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//在这里实现eat()方法并没有什么意义
//将该方法设计为抽象(abstract)方法
//抽象方法就是没有实现的方法,也就是没有方法体
//当一个类中存在抽象方法时,那么这个类是抽象类,需要用abstract来修饰
//抽象类会被继承,由子类实现抽象方法
// public void eat(){
// System.out.println("某某动物,喜欢吃什么");
// }
public abstract void eat();
}
抽象类的介绍
1)用abstract关键字来修饰一个类时,这个类就是抽象类;
访问修饰符 abstract 类名 {
}
2)用abstract关键字修饰一个方法时,这个方法就是抽象方法;
访问修饰符 abstract 返回类型 方法名 (参数列表);//没有方法体
3)抽象类的价值更多作用在于设计,设计好后让子类继承并实现抽象类;
4)抽象类,在框架和设计模式中使用较多。
抽象类使用注意事项和细节
1)抽象类不能被实例化;
public class Abstract02 {
public static void main(String[] args) {
//new Person(); 错误,抽象类不能被实例化
}
}
abstract class Person{ }
2)抽象类不一定包含抽象(abstract)方法,可以有实现的方法;
//抽象类
abstract class Person{
//普通方法
public void study(){
System.out.println("正在学习!");
}
//没有定义抽象方法
}
3)一旦类包含了抽象(abstract)方法,则一定要声明为抽象(abstract)类;
abstract class Animal{
//当一个类中存在抽象方法时,那么这个类是抽象类,必须要用abstract来修饰
public abstract void eat();
}
4)abstract只能修饰类和方法,不能修饰属性和其他;
5)抽象方法可以有任意成员(抽象类本质还是类),比如:非抽象方法、静态和非静态属性、构造器等等;
package com.pero.abstract_;
/**
* 抽象方法可以有任意成员(抽象类本质还是类)
*/
public class Abstract03 {
public static void main(String[] args) {
}
}
abstract class Student {
//私有属性
private String name;
private final static int AGE;
//静态方法体
static {
AGE = 18;
}
//构造器
public Student(String name){
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public static int getAGE() {
return AGE;
}
//抽象方法
public abstract void say();
}
6)抽象方法不能有主体,因为不能实现;
7)如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它也声明为抽象(abstract)类。
package com.pero.abstract_;
/**
* 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它也声明为抽象(abstract)类
*
* @version 1.3
* @author Pero
*/
public class Abstract04 {
public static void main(String[] args) {
}
}
abstract class A{
//抽象方法
public abstract void hi();
//非抽象方法
public void study(){
System.out.println("正在学习");
}
}
//抽象类的子类要不定义为抽象类,要不就实现抽象类的所有抽象方法
/*abstract*/class B extends A{
//所谓实现方法,就是方法有方法体,方法体具体有什么不管(可为空)
public void hi(){
System.out.println("你好");
}
//非抽象方法不一定要实现
}
8)抽象方法不能使用private、final和static 来修饰,因为这些关键字与重写相违背。
package com.pero.abstract_;
/**
* 抽象方法不能用private、final和static来修饰,这些关键字与重写相违背
*/
public class Abstract05 {
public static void main(String[] args) {
}
}
abstract class Father{
public abstract void hi();
//private abstract void hi(); 错误,私有的方法,子类继承后无法重写
//final abstract void hi(); 错误,final修饰的方法子类无法重写
//static abstract void hi(); 错误,static方法可以直接采用类形式调用,static和abstract是非法组合
}
抽象模板模式
1)设计一个抽象类
2)将子类中重复动作的方法在抽象类中写成一个非抽象方法,用于继承执行
3)将子类中独特动作的相同方法写成一个抽象方法,用于子类重写,由于动态绑定机制,子类会执行重写方法的特有动作
抽象类模板的父类:
package com.pero.abstract_;
/**
* 抽象类模板的父类
*/
public abstract class Template {
public abstract void job();
public void calculateTime(){
//得到开始时间
long start = System.currentTimeMillis();
job(); //动态绑定机制,执行子类中的job()方法
//得到结束的时间
long end = System.currentTimeMillis();
System.out.println("执行时间"+(end-start));
}
}
抽象类模板中的子类:
package com.pero.abstract_;
/**
* 测试抽象类模板
*/
public class AbstractExercise01 {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime();//执行从父类中继承的calculateTime()方法
}
}
class AA extends Template{
//计算任务
//1+.....+10000
public void job(){ //重写父类中的job()方法
long number = 0;
for (long i = 0; i <= 100000; i++) {
number += i;
}
}
}