JAVA-SE-抽象类和接口

一，抽象类

1.1什么是抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类，简单来说，抽象类就是由 abstract 关键字修饰的类，且抽象类内部中被 abtract 关键字修饰的方法(即抽象方法)可以不具体实现，例如：

//抽象类
abstract class A{
    //抽象方法
     public abstract void eat();
}

注意：1. 抽象类也是一种类，在普通类中定义的成员变量和成员方法都可以在抽象类中实现 

           2. 抽象方法只能在抽象类中定义，否则就会报错

           3. 抽象类和抽象方法都由abstract关键字修饰

1.2 抽象类的特性 

1. 抽象类不可以实例化对象，所以抽象类被定义的唯一用途就是被继承 

2. 抽象类被普通类继承后，抽象类中抽象方法必须被重写，这也就意味着，抽象方法不能被 static，private，final 修饰

3. 抽象类中可以不包含抽象方法，但是有抽象方法的类一定是抽象类

4. 象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

5. 抽象类A可以被抽象类B继承，但是如果普通类C继承了抽象类B，那么普通类C必须要重写抽象类A和抽象类B中的抽象方法

有的同学会问，抽象类可以做到的普通类也能做，那为什么还要有抽象类呢？

因为使用抽象类的话，在子类中如果没有重写抽象方法就会报错，而在普通类中就只是调用父类中的方法，总的来说，就是更加保险。

二，接口

2.1什么是接口

与类相似，只不过接口是由 interface 关键字修饰的，其中的成员变量一般是由 public static final 修饰，成员方法一般由 public abstract 修饰，例如：

//接口
interface IShape{
    public static final int a = 10;
    public abstract void eat();
}

1.2接口的语法

1. 创建接口时, 接口的命名一般以大写字母 I 开头

2. 接口当中的成员变量默认是由 public static final 修饰，成员方法默认是由 public abstract 修饰，一般我们不写，例如：

interface A{
    int a = 10;
    void eat();
}
//与上面的代码实际是一样的

3. 接口当中不能有普通的成员方法(即不能有具体实现)，除非用 default 或者 static 修饰，比如：

interface A{
    int a = 10;
    void eat();
    default public void SSS(){
        System.out.println("111");
    }
    public static void AAA(){
        System.out.println("222");
    }
}

  4. 与抽象类一样，接口也不可以实例化对象，因此需要一个类来实现，与继承类似，继承用extends，实现用 implements，例如：

interface A{
    int a = 10;
    void eat();
    default public void SSS(){
        System.out.println("111");
    }
    public static void AAA(){
        System.out.println("222");
    }
}

class B implements A{
//与抽象类相同，接口中的抽象方法也要重写
    @Override
    public void eat() {
        System.out.println("123");
    }
}

 5. 一个类只能有一个父类，但是却可以有多个接口，例如：

interface A{
    int a = 10;
    void eat();
}

interface B{
    int b = 10;
}

class C{
    public String name;
}
//中间用逗号隔开
class D extends C implements A,B{
    @Override
    public void eat() {
        System.out.println("123");
    }
}

  6. 在某种程度上，接口和父类一样，因为接口也可以实现动态绑定和向上转型，从而实现多态，例如：

interface Printer{
    void print();
}

class BlackPrinter implements Printer{
    public String A;
    @Override
    public void print() {
        System.out.println("打印黑白文件！");
    }
}
class ColorPrinter implements Printer{
    public String B;
    @Override
    public void print() {
        System.out.println("打印彩色文件！");
    }
}
public class Test {
    public void print(Printer printer) {
        printer.print();
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.print(new BlackPrinter());
        test.print(new ColorPrinter());
    }
}

(可以拿去与我多态的那篇博客对比一下)     

7. 重写接口中的抽象方法时，该方法必须用public修饰符修饰，因为接口中的抽象方法默认是

public abstract ，而重写方法的访问权限>=被重写的方法。

8. 接口中不能有静态代码块和构造方法