抽象类与接口

抽象类

一，抽象方法的定义：方法名前面被抽象修饰的方法

 abstract void f();//声明方法f()是抽象方法

二，抽象方法的几个特点：

1，抽象方法不能给出具体实现过程，注意是“不能”，若给出实现过程则会在编译时报错

2，抽象方法的访问权限不能是私有的，这很好理解，因为该方法就是为了被继承，让其子类来实现该方法的

3，抽象方法不能被final，static关键字修饰

三，抽象类的定义：类名前面被抽象修饰的类称为抽象类

abstract class B//声明类B是抽象类

四，抽象类的几个特点：

如图1所示，若一个类中含有抽象方法，则该类必须被声明为抽象类，换句话说，抽象类中可以没有抽象方法

2，抽象类可以含有成员变量，且成员变量的声明和使用和普通类是一样的

3，抽象类中的方法可以是抽象方法，也可以是普通的方法

4，抽象类可以没有构造函数，也可以有构造函数，构造函数为成员变量进行初始化

5，抽象类不能实例化，只能被其他类继承

6，抽象类可以被另一个抽象类继承，子抽象类可以不用实现父类的抽象方法

7，抽象类可以被普通类继承，普通类必须要实现父类的所有抽象方法

接口

一，接口的声明：

interface B//使用关键字interface，声明B是一个接口

二，接口的几个特点：

1，接口中可以含有成员变量，但只能声明为final static public，若不进行说明，则默认是final static public

2，接口中只能含有抽象方法，且只能声明为abstract public，若不进行说明，则默认是abstract public

3，一个类（这个类也可以是抽象类）可以实现多个接口，但如果有父类，继承父类必须写在实现接口前面

public class A extends B implements C,D//类A继承类B，且实现接口C、D

4，类中实现接口中的方法时，必须显式的声明为公共的，因为接口中的方法是public的

三，接口代码演示：

interface B//声明B是一个接口
{
    int a=20;//默认是final static public类型，且只能这样修饰
    void f();//默认被abstract public修饰，且只能这样修饰
}
public class A implements B//类A实现接口B
{
    public void f()//实现接口B的方法，必须声明为public，因为接口中f()是public
    {
        System.out.println("This is the f function in abstract interface B");
    }
    public static void main(String []args)
    {
        A p=new A();
        p.f();
        System.out.println(p.a);
    }
}

四、一些常用的接口

关于比较的说明：

比较返回值有负数、0、正数。表示的含义：如果是负数，则左边小于右边；如果是0，则左边等于右边；如果是正数，则左边大于右边

1、Comparable<进行比较的类型>接口

使用方法：需要进行比较的类继承该接口，然后在类里实现compareTo(进行比较的类型 对象a)方法

代码演示：

public class Test
{
    public static void main(String[] argv)
    {
        student a[]=new student[]{new student(12,"aa"),new student(11,"bob")};
        Arrays.sort(a);
        for (int i = 0; i < a.length; i++)
        {
            System.out.println(a[i].age+a[i].name);
        }
    }
}
class student implements Comparable<student>
{
    int age;
    String name;
    student(int a,String nn)
    {
        age=a;
        name=nn;
    }
    public int compareTo(student b)
    {
        if(age==b.age)
            return name.compareTo(b.name);
        return age-b.age;
    }
}

2、Comparator<需要进行比较的类型>接口

使用方法：声明一个类继承该接口，然后在声明的类里实现compare（进行比较的类型 对象a,进行比较的类型 对象b）方法，在排序时，在参数里可以实例化声明的类来指明比较规则

代码演示：

import java.util.*;
public class Test
{
    public static void main(String[] argv)
    {
        student a[]=new student[]{new student(12,"aa"),new student(11,"bob")};
        Arrays.sort(a,new comp());
        for (int i = 0; i < a.length; i++)
        {
            System.out.println(a[i].age+a[i].name);
        }
    }
}
class student
{
    int age;
    String name;
    student(int a,String nn)
    {
        age=a;
        name=nn;
    }
}
class comp implements Comparator<student>
{
    public int compare(student a,student b)
    {
        if(a.age==b.age)
            return a.name.compareTo(b.name);
        return a.age-b.age;
    }
}