Java基础—抽象类和接口定义及区别、内部类（静态内部类、实例内部类、匿名内部类）

最新推荐文章于 2022-03-22 15:01:58 发布

Angety

最新推荐文章于 2022-03-22 15:01:58 发布

阅读量580

点赞数

分类专栏： JAVA基础文章标签： java

本文链接：https://blog.csdn.net/weixin_52717049/article/details/117373623

版权

抽象类接口内部类匿名内部类 Java编程

关键词由CSDN通过智能技术生成

JAVA基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

抽象类

如果一个类中没有包含足够的信息来描绘一个具体的对象，我们可将之称之为抽象类。抽象类的性质包括以下几点：1.无法创建或者不应该创建实例；2.无法定义方法的主体。其内容应该在实例中实现。3.一个类只能继承一个抽象类。4.抽象类的访问限定符不能是private。

抽象类可以包含抽象方法，也可以没有抽象方法，抽象方法一定是抽象类。包含抽象方法的类一定要设计为抽象类。实例类可以实例化对象，抽象类不能实例化对象。普通类extends抽象类：必须实现抽象类的抽象方法。

接口

接口的定义包括接口声明和接口体两部分，接口规定一个类可以做什么，而不规定它如何去做。

接口比抽象类更加抽象（全部都是抽象）。接口不能实例化对象。访问限定符默认是public。

接口只能包含两种：只有抽象方法和常量。它提供统一的函数。

interface 接口名{

public static final int INITSIZE =10; //修饰符必须是public static final

public abstract void search(int value); //抽象方法 public abstract，在声明时可以省略

}

接口不能实现接口，但接口可以继承一个或多个接口；类和接口之间是实现（inplements）的关系；

public interface list{
    public static final int INITSIZE=10;    //常量
    public abstract void addHead(int value);    
    public abstract void addTail(int value);
    public abstract boolean search(int value);
}

类和接口之间是实现（implements）的关系，实例类要实现接口中的所有抽象方法。

public class MyArraryList implements list{ //类和接口之间是实现的关系  实例类要实现接口里的所有抽象方法  
    private int[] element;
    private int size;
    
    public MyArrayList(int size){
        int[] element=new int[list.INITSIZE];
        this.size=size;
    }
    @Override        //方法重写
    public void addHead(int value){

    }
    @Override
    public void addTail(int value){
    
    }
    @Override
    public boolean search(int value){

    }
}

若只实现接口（list）里的部分抽象方法，则剩下的抽象方法仍在My中，类My中包含抽象方法，则需要把类My设计成抽象类

public abstract class My implements list{
   //实现部分抽象方法
}

接口和抽象类的区别

语法层面上

抽象类可以提供方法的实现细节、成员变量可以是各种类型的，可含有静态方法、静态块。
接口中的方法是public abstract，成员变量必须是public static final 的类型的，没有静态方法、静态块。
一个类只能继承一个抽象类，可以实现多个接口。
抽象类可以有构造函数，接口不可以有。（抽象类中可以有普通变量，可以用构造方法初始化这些变量；接口中只要静态变量，构造方法没有意义）

在设计层面上

抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。继承是一个 "是不是"的关系，接口实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系。

对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

内部类

在外部类中在嵌套一个类，这个类称为内部类。内部类和外部类中的函数是并列的。

内部类的语法

内部类访问外部类的属性时外部类的属性前省略了outClass.this.

public class outClass{
    private int outInt;

    private outClass(int outInt){
        this.outInt = outInt;
    }

    public class InnerClass{     //实例内部类
        void fun(){
            outClass.this.outInt=10;   //内部类里面使用外部类里的属性
                                       // 也可写成outInt=10;  省略了outClass.this.
        }
    }
}

生成内部类对象

在main方法中生成内部类对象，即new InnerInt；

生成实例内部类对象

outClass out = new outClass(); //依赖于外部类对象，生成外部类对象

outClass.InnerClass 变量名 = out.new InnerClass(); //outClass 中的InnerClass，依赖于外部类对象new生成内部类对象

outClass out = new outClass();
outClass.InnerClass 变量名  = out.new InnerClass();

生成静态内部类对象

静态内部类对象是outClass中的InnerClass中的,在作用域中生成即可。

outClass.InnerClass 变量名 =new outClass.InnerClass ();

outClass.InnerClass 变量名 = new outClass.InnerClass();

静态内部类和实例内部类的区别

1.实例内部类前没有static关键字修饰，使用外部类的属性时写法为outClass.this.outInt=10;

静态内部类用static关键字修饰，在内部类中，不能使用外部类的属性和方法，如果内部类不用使用外部类的属性或方法，则可以用static修饰。

public class outClass {
    private int outInt;

    public outClass(int outInt) {
        this.outInt = outInt;
    }
    public void outFun(){
        System.out.println("outFun");
    }

    public static class InnerClass{   // 静态内部类  
        private int InnerInt;

        public InnerClass(int innerInt) {
            InnerInt = innerInt;
        }
        public void InnerFun(){
            System.out.println("InnerFun");
        }
    }
}

2.在使用实例内部类时，需要使用内部类自身的this 也要使用外部类的this，而静态内部类则只需要使用内部类自身的this开销较之实例内部类小。若一个类可以同时使用静态内部类和实例内部类，则选用静态内部类；如要访问外部类的属性，则选择实例内部类。

匿名内部类

匿名内部类就是没有名字的内部类。它只能使用一次，通常用简化代码来编写。匿名内部类必须继承一个父类或实现一个接口。

如下面的代码，使用Comparator接口中的compare方法比较两个Student1对象S1，S2的成绩，只使用接口，在main方法中通过new一个Com类的com对象来调用。

class Com implements Comparator<Student1>{
    @Override
    public int compare(Student1 o1, Student1 o2) {
        if(o1.getScore() >o2.getScore()){
            return 1;
        }if(o1.getScore() == o2.getScore()){
            return 0;
        }else{
            return -1;
        }
    }
}
public class Student1 {
    private String name;
    private int age;
    private int score;

    public Student1(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public int getScore() {
        return score;
    }
}

public static void main(String[] args) {
        Student1 S1=new Student1("zs",13,90);
        Student1 S2=new Student1("lisi",13,98);
        Com com = new Com();
        System.out.println(com.compare(S1,S2));

以下是使用匿名内部类的方法，基接口的引用，引用实现接口的类对象，接口不能实例化，所以在Comparator接口下定义一个实现该接口的内部类，在匿名内部类中实现compare方法，即引用实现接口的类对象。

public class Student1 {
    private String name;
    private int age;
    private int score;

    public Student1(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public int getScore() {
        return score;
    }
}
public static void main(String[] args) {
        Student1 S1=new Student1("zs",13,90);
        Student1 S2=new Student1("lisi",13,98);
        Comparator<Student1> comparator = new Comparator<Student1>() {   //匿名内部类的使用
            @Override
            public int compare(Student1 o1, Student1 o2) {
                if (o1.getScore() > o2.getScore()) {
                    return 1;
                }
                if (o1.getScore() == o2.getScore()) {
                    return 0;
                } else {
                    return -1;
                }
            }
        };
    System.out.println(comparator.compare(S1,S2));
}