Java——抽象类与接口

抽象类

在 Java 中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法。

【注意】：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法

抽象类的特性

• 抽象类是不能进行实例化的
• 抽象类可以和普通类一样定义成员变量与成员方法
• 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，
  必须要使用 abstract 修饰
• 抽象方法不能被private、static、final所修饰，因为抽象方法要被子类重写
• 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
• 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

接口

在Java中，接口可以看作是多个类的公共规范，是一种引用数据类型。接口不能直接使用，必须要有一个“实现类”来实现该接口。

接口是使用interface来修饰的。

//语法规则
public interface 接口名称{
// 抽象方法
    public abstract void method1(); // public abstract 是固定搭配，可以不写
    void method4();// 注意：更推荐这种方式，代码更简洁
}

接口特性

• 接口当中不能有被实现的方法，即只能有抽象方法。接口中的方法会被隐式的指定为 public abstract

但是有两个方法除外：一个是被static修饰的方法，一个是被default修饰的方法

• 接口是一种引用类型，但是不能直接new接口的对象。因为接口是抽象的，无法实例化
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现。类和接口之间的关系，可以使用inplements来进行关联（即这个类实现了这个接口）
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
• 重写接口中方法时，不能使用默认的访问权限
• 接口中不能有静态代码块和构造方法
• 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
• 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承。但是一个类可以实现多个接口。

【注意】：

一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

 接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。接口间的继承相当于把多个接口合并在一起。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字

接口实例

class Student {
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Test{
 public static void main(String[] args) {
        //利用比较器排序
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",10);
        students[1] = new Student("lisi",11);
        students[2] = new Student("wangwu",9);
        System.out.println("排序前： " + Arrays.toString(students));

        AgeComparator ageComparator = new AgeComparator();
        //NameComparator nameComparator = new NameComparator();

        Arrays.sort(students,ageComparator);
       // Arrays.sort(students,nameComparator);



        System.out.println("排序后: " + Arrays.toString(students));
    }
}

class Student {
    public String name;
    public int age;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void bubbleSort(Comparable[] comparables) {
        //模拟实现排序
        for (int i = 0; i < comparables.length-1; i++) {
            for (int j = 0; j < comparables.length-1-i; j++) {
                if (comparables[j].compareTo(comparables[j+1])>0) {
                    Comparable tmp = comparables[j];
                    comparables[j] = comparables[j+1];
                    comparables[j+1] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("zhangsan",10);
        students[1] = new Student("lisi",11);
        students[2] = new Student("wangwu",9);
        System.out.println("排序前： " + Arrays.toString(students));

        bubbleSort(students);


        System.out.println("排序后: " + Arrays.toString(students));
    }
}

• Comparable  对类的侵入性比较强。一旦写好了规定的比较方式，那么以后只能以这种方式进行比较了
• Comparator 比较灵活。只需要传入两个要比较的对象就可以了

抽象类和接口的区别

抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。

区别	抽象类	接口
结构组成	普通类+抽象方法	抽象方法+全局常量
权限	各种权限	public
子类使用	使用extends关键字继承抽象类	使用implements关键字实现接口
关系	一个抽象类可以实现若干接口	接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
子类限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口

Object类

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

在开发之中，Object类是参数的最高统一类型。

获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法

对象比较

在Java中，==进行比较时：

• 如果==左右两侧是基本类型变量，比较的是变量中值是否相同
• 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
• 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。

内部类也是封装的一种体现。

【注意】

1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

实例内部类

即未被static修饰的成员内部类。

【注意事项】

1. 外部类中的任何成员都可以在实例内部类方法中直接访问

2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束

3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问

4. 实例内部类对象必须在先有外部类对象前提下才能创建

5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用

6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象

静态内部类

 被static修饰的内部成员类称为静态内部类。

【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员

如果确实想访问，在内部类中实例化外部类，再利用实例化对象访问

2. 创建静态内部类对象时，不需要先创建外部类对象

局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用

2. 不能被public、static等修饰符修饰

3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class

class OuterClass {
    public int data1 = 1;
    public static int data2 = 2;
    private int data3 = 3;
    class InnerClass {
        //实例内部类
        public int data1 = 10;
        public int data4;
        //public static int data5 = 5;
        public static final int data5 = 5; //static 需要加final
        private int data6 = 6;
        public void test() {
            System.out.println("InnerClass::test()");
            System.out.println(data1);
            System.out.println(OuterClass.this.data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);

        }

    }

    public void test() {
        InnerClass innerClass = new InnerClass();
        System.out.println("OuterClass::test()");
    }

}
class Out {
    public int data1 = 1;
    public static int data2 = 2;
    private int data3 = 3;

    static class InnerClass {
        //静态内部类
        public int data4;
        public static final int data5 = 5;
        private int data6 = 6;
        public void test() {
            Out out = new Out();
            System.out.println("InnerClass::test()");
            System.out.println(out.data1);
            System.out.println(data2);
            System.out.println(out.data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public void test() {
        System.out.println("Out::test()");
    }
}
interface IA {
    void test();
}
public class Test {
    
    public void func() {
        class A {
            //局部内部类，只能在方法体中使用
            public int a;
        }
        A aa = new A();
        System.out.println(aa.a);
    }
    public static void main(String[] args) {
        //静态内部类
        Out.InnerClass innerClass = new Out.InnerClass();
        innerClass.test();
    }
    public static void main1(String[] args) {
        //实例内部类
        //实例化一个内部类对象
       /* OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();*/

        //OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();

        innerClass.test();
    }
}