一、抽象类(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;
}
}
}
