什么是抽象类和接口
使用 abstract 关键字修饰的方法被称为 抽象方法 ，即只有声明没有方法体的方法。如下：
public abstract void function();
抽象类 就是包含抽象方法的类。
如果一个类包含一个或者多个抽象方法，该类必须被限定为抽象的。抽象类可以不包含抽象方法。
public abstract class BaseActivity {
private final String TAG = this.getClass().getSimpleName(); //抽象类可以有成员
void log(String msg){ //抽象类可以有具体方法
System.out.println(msg);
}
// abstract void initView(); //抽象类也可以没有抽象方法
}
接口 是抽象类的一种特殊形式，使用 interface 修饰。
public interface OnClickListener {
void onClick(View v);
}
抽象类的特点：
抽象类是对类的抽象，具体实现是不确定的，所以不允许直接创建实例。
- 抽象类是由子类具有相同的一类特征抽象而来，也可以说是其基类或者父类
- 抽象方法必须为 public 或者 protected修饰（因为如果为 private，则不能被子类继承，子类便无法实现该方法），默认是 public
- 抽象类不能用来创建对象
- 抽象方法必须由子类来实现
- 如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法，如果子类没有实现父类的抽象方法，则必须将子类也定义为抽象类
接口的特点：
在java中为了保证数据安全性是不能多继承的，一个类只能有一个父类。但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多继承的缺陷。接口是抽象类的延伸，它可以定义没有方法体的方法，要求实现者去实现。
- 接口的所有方法访问权限自动被声明为 public
- 接口中可以定义“成员变量”，会自动变为 public static final 修饰的静态常量
- 可以通过类命名直接访问：ImplementClass.name
- 不推荐使用接口创建常量类
- 实现接口的非抽象类必须实现接口中所有方法，抽象类可以不用全部实现
- 接口不能创建对象，但可以申明一个接口变量，方便调用
- 完全解耦，可以编写可复用性更好的代码
如果我们的一个项目，需要写大量的 Activity，这些 Activity 会有一些通用的属性和方法，我们会创建一个基类，把这些通用的方法放进去：它的作用就是：封装重复的内容。在 BaseActivity 里创建了一些抽象方法，要求子类必须实现。
public abstract class BaseActivity extends Activity {
private final String TAG = this.getClass().getSimpleName();
@Override
protected void onCreate(final Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(getContentViewLayoutId());
initView(); //这里初始化布局
loadData(); //这里加载数据
}
/**
* 需要子类实现的方法
* @return
*/
protected abstract int getContentViewLayoutId();
protected abstract void initView();
protected abstract void loadData();
void toast(String msg) {
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
}
}
定义的抽象方法访问权限修饰符可以是 public protected 和 default，但不能是 private，因为这样子类就无法实现了。
这时 BaseActivity 因为有了抽象方法，变成了一个抽象类。它的作用就是：定义规范，强制子类符合标准；如果有调用抽象方法，也会制定执行顺序的规则。
继承 BaseActivity 的类只要实现这些方法，同时为父类提供需要的内容，就可以和父类一样保证代码的整洁性。
public class MainActivity extends BaseActivity{
private TextView mTitleTv;
@Override
protected int getContentViewLayoutId() {
return R.layout.activity_main;
}
@Override
void initView() {
mTitleTv = (TextView) findViewById(R.id.main_title_tv);
mTitleTv.setOnClickListener(this);
}
@Override
protected void loadData() {
//这里加载数据
}
}
以后如果发现有某些功能在不同 Activity 中重复出现的次数比较多，就可以把这个功能的实现提到 BaseActivity 中。注意不要轻易添加抽象方法，因为这会影响到之前的子类。
很多页面都有根据定位信息改变而需要重新请求数据的情况，为了方便管理，我们要把这些代码都放到 BaseActivity? 但是这样一来，那些不需要定位相关的代码就会冗余，逻辑太多。 BaseActivity 也会变得很复杂。我们想要把位置相关的放到另一个类，但是 Java 只有单继承，这时就可以使用接口了。
我们创建一个接口表示对地理位置的监听：
interface OnLocationChangeListener {
void onLocationUpdate(String locationInfo);
}
接口默认是 public,不能使用其他修饰符。
这样我们在需要定位的页面里实现这个接口：
public class MainActivity extends BaseActivity implements View.OnClickListener,
OnLocationChangeListener {
private TextView mTitleTv;
@Override
protected int getContentViewLayoutId() {
return R.layout.activity_main;
}
@Override
public void onClick(final View v) {
int id = v.getId();
if (id == R.id.main_title_tv) {
toast("你点击了 title");
}
}
@Override
void initView() {
mTitleTv = (TextView) findViewById(R.id.main_title_tv);
mTitleTv.setOnClickListener(this);
}
@Override
protected void loadData() {
//这里加载数据
}
@Override
public void onLocationUpdate(final String locationInfo) {
mTitleTv.setText("现在位置是：" + locationInfo);
}
}
这样 MainActivity 就具有了监听位置改变的能力。如果 MainActivity 中需要添加其他功能，可以再创建对应的接口，然后予以实现。
抽象类和接口的不同：
抽象层次不同
抽象类是对类抽象，而接口是对行为的抽象
抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部行为进行抽象
跨域不同
抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类
抽象类所体现的是一种继承关系，考虑的是子类与父类本质“是不是”同一类的关系
而接口并不要求实现的类与接口是同一本质，它们之间只存在“有没有这个能力”的关系
设计层次不同
抽象类是自下而上的设计，在子类中重复出现的工作，抽象到抽象类中
接口是自上而下，定义行为和规范
抽象类定义了“是什么”，可以有非抽象的属性和方法；接口是更纯的抽象类，在 Java 中可以实现多个接口，因此接口表示“具有什么能力”。在进行选择时，可以参考以下几点：
若使用接口，我们可以同时获得抽象类以及接口的好处
所以假如想创建的基类没有任何方法定义或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类
如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口
只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类
使用接口最重要的一个原因：实现接口可以使一个类向上转型至多个基础类。
比如 Serializable 和 Cloneable 这样常见的接口，一个类实现后就表示有这些能力，它可以被当做 Serializable 和 Cloneable 进行处理。
推荐接口和抽象类同时使用，这样既保证了数据的安全性又可以实现多继承。
面向接口编程
我们在写代码时追求的是“以不变应万变”，在需求变更时，尽可能少地修改代码就可以实现。
需要模块之间依赖时，最好都只依赖对方给的抽象接口，而不是具体实现。
在设计模式里这就是“依赖倒置原则”，依赖倒置有三种方式来实现：
通过构造函数传递依赖对象 比如在构造函数中的需要传递的参数是抽象类或接口的方式实现
通过 setter 方法传递依赖对象 即在我们设置的 setXXX 方法中的参数为抽象类或接口，来实现传递依赖对象
接口声明实现依赖对象，也叫接口注入 即在函数声明中参数为抽象类或接口，来实现传递依赖对象，从而达到直接使用依赖对象的目的。
可以看到，“面向接口编程”说的“接口”也包括抽象类，其实说的是基类，越简单越好。
多态
多态指的是编译期只知道是个人，具体是什么样的人需要在运行时能确定，同样的参数有可能会有不同的实现。
通过抽象建立规范，在运行时替换成具体的对象，保证系统的扩展性、灵活性。
实现多态主要有以下三种方式：
接口实现
继承父类重写方法
同一类中进行方法重载
不论哪种实现方式，调用者持有的都是基类，不同的实现在他看来都是基类，使用时也当基类用。
这就是“向上转型”，即：子类在被调用过程中由继承关系的下方转变成上面的角色。
向上转型是能力减少的过程，编译器可以帮我们实现；但 “向下转型”是能力变强的过程，需要进行强转
