JavaSE 基础 第36节 抽象类概述与使用

2016-06-29

1 抽象类的定义

抽象类是为子类提供一个规范。

修饰符 abstract 类名{
//类体
修饰符 abstract 返回值类型 方法名(参数列表);
}

抽象方法没有方法体：public abstract void test();
普通方法有方法体： public void test(){//方法体内的代码};

1、定义一个类，如果这个类是抽象类，那么这个类中至少有一个抽象方法。
2、抽象类的方法不一定是抽象方法，但是含义抽象方法的类一定是抽象类。

package com.java1995;
/**
 * 抽象类：猫科动物类
 * @author Administrator
 *
 */
public abstract class Feline {
    /**
     * 封装
     */
    private int legCount=4;//定义腿的数量
    private String headShape="round";//定义脑袋的形状
    private boolean meatEater=true;//定义是否为食肉动物，默认为是
    
    /**
     * 抽象方法：捕食
     * @param animal
     */
    public abstract void catchAnimal(Animal animal);
    
    /**
     * 普通方法：叫喊
     */
    public void cry(){
        System.out.println("动物在狂吼");
    }
    
    /**
     * 封装的实现
     * @return
     */
    public int getLegCount() {
        return legCount;
    }

    public void setLegCount(int legCount) {
        this.legCount = legCount;
    }

    public String getHeadShape() {
        return headShape;
    }

    public void setHeadShape(String headShape) {
        this.headShape = headShape;
    }

    public boolean isMeatEater() {
        return meatEater;
    }

    public void setMeatEater(boolean meatEater) {
        this.meatEater = meatEater;
    }

}

2 抽象类的使用

package com.java1995;
/**
 * 父类、被被捕食类：动物类
 * @author Administrator
 *
 */
public class Animal {

}

package com.java1995;

/**
 * 子类、被被捕食类：老鼠类
 * @author Administrator
 *
 */
public class Mouse extends Animal {

}

package com.java1995;
/**
 * 抽象类的子类：老虎
 * @author Administrator
 *
 */
public class Tiger extends Feline{
    
    /**
     * 重写抽象方法：老虎的捕食
     */
    @Override
    public void catchAnimal(Animal animal) {
        // TODO Auto-generated method stub
        System.out.println("老虎在捕食");
        
    }
    
    public static void main(String[] args) {
        Mouse mouse=new Mouse();
        Tiger t=new Tiger();
        t.catchAnimal(mouse);
    }

}

package com.java1995;
/**
 * 抽象类的子类：猫
 * @author Administrator
 *
 */
public class Cat extends Feline{
    
    /**
     * 重写抽象方法：猫的捕食
     */
    @Override
    public void catchAnimal(Animal animal) {
        // TODO Auto-generated method stub
        //首先要判断捕食的animal是否为老鼠，如果是，可以捕食
        if(animal instanceof Mouse){
            System.out.println("猫正在捕食老鼠");
        }else{
            System.out.println("猫不能捕食它");
        }
    }
    
    public static void main(String[] args) {
        Mouse mouse =new Mouse();
        Cat cat=new Cat();
        cat.catchAnimal(mouse);
    }

}

 @Override 用来检测是否重写成功。
1、一个类继承了抽象类，就必须重写该抽象类的所有抽象方法。
2、如果有一个类没有重写抽象类的抽象方法，那么这个类也要定义为抽象类。

package com.java1995;
/**
 * 抽象方法类
 * @author Administrator
 *
 */
public abstract class Test {
    /**
     * 抽象方法
     */
    public abstract void test1();
    public abstract void test2();

}

package com.java1995;
/**
 * 抽象方法类的子类
 * @author Administrator
 *
 */
public class SubTest extends Test{

    /**
     * 一个类继承了抽象类，就必须重写该抽象类的所有抽象方法
     *  @Override用来检测是否重写成功。
     */
    @Override
    public void test1() {
        // TODO Auto-generated method stub
        System.out.println("方法1");
        
    }

    @Override
    public void test2() {
        // TODO Auto-generated method stub
        System.out.println("方法2");

    }
}

package com.java1995;
/**
 * 如果有一个类没有重写抽象类的抽象方法，那么这个类也要定义为抽象类
 * @author Administrator
 *
 */
public abstract class AbstractTest1 {
    public abstract void test();
    
    public void test2(){
        System.out.println("这是普通方法");
    }

}

【参考资料】

[1] Java轻松入门经典教程【完整版】