JAVA-（抽象类、接口、实战小demo）

作者: 宁晓鸯 | 来源:发表于2019-08-12 21:00 被阅读0次

心得体会

今天相当于之前来说上课的时间要少一点，同时我们自我理解的时间就相对变得充裕了很多。抽象类和接口似乎用的很多，有些时候很容易将两者搞混，但是再容易搞混的两种事物，只要你深入的去接触，也会找到突破点的，上课没听懂，课后就多花点时间去弄懂，网上搜，问同学，无论何种方式，反正当日事情当日做嘛，不然明日复明日，明日何其多，会很难过的。

技术

1.抽象类

2.接口

3.接口与抽象类的联系与区别

4.实战小demo1

5.练习小demo2

具体操作

1.抽象类

1.抽象类及抽象方法的定义

抽象类：用abstract关键字来修饰一个类时，这个类叫做抽象类；
抽象方法：用abstract来修饰一个没有方法体的方法时，该方法叫做抽象方法

例：定义一个抽象类

abstract class BaseAndroidStudy{
.......
}

2.抽象类的性质

抽象类中可以有代码块、构造方法，可以定义属性，静态常量，普通方法，抽象方法,普通方法

抽象方法不需要实现，由子类来实现

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.name=dream;
       }

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

       //定义一个抽象方法 不需要实现 子类来实现
       public abstract void studyC();
       //定义一个普通方法 已经确定了这个方法的具体实现
       public void studyJava(){
           System.out.println("参加培训班");
       }

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

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

抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类

子类中的抽象方法不能与父类的抽象方法同名。

abstract不能与final并列修饰同一个类。

abstract 不能与private、static、final或native并列修饰同一个方法。

如果继承一个抽象类就必须实现抽象类里面的抽象方法；如果不实现抽象方法，也可以把这个类定义为抽象类

例如：

//抽象类
  abstract class BaseAndroidStudy{
     public abstract void studyC();//抽象方法，抽象方法不许要实现，由子类来实现
}

class Student extends BaseAndroidStudy{
    String name;
   @Override
    public void studyC(){
       System.out.println("看书，看视频");//实现抽象类中的抽象方法

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

或者

//抽象类
  abstract class BaseAndroidStudy{
     public abstract void studyC();//抽象方法，抽象方法不许要实现，由子类来实现
}

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

3.抽象类的使用

 public class Myclass {
        public static void main(String[] args){
            //1.显示的创建一个类继承于抽象类 创建这个类的一个对象
            Student xw=new Student("小王","Java编程思想","参加培训班");


            //使用匿名类 只使用一次
            BaseAndroidStudy zs=new BaseAndroidStudy("java书","高薪") {
                @Override
                public void studyC() {
                    System.out.println("培训");
                }

            };
        }
    }

什么情况下需要将一个父类做成抽象类（模板）

1.不能直接创建这个类的一个对象

2.这个类里面的某些方法还不确定如何实现

2.接口

1.接口的定义

接口（Interface):是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，接口就是java提供的一个面向对象的机制

例如：定义一个接口

interface  testInterface{
...
}

2.接口的性质

接口里面默认的变量都是static final 常量,默认情况下不需要自己写public static final

接口里面不能定义变量

接口里面不能定义代码块,构造方法

如果需要定义已经有实现的方法使用default

接口里面可以定义内部类

使用implements实现一个接口

interface  testInterface{
    public static final int I=100;
    int COUNT=20;
    void test();
    public void test2();
    public abstract void test3();

    // 接口的静态内部类
    static class inner{
        int name;
        public void show(){
            System.out.println("内部类");
        }
    }

}
interface  testInterface2 extends testInterface{
     int I=100;
     int COUNT=20;
     void test();

     class inner{
         int name;
         public void show(){
            System.out.println("内部类");
        }
    }
}
class PXDClass implements testInterface2,testInterface{

    @Override
    public void test() {
        testInterface.inner in=new testInterface.inner();
        in.show();
    }

    @Override
    public void test2() {

    }

    @Override
    public void test3() {

    }
}
class Te{
    public static void main(String[] args){
        PXDClass pxd=new PXDClass();
        testInterface2 t=new PXDClass();
    }
}

接口里面不能添加普通方法/对象方法/实例方法，只有抽象方法默认就是public abstract

    void test();
    public void test2();
    public abstract void test3();//这三种定义方法默认都是public abstract

一个类可以实现多个接口

class PXDClass implements testInterface2,testInterface{
}

一个接口可以继承多个接口

interface  testInterface2 extends testInterface，testInterface3{
}

3.接口与抽象类的联系与区别

1.联系

接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。

接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

2.区别

接口里只能包含抽象方法，静态方法和默认方法，不能为抽象方法提供方法实现，抽象类则完全可以包含普通方法。

接口里只能定义静态常量，不能定义普通成员变量，抽象类里则既可以定义普通成员变量，也可以定义静态常量。

接口不能包含构造器，抽象类可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

接口里不能包含初始化块，但抽象类里完全可以包含初始化块。

一个类最多只能有一个直接父类，包括抽象类，但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承不足。

4.实战小demo

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

package day6.JAVA.Demo;

import java.util.ArrayList;

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

    //将子控件添加到一个界面上
    //接受的时候用父类去接受子类
    //当需要访问子类内容的时候 就要强制转换为对应的类
    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);
    }

}

2.管理一个视图显示和事件监听

public class View {
    //所有视图都共有的属性
    String backgroundColor;//背景颜色
    String borderColor;//按钮颜色

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

    //所有的视图都要监听事件
    //定义一个内部接口 封装
    public interface OnClickListener{
        //定义一套方法 约束外部使用这些方法来监听事件
        void onClick(View v);
    }
    //用于控件接受触摸事件
public void getTouchEvent(){
        //调用监听者里面的onClick方法
        listener.onClick(this);
}

}

3.创建按钮类

public class Button extends View {
    String title;//创建标题
    String titleColor;//创建标题颜色
    public Button(String title,String titleColor){
        this.title=title;
        this.titleColor=titleColor;
    }
}

4.显示一张图片

/**
 * 显示一张图片
 */

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

5.创建主界面

1.实现抽象类中的抽象方法

 @Override
    public void onCreate () {...}
  @Override
    public void onDestory() {
        //销毁之前需要做点什么事情
    }

2.添加一个按钮

Button btn;
btn=new Button("分享","红色");

3.添加一张图片

ImageView img;
img=new ImageView("周杰伦");

4.把子控件添加到主界面

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

/**
 * 管理主界面（程序运行起来的第一个界面）
 */
public class MainActivity extends Activity implements View.OnClickListener{
    //当界面一旦创建 就自动调用onCreate方法
    public MainActivity(){
        onCreate();
    }
    Button btn;
    ImageView img;
    @Override
    public void onCreate () {
        //主界面如何布局
        //添加一个按钮
        btn=new Button("分享","红色");
        //添加一张图片
         img=new ImageView("周杰伦");

        //将创建的控件添加到当前界面
        addChild(btn);
        addChild(img);
        //如果一个控件需要监听事件 那么就必须实现监听事件的接口
        //告诉按钮是谁在监听这个事件
        btn.listener=this;
        //给ImageView添加以一个时间
        img.listener=new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                System.out.println("图片被点击了");
            }
        };
    }

    //模拟触摸的
    public void touch(){
        //将屏幕触摸的时间 传递给按钮
        btn.getTouchEvent();
        img.getTouchEvent();
}
    @Override
    public void onDestory() {
        //销毁之前需要做点什么事情
    }
    //
    @Override
    public void onClick(View v){
        System.out.println("按钮被点击了");

        }
}

6.实现事件监听

public class MainActivity extends Activity implements View.OnClickListener{

1.实现接⼝里⾯的方法

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

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

  btn.listener=this;

3.使⽤用匿名类给图⽚添加事件监听

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

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

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

5.MainActivity中添加方法模拟⼿手触摸屏幕将触摸的事件传递给按钮或者图⽚

  //模拟触摸的
    public void touch(){
        //将屏幕触摸的时间 传递给按钮
        btn.getTouchEvent();
        img.getTouchEvent();
}

7.外部使用

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

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

8.运行结果

image.png

5.练习小demo2

希望能够创建一个
使用这个模板可以方便的测出某个代码块的执行效率

package day6.JAVA.Templete;

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;
        }
    }


    }

image.png

JAVA-（抽象类、接口、实战小demo）

心得体会

技术

1.抽象类

2.接口

3.接口与抽象类的联系与区别

4.实战小demo1

5.练习小demo2

具体操作

1.抽象类

1.抽象类及抽象方法的定义

2.抽象类的性质

3.抽象类的使用

2.接口

1.接口的定义

2.接口的性质

3.接口与抽象类的联系与区别

1.联系

2.区别

4.实战小demo

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

2.管理一个视图显示和事件监听

3.创建按钮类

4.显示一张图片

5.创建主界面

6.实现事件监听

7.外部使用

8.运行结果

5.练习小demo2

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读