一、抽象类(abstract class)

1. 定义：如果一个类没有包含足够多的信息来描述一个具体的对象，这样的类就是抽象类.

• 抽象类不能实例化，但是也能像普通类一样在{}中定义成员变量、成员方构造方法等。
• 抽象方法：只声明，不实现。具体的实现由继承它的子类来实现，也就是说，被abstract修饰的方法，方法名后直接跟一个分号,如：

abstract public void show();

• 一个类中含有抽象方法（被abstract修饰），那么这个类必须被声明为抽象类（被abstract修饰）。
• 构造方法、类方法（用static修饰的）不能声明为抽象方法。

2. 继承抽象类：使用extends来继承一个抽象类

• 如果继承于一个抽象类，就必须实现抽象类里面的抽象方法。
• 如果不实现抽象方法，也可以把这个类定义为抽象类。
• 只有抽象类的非抽象子类可以创建对象

abstract class BaseAndroidStudy {
    //定义一个代码块
    {
        System.out.println("锻炼身体！");
    }

    //定义一个属性 用于保存数据
    public String javaBook;
    public Dream dream;


    //提供构造方法
        public BaseAndroidStudy(String javaBook,String dream){
            this.javaBook = javaBook;

            this.dream = new Dream();
            this.dream.dreamName = dream;
        }

    //定义一个静态的常量
    public static final String CBOOK = "C Primier";


        //定义一个抽象方法  不需要实现  子类来实现
        abstract public void studyCLanguage();

        //定义一个普通方法  已经确定了这个方法的具体实现
        public void studyJavaLanguage() {
            System.out.println("参加Java培训班");
        }

        //定义一个类 内部类 用于管理每个人的理想 梦想
        class Dream{
            private String  dreamName;

            public void show(){
                System.out.println("我的梦想是:"+dreamName);
            }
        }

}

抽象类的使用：

class Student extends BaseAndroidStudy{
    String name;

    @Override
    public void studyCLanguage() {
        System.out.println("看书，看视频");
    }

    public Student(String name,String bookName,String dream){
        super(bookName,dream);
        this.name = name;
    }
}


public class MyClass {
        public static void main(String[] agrs) {
          
            //1.显示地创建一个类继承于抽象类 创建这个类的一个对象
            Student xw = new Student("小王","java编程思想","成为高级工程师");


            //2.使用匿名类 只使用一次
            BaseAndroidStudy zs = new BaseAndroidStudy("java编程思想","成为高级工程师") {
                @Override
                public void studyCLanguage() {
                    System.out.println(".......");
                }
            };
        }
    }

二、接口(interface)

1. 定义：接口在java中是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，从而继承接口的抽象方法。

• 从定义是上看，接口是个集合，并不是类。类描述了属性和方法，而接口只包含未实现的方法。接口和抽象类一样不能被实例化，因为不是类。但是接口可以被实现（impments关键字）。实现某个接口的类必须在类中实现该接口的全部方法。虽然接口内的方法都是抽象的（和抽象方法很像，没有实现），但是不需要abstract关键字。
• 接口里面默认的都是static final 常量, 默认情况下不需要自己写public static final,不能定义变量
• 接口里面不能定义代码块
• 接口里面不能定义构造方法
• 接口里面不能添加普通/对象/实例方法，必须是抽象的（不能实现）, 默认就是public abstract

interface TestInterface2 extends TestInterface{
    int I = 100;
    int COUNT = 100;

    void test();

    class Inner{
        int name;
        public void show(){
            System.out.println("内部类");
        }
    }
}

• 如果需要定义已经有实现的方法,使用default
• 接口里面可以定义内部类 ,内部类默认public static
• 一个类可以实现多个接口 , 一个接口可以继承多个接口

class GYLClass implements TestInterface2,TestInterface

2.继承接口:一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

class GYLClass implements TestInterface2,TestInterface{

    @Override
    public void test() {
        TestInterface.Inner inner = new TestInterface.Inner();
        inner.show();
    }

    @Override
    public void test2() {

    }

    @Override
    public void test3() {

    }
}


//接口的使用
class Test{
    public static void main(String[] args){
        GYLClass gyl = new GYLClass();
        TestInterface2 t = new GYLClass();
    }
}

三、接口与抽象类的区别

• 接口不能用于实例化对象。

• 接口没有构造方法。

• 接口中所有的方法必须是抽象方法。

• 接口不能包含成员变量，除了 static 和 final 变量。

• 接口不是被类继承了，而是要被类实现。

• 接口支持多继承。

四、项目实战(实现对按钮的监听)

功能图

1. 创建Activity模板（抽象类）

/**
 * 管理界面的抽象类 定义了一个界面创建到结束的模板
 */
public abstract class Activity{
    //保存这个界面的所有子视图
    public ArrayList<View> childs = new ArrayList<View>();

    //抽象类不用实现 由子类实现

    //界面创建
    public abstract void OnCreate();

    //界面销毁
    public abstract void OnDestroy();

   
}

2. 创建View管理所有视图的显示和事件监听

/**
 * 管理一个视图显示和事件监听
 * 什么情况下需要将一个父类做成一个抽象类
 * 1.不能直接创建这个类的对象
 * 2.这个类里面的某些方法 还不确定怎么实现
 *
 */
public class View {
    //所有视图都拥有的属性
    String backgroundColor;
    String borderColor;

    //记录谁想监听这个事件
    //暂时不确定是谁要监听
    //但是要监听的人实现了这个接口  内部接口
    OnClickListener listener;


    //所有的视图都要监听事件
    //定义内部接口
    public interface OnClickListener{
        //定义一套方法 约束外部使用这些方法来监听事件
         void onClick(View v);

    }

}

3. 创建主界面MainActivity

/**
 * 管理主界面(程序运行起来第一个界面)
 */
public class MainActivity extends Activity implements View.OnClickListener{
  
    @Override
    public void OnCreate() {
        //主界面如何布局
      
    }


    @Override
    public void OnDestroy() {
        //销毁之前需要做点什么事情
        System.out.println("......");
    }

4. 创建按钮对象

/**
 * 创建一个按钮类
 */
public class Button extends View{
    String title;
    String titleColor;

    public Button(String title,String titleColor){
        this.title = title;
        this.titleColor = titleColor;
    }
}

5. 创建一张图片

/**
 * 显示一张视图
 */
public class ImageView extends View{
    String picture;

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

}

6. 在主界面添加按钮和图片

 //主界面如何布局
        //添加一个按钮
        button = new Button("分享","红色");
        //添加一张图片
        imageView = new ImageView("星空 ");

7. 实现控件添加到界⾯上的过程 抽象类Activity中 添加addChild方法

//将子控件添加到当前界面上
    //接收的时候是用父类接收子类
    //当要访问子类内容的时候 就要强制转换为对应的类型
    public void addChild(View v){
        if (v instanceof Button){
            Button btn = (Button)v;  //强制转换
            System.out.println(btn.title+"按钮显示到界面上了");
        }

        if (v instanceof ImageView){
            ImageView iv = (ImageView)v;
            System.out.println(iv.picture+"图片显示到界面上了");
        }

        //保存子类控件
        childs.add(v);
    }

8. 将创建好的控件添加到界面上

 //将创建的控件添加到当前界面
        addChild(button);
        addChild(imageView);

9. 事件监听 MainActivity实现接口 == MainActivity需要监听事件

//所有的视图都要监听事件
    //定义内部接口
    public interface OnClickListener{
        //定义一套方法 约束外部使用这些方法来监听事件
         void onClick(View v);

    }

10. 在MainActivity实现接⼝里⾯的⽅法

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

11. 告诉按钮 是谁要监听他的点击事件

//如果一个控件需要监听事件就必须实现监听事件的接口
        //告诉按钮谁在监听这个事件
        button.listener = this; //表示当前类的一个对象

12. 使⽤匿名类给图片添加事件监听器

//2.
        //给ImageView添加一个事件
        imageView.listener = new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                System.out.println("图片被点击了");
            }
        };

13. View中事件接收触摸事件的方法 用于获取按钮被点击了

//用于控件接收触摸事件
    public void getTouchEvent(){
        //调用监听者里面的OnClick方法
        listener.onClick(this);
    }

14. MainActivity中添加⽅法 模拟手触摸屏幕 将触摸的事件传递给按钮或者图片

 //模拟触摸
    public void touch(){
        //将屏幕触摸的事件传递给按钮
        button.getTouchEvent();
        imageView.getTouchEvent();
    }

15. 外部使用

public class MyClass {
    public static void main(String[] args){
        //启动程序 创建界面
        MainActivity main = new MainActivity();

        //模拟触摸
        main.touch();
    }
}

运行结果： 运行结果

计算代码运行时间：

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 start = System.currentTimeMillis();

        //测量的代码
        code();

        long end = System.currentTimeMillis();

        System.out.println(end - start);
    }
}

class MyCode extends TimeTemplate{

    @Override
    public void code() {
        //写自己的测试代码
        int total = 0;
        for (int i = 0;i < 100000;i++){
            total += i;
        }
    }
}

五、心得体会

  这个demo下来自己对于代理设计模式，工厂设计模式等等模式还不是很懂，需要反复地练习，加深理解。