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