1.抽象类

抽象方法是只有方法签名，没有方法实现的方法。有抽象方法的类只能被定义成抽象类，抽象类可以没有抽象方法。抽象方法和抽象类必须使用abstract修饰符来定义。

抽象类不能被实例化，抽象类可以包含方法（抽象和普通）、成员变量、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要用于被其子类调用。

public abstract class Shape {

    {

        System.out.println("执行Shape的初始化块");

    }

    private String color;

    public abstract double calPerimeter();

    public abstract String getType();

    public Shape() {

    }

    public Shape(String color) {

        System.out.println("执行Shape的构造器");

        this.color = color;

    }

   set,get.....

}

-----------------------------------------------------------------------------public class Triangle extends Shape {

    public static void main(String[] args) {

        Shape triangle = new Triangle("red", 1, 2, 2);

        System.out.println(triangle.calPerimeter());

        System.out.println(triangle.getType());

    }

    private double a;

    private double b;

    private double c;

    public Triangle(String color, double a, double b, double c) {

        super(color);

        this.setSides(a,b,c);

    }

    public void setSides(double a,double b,double c){

        if(a+b<=c||a+c<=b||b+c<=a){

            System.out.println("三角形两边之和必须大于第三边");

            return;

        }

        this.a = a;

        this.b = b;

        this.c = c;

    }

    @Override

    public double calPerimeter() {

        return a+b+c;

    }

    @Override

    public String getType() {

        return "三角形";

    }

    static abstract class test{

    }

}

final和abstract不能同时使用，static和abstract不能同时使用（并不是绝对互斥，可以同时修饰内部类）。

抽象类避免了子类设计的随意性，抽象类体现的就是一种模板模式的设计。

2.Java 8改进的接口

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行进行的更彻底，则可以提炼出一种更加特殊的“抽象类”-----接口。接口里不能包含普通方法，接口里所有的方法都是抽象方法。Java 8 以后，允许在接口中定义默认方法，默认方法可以提供方法实现。

接口体现的是规范和实现分离的设计哲学。

[修饰符] interface 接口名 extends 父接口1，父接口2...

{

  零个到多个常量定义...

  零个到多个抽象方法定义...

  零个到多个内部类、接口、枚举定义...

  零个到多个默认方法或类方法定义...

}

接口定义的是一种规范，因此接口里不能包含构造器和初始化代码块定义。接口里可以包含成员变量（只能是静态常量），方法（抽象、默认、类），内部类（包括内部接口、枚举）定义。

//系统自动为接口里定义的成员变量增加public static final修饰符int MAX_SIZE=50;public static final MAX_SIZE=50;

接口里的普通方法不管是否使用public abstract修饰符，系统自动为接口里定义的普通方法增加public abstract修饰符。

接口里定义的内部类、内部接口、内部枚举默认都采用public static修饰符。

public interface Output {

    int MAX_CACHE_INT=50;

    void out();

    void getData(String msg);

    default void print(String... msgs){

        for(String msg:msgs){

            System.out.println(msg);

        }

    }

    default void test(){

        System.out.println("默认的test()方法");

    }

    static String staticTest(){

        return "接口里的类方法";

    }

}

3.接口和抽象类

相同点：

· 接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。

· 接口和抽象类都可以包含抽象方法，实现接口或继承抽像类的普通子类必须实现这些抽象方法。

不同点：

· 接口里只能包含抽象方法和默认方法，不能为普通方法提供方法实现；抽象类则可以包含普通方法。

· 接口里只能定义静态常量；抽象类可以定义普通成员变量。

· 接口里不包含构造器，初始化块；抽象类包含。

4.内部类

内部类的作用：

· 提供更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。

· 内部类成员可以直接访问外部类的私有数据。

· 匿名内部类适合用于创建那些仅需要一次使用的类。

内部类比外部类多使用三个修饰符：private、protected、static，非静态内部类不能拥有静态成员。

在Java 8之前，被局部内部类、匿名内部类访问的局部变量必须使用final修饰，Java 8以后不必，系统默认。

以上就介绍了JAVA的相关知识，希望对JAVA有兴趣的朋友有所帮助。了解更多内容，请关注职坐标编程语言JAVA频道！