Java抽象类

抽象类
1、抽象方法：父类定义的方法，子类肯定会重写，父类中不要方法实现，只有方法的声明
没有方法体的方法就是抽象方法
有方法体的方法 public void shout（）{方法体}
抽象方法public abstract void shout()
2、有抽象方法的类必须定义成抽象类
public abstract class Test{}

抽象类的使用
1、抽象类不能直接new其本身的实例，不能直接Animal an=new Animal（）；就如同一个未完成的设计图，不能生产产品，但是可以new其子类的实例（子类必须实现（重写父类所有的抽象方法）：Animanl an=new Cat();多态的用法）
2、抽象类是用来被继承的
抽象方法是被用来子类实现的
3、子类有两种选择
1、子类必须实现（重写）父类的所有抽象方法
2、子类可以继续声明为抽象类

public class Main {
    public static void main(String[] args) {


        Animal cat = new Cat();
        Animal dog = new Dog();
        Cat cat2=new Cat();
        cat.eat();
        dog.eat();
        cat2.setFood("老鼠");
        cat2.eat();


    }

}

// 定义一个父类
/**
 * Animal
 */
abstract class Animal {
    private String name;
    private int age;

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void call() {
        System.out.println("动物的叫声");
    }

    public void eat() {
        System.out.println("动物的食物");
    }
    // 定义抽象类
    public abstract void test();
}

/**
 *  
 */
class Cat extends Animal {
    private String food;

    public void setFood(String food) {
        this.food = food;
    }

    public String getFood() {
        return food;
    }

    public void eat() {
        System.out.println("小猫吃" + food);
    }
 @Override
 public void test() {
     // TODO Auto-generated method stub
     System.out.println("子类必须实现抽象类");
 }
}

/**
 * InnerMain
 */
class Dog extends Animal {
    private String food;

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    @Override
    public void eat() {
        System.out.println("小狗吃" + food);
    }

    @Override
    public void test() {
        // TODO Auto-generated method stub
        System.out.println("实现父类的抽象方法");
    }
}
// 定义为抽象类不用实现父类的抽象方法
abstract class  Test extends Animal {

    
}

抽象类的特点
1、抽象类可以有0个或者多个抽象方法
2、抽象类中可以有成员变量，成员方法，构造方法，比具体类多抽象方法
3、抽象类首先是一个类，要遵循is 安定关系，子类是一中父类时才能继承
抽象类的作用，抽象类是一个（模板）子类必须实现父类所有的抽象方法，避免了子类设计的随意性，使子类之间更加通用
抽象类练习
计算不同图像的面建和周长

public class Main {
    public static void main(String[] args) {

        Shape cc = new Circls(3.2);
        Shape sq = new Square(3.3);
        System.out.println(cc.getArea());
        System.out.println(cc.getLength());
        System.out.println(sq.getArea());
        System.out.println(sq.getLength());

    }

}

// 定义一个父类
/**
 * 定义一个抽象父类
 */

abstract class Shape {

    public abstract double getArea();

    public abstract double getLength();

}

// 定义子类实现父类的抽象方法
class Circls extends Shape {
    private double r;// 半径
    static final double PI = 3.14;

    // 定义无参构造
    public Circls() {

    }

    // 定义有参构造
    public Circls(double r) {
        this.r = r;
    }

    @Override
    public double getArea() {
        double area = PI * Math.pow(r, 2);
        return area;
    }

    @Override
    public double getLength() {
        // TODO Auto-generated method stub
        double length = 2 * PI * r;
        return length;
    }

}

// 子类实现
class Square extends Shape {
    private double length;

    // 定义无参构造
    public Square() {

    }

    // 定义有参构造
    public Square(double length) {
        this.length = length;
    }

    @Override
    public double getArea() {
        // TODO Auto-generated method stub
        double area = Math.pow(length, 2);
        return area;
    }

    @Override
    public double getLength() {
        // TODO Auto-generated method stub
        double length = 4 * this.length;
        return length;
    }

}