Java面向对象（4）—— 抽象方法、抽象类、接口

1、抽象方法

　　Java中抽象方法具有以下特性：
　　（1）由abstract修饰
　　（2）只有方法的定义，没有方法的实现（大括号都没有，用一个分号结尾。）

---

2、抽象类

　　Java中抽象类具有以下特性：
　　（1）由abstract修饰
　　（2）包含抽象方法的类必须是抽象类
　　　　不包含抽象方法的类也可以声明为抽象类（可选）
　　（3）抽象类不能被实例化
　　（4）抽象类是需要被继承的，所以abstract和final关键字不可以同时用于修饰一个类，子类：
　　　　4.1）重写所有抽象方法，不同的子类可以有不同的实现——–常用
　　　　4.2）也声明为抽象类——–不常用
　　（5）抽象类的意义：
　　　　5.1）封装子类中的重复内容（成员变量和方法）
　　　　5.2）为所有子类提供一个公共的类型—向上造型
　　　　5.3）包含抽象方法，为所有子类提供一个公共的入口
　　　　　　子类有不同的实现

package oop.day05;

public class ShapeTest {
    public static void main(String[] args) {
        //Shape s = new Shape();//错误，抽象类不能被实例化

       //new Shape数组
        Shape[] shapes = new Shape[2];
        shapes[0] = new Circle(1);
        shapes[1] = new Square(1);
        maxArea(shapes);
    }

    public static void maxArea(Shape[] shapes){
        double maxArea = shapes[0].area();
        int maxIndex = 0; //最大面积索引

        for(int i=1;i<shapes.length;i++){
            double area = shapes[i].area();
            if(area > maxArea){
                maxArea = area; //重置最大面积
                maxIndex = i;   //重置最大面积索引
            }
        }
        System.out.println("最大面积:" + maxArea + ",最大面积索引:" + maxIndex);
    }
}

abstract class Shape{  //抽象类
    double c;
    abstract double area(); //抽象方法
}

class Circle extends Shape{
    Circle(double c){
        this.c = c;
    }

    double area(){
        return 0.0796*c*c;
    }
}

class Square extends Shape{
    Square(double c){
        this.c = c;
    }

    double area(){
        return 0.0625*c*c;
    }
}

---

3、接口

　　Java中接口具有以下特性：
　　（1）是一个标准、规范
　　　　遵守了这个标准，就能干某件事—API后了解
　　（2）由interface定义
　　（3）只能包含常量和抽象方法
　　（4）接口不能被实例化
　　（5）接口是需要被实现/继承的，实现类/子类：
　　　　必须重写接口中的所有抽象方法
　　（6）一个类可以实现多个接口，用逗号分隔
　　　　若又继承又实现接口时，应先继承extends后实现implements
　　（7）接口可以继承接口

　　接口可以看成是特殊的抽象类，即只包含有抽象方法的抽象类。
　　接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象；通过该变量可以调用该接口中定义的方法（具体的实现类提供了方法的实现）。

package oop.day05;

public class InterfaceDemo {
    public static void main(String[] args) {
        错误，接口不能被实例化
        //Inter1 i = new Inter1();

        Inter1 i = new Goo(); //向上造型
        i.a();  //Goo的a方法
        i.b();  //Goo的b方法
        //i.show(); //错误，能点出来什么，看引用类型
    }
}

interface Inter1{
    void a();//接口的方法都默认加了public abstract，所以这里不用加
    void b();
}

interface Inter2{
    void c();
}

interface Inter3 extends Inter1{
    void m();
}

class Goo implements Inter1{
    void show(){}
    public void a(){}
    public void b(){}
}

class Foo implements Inter3{
    public void m(){}
    public void a(){}
    public void b(){}
}

abstract class Doo{
    int num;
    abstract void d();
}

class Eoo extends Doo implements Inter1,Inter2{
    public void a(){}
    public void b(){}
    public void c(){}
    void d(){}
}