1.抽象类

1.1 抽象类概念

抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，包含抽象方法的类也必须使用abstract class声明。

1.1.1 抽象类定义规则

  1. 抽象类和抽象方法都必须用abstract关键字来修饰；
  2. 抽象类不能直接实例化，即不能使用new关键字去产生对象；
  3. 抽象类定义时抽象方法只需声明，而不需实现；
  4. 含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

1.2 抽象类声明

访问权限  abstract class 类名 {
    // 声明成员变量
    访问权限 变量类型 成员变量名;
    // 声明一般方法
    访问权限 返回类型 方法名(){
        // ...
    }
    // 声明抽象方法
    abstract 返回类型 方法名();
}

实例

/**
 * description:
 *
 * @author : Mr.Liuqh
 * @since : 2019-10-31 18:51
 */
public abstract class People {
    // 声明成员变量
    private String name;

    // 声明一般方法
    public String getName(){
        return this.name;
    }

    // 声明抽象方法
    abstract String like();
}

由上可知:抽象类的定义就是比普通类多了一些抽象方法的定义而已。虽然定义了抽象类，但是抽象类却不能直接使用。

People girl = new People(); // 这种调用会报错,People 是抽象的，无法实例化

1.2.1 抽象类的使用原则

如果说一个类的对象可以被实例化，那么就表示这个对象可以调用类中的属性或者是方法，但是抽象类中存在抽象方法，而抽象方法没有方法体，没有方法体的方法无法使用。

对于抽象类的使用原则如下:

  • 抽象类必须有子类，子类使用extends继承抽象类，一个子类只能够继承一个抽象类；
  • 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法；
  • 若想实例化抽象类的对象，则可以使用子类进行对象的向上转型来完成。

1.3 抽象类特征

1.3.1 抽象类中可以有构造方法

与一般类相同，在抽象类中也可以拥有构造方法，但是这些构造方法必须在子类中被调用，并且子类实例化对象的时候依然满足类继承的关系，先默认调用父类的构造方法，而后再调用子类的构造方法，毕竟抽象类之中还是存在属性的，只不过这个抽象方法无法直接被外部实例化对象的时候所使用。

代码示例:

//定义一抽象类Person
abstract class Person
{
    String name;
    int age;
    String occupation;
    public Person(String name,int age,String occupation) //定义构造函数
    {
        this.name=name;
        this.age=age;
        this.occupation=occupation;
    }
    public abstract String talk();
    //声明一个抽象方法
}

//声明抽象类的子类
class Student extends Person    
{
	public Student(String name,int age,String occupation){
		//在这里必须明确调用抽象类中的构造方法
		super(name,age,occupation);
	}
	
	//覆写talk()方法
	public String talk() {
		return "学生——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！";
	}
}

// 测试
class AbstractConstructor
{
	public static void main(String[] args){
		//创建对象s
		Student s=new Student("张三",18,"学生");
	
		//调用被覆写过的方法
		System.out.println(s.talk()); // 输出:学生——>姓名：张三，年龄：18，职业：学生！ 
	
	}
}

从程序中可以看到，抽象类也可以像普通类一样，有构造方法、一般方法和属性，更重要的是还可以有一些抽象方法，需要子类去实现，而且在抽象类中声明构造方法后，在子类中必须明确调用。

1.3.2 抽象类不能够使用final定义。

使用final定义的类不能有子类，而抽象类使用的时候必须有子类，这是一个矛盾的问题，所以抽象类上不能出现final定义。

1.3.3 在外部抽象类上无法使用static声明

在外部抽象类上无法使用static声明，但是内部抽象类却可以使用static定义，使用static定义的内部抽象类就表示一个外部类。

代码

abstract class Book{
    //抽象方法
    public abstract void print();
    //静态内部抽象类
    static abstract class CD{
      //抽象方法
      public abstract void get();         
           
    }
}
//继承抽象类
class JavaCD extends Book.CD {
    public void get(){
        System.out.println("java学习");
    }
}

public class StaticInnerAbstractClass{
    public static void main(String[]  args){
        //实例化对象
        Book.CD cd=new JavaCD();
        cd.get(); // 输出:java学习
    }
}

2. 接口

接口（interface）是Java所提供的另一种重要技术，是一种特殊的类，它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有不同，并且Java 8中又添加了新特性。

2.1 接口的基本概念

  • 接口里的数据成员必须初始化，且数据成员均为常量，常见的是全局变量。
  • 接口里的方法为abstract，接口不能像抽象类一样定义一般的方法，需定义“抽象方法”。

Java8中为避免在接口中添加新方法后要修改所有实现类，允许定义默认方法，即default方法，也可以称为Defender方法，或者虚拟扩展方法（Virtual extension methods)。
Default方法是指，在接口内部包含了一些默认的方法实现（也就是接口中可以包含方法体，这打破了Java之前版本对接口的语法限制），从而使得接口在进行扩展的时候，不会破坏与接口相关的实现类代码。

2.2 接口定义

声明格式:

public interface 接口名称 {
    //数据成员必须赋初值
    final 数据类型 成员名称=常量；
    //抽象方法，注意没有定义方法主体
    abstract 返回数据类型 方法名称（参数…）；
    
    //默认方法，包含方法体
    default 返回值的数据类型方法名称（参数…）{
        // 方法体...
    }
}

示例:

  • 无默认方法的接口
interface MyInterface{
    // 数据成员必须赋初值
    static final String NAME="Mr.Liu" 
    // 抽象方法
    abstract String getName();
}
  • 有默认方法的接口
public interface MyInterface{
    // 数据成员必须赋初值
    static final String NAME="Mr.Liu" 
    // 抽象方法
    abstract String getName();
    // 默认方法
    default  String say(){
        System.out.println("Hello!")
    }
}

2.3 接口使用原则

  • 接口必须有子类，子类依靠implements关键字可以同时实现多个接口；

  • 接口的子类（如果不是抽象类）则必须覆写接口之中的全部抽象方法；

  • 接口可以利用对象多态性，利用子类实现对象的实例化。

  • 接口与一般类一样，本身也具有数据成员与方法，但数据成员一定要赋初值，且此值不能再更改

  • 接口中除default方法外必须都是抽象方法，所以接口定义格式中，抽象方法声明的关键字abstract是可以省略的。

  • 一个类实现多个接口时，若接口有默认方法，不能出现同名的默认方法

  • 接口可以继承多个接口

3.抽象类和接口的区别

3.1 共同点

  • 都是抽象类型

  • 都可以有实现方法（以前接口不行）

  • 都可以不需要实现类或者继承者去实现所有方法。（以前不行，现在接口中默认方法不需要实现者实现）

3.2 不同点

  • 抽象类不可以多重继承，接口可以（无论是多重类型继承还是多重行为继承）

  • 抽象类和接口所反映出的设计理念不同。其实抽象类表示的是”is-a”关系，接口表示的是”like-a”关系

  • 接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值；抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值

    如果一个类、类属变量及方法不以这三种修饰符来修饰，它就是friendly类型的，那么包内的任何类都可以访问它，而包外的任何类都不能访问它(包括包外继承了此类的子类)

总体来说，抽象类和接口在很大程度上都是可以互相替换使用的，但就是由于抽象类本身具备单继承局限，所以当抽象类和接口全部都可以使用的时候优先考虑接口，因为接口没有单继承局限，并且在Java8中接口可以设定默认方法，在一定程度上避免代码重复，利于后期的维护。