1. 什么是抽象类？
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
抽象类的出现使面向对象更加规范，比如人是一个抽象的概念，没有具体的对象，我们应该将其抽象成一个类，它无法生成对象实例，却拥有一些人通用的属性和方法。有些方法人类都是一样的行为，比如说都是用嘴吃饭，用耳朵听声音等；但有些则不是，比如工作，不同的岗位人们有不同的工作行为，那么这些行为的具体实现在子类完成，Person父类只负责定义。
2. 抽象类与抽象方法的特点
- 用abstract关键字来修饰一个类，这个类叫做抽象类。
- 抽象类可以有构造器，可以使用this关键字，子类可以使用super关键字
- 用abstract来修饰一个方法，该方法叫做抽象方法。抽象方法只能声明，具体实现应该交给子类完成
抽象方法：只有方法的声明，没有方法的实现。以分号结束：
比如：public abstract void talk(); - 抽象类中不一定包含抽象方法,但是含有抽象方法的类必须被声明为抽象类。
- 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须定义父类的抽象方法，并提供方法体。若没有定义全部的抽象方法，仍为抽象类。
- 不能用abstract修饰变量、代码块、构造器；
- 不能用abstract修饰私有(private)方法、静态(static)方法、final的方法、final的类
- 抽象类可以引用非抽象类的子类对象，并调用子类实现抽象类定义的方法和抽象类本身不是抽象的方法。
package Random_name.sgm.abstract_interface;
/**
* @Program: JavaSE
* @ClassName: TestMain
* @Author: Mr.BitHachi
* @CreateTime: 2020-08-08 12:07
* @Version: V1.0
* @Description:
**/
abstract class A {
private int aa=10;
static final String str="可以有static属性";
static{
System.out.println("可以有代码块");
}
A(int aa){
this.aa=aa;
}
public abstract void m1();
public void m2() {
System.out.println("A类中定义的m2方法");
System.out.println("A类中的属性a="+this.aa);
}
}
class B extends A {
private int bb=10;
B(int aa,int bb){
super(aa);
this.bb=20;
}
public void m1() {
System.out.println("B类中定义的m1方法");
}
public void m2() {
System.out.println("B类中重写的的m2方法");
}
void m3(){
super.m2();
}
}
class Test {
public static void main(String args[]) {
A a = new B(20,20);
a.m1();
a.m2();
B b=new B(30,30);
b.m3();
}
}
运行结果:
可以有代码块
B类中定义的m1方法
B类中重写的的m2方法
A类中定义的m2方法
A类中的属性a=30
3. 抽象类的应用
抽象类的应用与多态应用相关联。
抽象类体现的是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
抽象类解决的问题：
- 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
- 在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种
模板模式。
模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的影子，比如常见的有：
- 数据库访问的封装
- Junit单元测试
- JavaWeb的Servlet中关于doGet/doPost方法调用
- Hibernate中模板程序
- Spring中JDBCTemlate、HibernateTemplate等
4. 什么是接口？
- 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。
- 有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
- 有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
5.接口的特点
- 接口(interface)是抽象方法和全局常量值定义的集合(jdk8之前)。jdk8之后可以定义static和default的方法和方法体
- 接口的特点：
- 用interface来定义。
接口中没有构造器。- 接口不能用于实例化对象。
接口中不能拥有代码块- 接口中的所有成员变量都默认是由
public static final修饰的。 - 接口中的所有抽象方法都默认是由
public abstract修饰的。 - 一个类可以实现多个接口，接口也可以继承（extends）其它一个或多个接口。
- 定义Java类的语法格式：先写extends，后写implements
class SubClassextendsSuperClassimplementsInterfaceA{ } - 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
- 接口的主要用途就是被实现类实现。（面向接口编程）
- 与继承关系类似，接口与实现类之间存在多态性
- 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。
接口的定义举例：
JDK8中关于接口的改进:
-
Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
-
静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。 -
默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。- 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现： ·接口冲突·。
解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。 - 若一个接口中定义了一个默认方法，实现其接口的类的父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：
类优先原则。接口中具有相同名称和参数的默认方法会被忽略。
- 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现： ·接口冲突·。
-
接口中静态方法和默认方法必须给出方法体，不能只定义
根据接口的特点，综合举例：
/************ 一个类可以实现多个无关的接口 ************/
interface Runner {
int a=10;
public void run();//jdk8之前只能声明非static和defult的方法
static void fun2() {
//jdk8之后可以定义static和defult的方法，不能声明，必须给出方法体
System.out.println("interface Runner static fun2");
}
default void fun3(){
System.out.println(this.a);//可以使用this,但是不能更改其值，因为默认缺省public static final
System.out.println("interface Runner default fun3");
}
}
interface Swimmer {
public double swim();
default void fun3(){
System.out.println("interface Swimmer default fun3");
}
default void skip(){
System.out.println("interface Swimmer default skip");
}
}
class Creator{
public void eat() {
System.out.println("eat");
}
public void skip(){
System.out.println("class Creator skip");
}
}
class Man extends Creator implements Runner ,Swimmer{
public void run() {
System.out.println("run");
}
public double swim() {
System.out.println("swim");
return 1.1d;
}
public void fun3(){
System.out.println("class Man fun3");//类覆盖两个接口中默认的方法fun3()
Runner.super.fun3();//调用原接口中默认的方法
Swimmer.super.fun3();
}
}
class Test{
public static void main(String args[]){
Test t = new Test();
Man m = new Man();
t.m1(m);//接口多态引用，与继承关系类似，接口与实现类之间存在多态性
t.m2(m);
t.m3(m);
System.out.println("-----------");
Runner.fun2();
System.out.println("-----------");
System.out.println(Runner.a);
System.out.println("-----------");
m.fun3();
System.out.println("-----------");
m.skip();
}
public void m1(Runner f) {
//接口多态引用
f.run();
}
public void m2(Swimmer s) {
//接口多态引用
s.swim();
}
public void m3(Creator a) {
//接口多态引用
a.eat();
}
}
运行结果：
run
swim
eat
-----------
interface Runner static fun2
-----------
10
-----------
class Man fun3
10
interface Runner default fun3
interface Swimmer default fun3
-----------
class Creator skip
6.接口面试题
题一：
interface A {
int x = 0;
}
class B {
int x = 1;
}
class C extends B implements A {
public void pX() {
System.out.println(x);//Error
System.out.println(super.x);//1
System.out.println(A.x);//0
}
public static void main(String[] args) {
new C().pX();
}
}