一、学习目的

抽象类最核心的作用就是作为模板，接口是定义一套方法，用于对象之间的通信。抽象类和接口在编写程序时有很大的作用，比如如果要增强增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

二、学习内容

（1）抽象类

如何定义一个抽象类
使用修饰符abstract，抽象类里可以有具体的对象方法，可以定义未实现的抽象方法，可以定义内部类,代码块,构造方法

   abstract class AbstractAndroidStudy{  
      public AbstractAndroidStudy(){       //构造方法
      }
    public void test1();  //定义一个抽象方法
    public void test2(){         //定义一个实例方法
          System.put.println("hello");
        }
         class  Inner{                         //定义一个内部类
            System.out.println("welcome");
           }
           {
                  System.out.println("锻炼身体"）; //定义一个代码块
          }
      }

抽象类的特点

抽象类必须使用abstarct进行定义声明
抽象类中的抽象方法方法使用abstarct声明，且这个方法不能实现，由子类实现
一个抽象类中除了含有抽象方法外，还可以有具体的方法(有方法体，有具体内容实现)。
抽象类不能用new创建对象，因为加入一个抽象类中全是抽象方法，即使创建对象去使用调用这些方法，却也只能是一些空实现，调用抽象类没有任何意义。抽象类是用来继承的，抽象方法是用来重写的。
抽象类中抽象方法要被使用，必须由子类复写这个抽象类(父类)中的所有抽象方法后，由子类对象去调用使用这些复写后的方法。
一个抽象类继承了一个抽象类，那么这个类可以不用去实现父类中的抽象方法。
抽象类中也可以没有抽象方法。
8，abstract关键字不能和final，private，static共存
抽象类和普通类的区别
抽象类比一般类多了抽象方法，而且还不能实例化。

（2）接口

如何定义接口
接口用interface定义，接口里面的成员变量默认都是public static final，方法都是抽象方法，不能实现。

interface TestInterface1{
public static final int I = 100;
int COUNTT = 20;
public abstract void test();
static class Inner{      //内部类默认就是public static
    int name;
    public void show(){
        System.out.println("内部类");
     }
  }
}

如何实现接口
实现接口用关键字implement,一个类可以实现多个接口，接口之间用逗号隔开，实现多个接口相当于变相的多继承。

class PXDClass implements  TestInterface1,TestInterface2{
@Override
public void test() {
    TestInterface1.Inner in1 = new TestInterface1.Inner();
    in1.show();
}
@Override
public void test1() {
    System.out.println("hello");
   }
 }

接口的特点
1.接口中的成员方法都是抽象方法。

接口不能创建对象，因为其中的抽象方法都是抽象方法，没有实现，创建对象没有意义，需要被子类实现，复写接口中的方法，由子类去创建对象，调用方法。
接口中的成员都是public的，变量都是public static final
接口可以被类多实现，一个类也可以实现多个接口，即变相的多继承
因为接口中的方法都是抽象方法，没有实现，无论这些接口中存在多少个相同的方法，这些接口的子类都可以实现，而这些相同的方法，只要在子类复写一个，就相当于复写了所有接口中的方法
接口是对外暴露的规则。
接口降低了耦合性
注意：两个或多个接口中不可有不同返回类型的同名抽象函数，因为同一个类实现这来两个类会出错

（4）接口与抽象类的比较

1，抽象类是为了提供功能模板，接口是为了类对象之间的通信
2，抽象类是一种被子类继承(extends)的关系，而接口和类是一种实现(implements)关系，接口和接口是继承(extends)关系。
注:子类只能继承一个抽象类，一个类却可以实现多个接口，接口可以继承多个接口。
3，接口和抽象类最大的一个区别，就在于抽象类可以提供某些方法的部分实现，而接口不可以，这大概就是抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而接口做不到这一点，如果向一个接口里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是接口的缺点。

三、实例分析

（1）在界面上添加控件，并监听事件。
1，先定义一个界面的抽象类,里面抽取了界面的功能，留给子类实现

  package swu.xwj.day6.button;
  import java.util.ArrayList;
   /**
   * 管理界面的抽象类 定义了一个界面从创建到结束的模板
   */
public abstract class Activity {
//保存这个界面的所有子视图
public ArrayList childs = new ArrayList();
//创建界面
public abstract void onCreat();
//界面销毁
public abstract void onDestory();
//将子控件添加到界面上
//接受的时候用父类去接收子类 当需要访问子类内容的时候 就需要转化为对应的类型
public void addChild(View view) {
    if(view instanceof Button){
        Button button = (Button)view;
        System.out.println(button.title+"按钮被添加到界面上了");
    }
    if(view instanceof ImageView){
        ImageView imageView = (ImageView)view;
        System.out.println(imageView.picture+"的图片被添加界面上了");
    }
    //保存子类控件
    childs.add(view);
}
}

2，建一个View类，里面的借口用于监听事件

 package swu.xwj.day6.button;
    /**
    *管理视图显示和事件监听
     * 什么情况下需要将一个类做成一个抽象类
    * 1，不能直接创建这个类的对象
    * 2，这个类里面的某些方法还不知道如何实现
   */
 public class View {
//所有视图共有的属性
String backgroundColor;
String bounderColor;
//记录谁想监听这个事件
//暂时不知哪个要监听事件，但监听事件一定实现了这个接口
OnClickListener listener;
//所有的视图都要监听事件
//定义内部接口 封装
public interface OnClickListener {
    //定义一套方法，约束外部使用这些方法来监听事件
     void onClick(View view);
}
//用于控件接收触摸事件
public void getTouchEvent(){
    //调用监听者里面的onclick方法
    listener.onClick(this);
}
}

3，在View的基础上创建button，imageviewl两个控件的类

  package swu.xwj.day6.button;
/**
 * 管理按钮
 */
public class Button extends View {
String title;
String titleColor;
public Button(String title,String titleColor){
    this.title = title;
    this.titleColor = titleColor;
}

}

  package swu.xwj.day6.button;
  /**
    * 显示一张图片
 */
public class ImageView extends View {
String picture;

public ImageView(String picture){
    this.picture = picture;
}
}

4，创建主界面，将两个控件添加到主界面上，并模拟触摸两个控件。

    package swu.xwj.day6.button;
  /**
     * 主界面 程序运行起来的第一个界面
   */
  public class MainActivity extends Activity implements View.OnClickListener {
  Button btn;
ImageView img;
//构造方法
public MainActivity(){
    //当界面被创建 调用onCreate方法
    onCreat();
}
@Override
public void onCreat() {
    //主界面如何布局
    //添加一个按钮
     btn = new Button("分享","红色");
    //添加一张图片
     img = new ImageView("蔡徐坤");
    //将创建的界面添加到当前界面
    addChild(btn);
    addChild(img);
    //方法一：
    //如果一个控件需要监听事件就必须实现监听事件的接口
    btn.listener = this; //告诉按钮谁在监听事件 this指mainactivity的对象
    //方法二
    //给imageview添加一个事件
    img.listener = new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            System.out.println("图片被点击了");
        }
    };
}
//模拟触摸
public void touch(){
    //将屏幕触摸的事件传递给按钮
    btn.getTouchEvent();
    img.getTouchEvent();
}
@Override
public void onDestory() {
    //销毁之前需要做点什么事情
    System.out.println("图片正在被删除");
}

//当事件触发了，就会调用onClick方法
@Override
public void onClick(View view) {
    System.out.println("按钮被点击了");
}
}

5，创建一个界面

package swu.xwj.day6.button;
public class MyClass {
public static void main(String[] args){
//启动程序 创建界面
    MainActivity mainActivity = new MainActivity();
    //触摸模拟
    mainActivity.touch();
  }
}

输出结果

（2）测试一段代码的执行时间

  package swu.xwj.day6.Demo;
  public class MyClass {
  public static void main(String[] args){
    MyCode test = new MyCode();
    test.calculate();
  }
}
/**
 * 希望能够创建一个模板
 * 使用这个模板可以方便测出某个代码块的执行效率
 */
abstract class TimeTemplate{
//通过实现这个方法 获得具体的测量的代码
public abstract void code();
//实现测量
public void calculate(){
    long star = System.currentTimeMillis();
    code();
    long end = System.currentTimeMillis();
    System.out.println("从1加到100000所需时间为"+end-star+"毫秒");
  }
}
class MyCode extends TimeTemplate{
@Override
public void code() {
    //写自己的测试代码
    long total = 0;
    for(int i = 0; i

用抽象类设置了一个模板，只需要吧需要测试的代码写到子类的函数中就可以测试。

输出结果

四、学习感悟

今天学习的抽象类和接口，抽象类不难理解，就是对接口有点似是而非，理解的不够透彻。但我觉得多联系几次理解应该就深刻了。

珞印专属

Java学习之抽象类、接口