java SE 教程 day11

抽象类(重点)

用abstract关键字修饰的类称为抽象类。

抽象类不能实例化，抽象类的意义在于“被继承”。

抽象类为其子类“抽象”出了公共的部分，通常也定义了子类所必须具体实现的抽象方法。
模版方法设计模式 (重点)

定义:

定义一个功能的骨架 , 一部分功能是确定的 , 一部分 功能是不确定的 , 把确定的实现, 不确定的功能抽取抽象出来, 延迟到子类中实现 !

案例:

public abstract class DaBaoJian {
public void baoJian() {
System.out.println(“大哥 , 您又来了 ? 哎呦, 还带着肾宝来的 ! “);
System.out.println(“哥 , 你是足疗 还是 按摩啊?”);
System.out.println(“哥, 整个法器不? “);
if(work()) {
System.out.println(“大哥, 您进这个没有窗户的屋子 ~ 里面亮堂~ “);
System.out.println(“床啊 ~ 床 ~ 床啊 ~ 床”);
}else {
System.out.println(“别整那没用的 , 来俩吧 ~ “);
System.out.println(“大哥, 您进这个没有窗户的屋子 ~ 里面亮堂~ “);
System.out.println(“大床啊 ~ 床 ~ 大床啊 ~ 床”);
}
}

public abstract boolean work();

}

public class DongFei_DaBaoJian extends DaBaoJian {

private String name;
private int length;

public DongFei_DaBaoJian() {
    super();
}

public DongFei_DaBaoJian(String name, int length) {
    super();
    this.name = name;
    this.length = length;
}

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getLength() {
    return length;
}
public void setLength(int length) {
    this.length = length;
}
@Override
public boolean work() {
    System.out.println(name+"低头看了看自己的"+length);
    if(length>15) {
        System.out.println("最近身体火气大 ~ ");
        return false;
    }else {
        System.out.println("虽然肾宝好  , 但是今天还有事 ~ ");
        return true;
    }
}

}
接口 重点

如果一个类中的全部方法都是抽象方法 , 全部属性都是全局常量 , 那么此时就可以将这个类定义为一个接口 !

一个类 可以实现多个接口, 这点与继承不同 !

如果一个接口 没有具体的实现类 , 那么这个接口 没有任何的意义 !

接口与接口之间可以使用继承关系 !

特别注意:

接口和继承是可以同时存在的, 例如: 

class A extends B implements C,D{

}

面向接口编程 !

定义格式:

interface 接口名称{

    全局常量;
    抽象方法;
}

类实现接口的格式:

class 类名 implements 接口1,接口2...接口N{

}

在接口中定义不了变量, 必须定义常量:

public static final 数据类型 常量名 = 初始化值; 

如果编写为:

数据类型 常量名=  初始化值; 

则编译器, 自动添加为如下格式:

public static final 数据类型 常量名 = 初始化值; 

在接口中无法编写具体的方法实现 (不能编写方法体) ,

在编写方法时, 可以省略调用abstract关键字, 会自动添加 public abstract

如果编写为: 

    void haha();

则编译器会自动修改为如下格式: 

    public abstract void haha();

匿名对象(重点)

思考 我们为什么在创建时 给对象添加引用名;

Person p = new Person();

我们添加引用名 , 是为了创建一次对象 能操作很多次 !

有时我们有些特殊的需求下, 可能某一个对象被创建后 只使用一次, 那么我们可以使用匿名对象 ,格式:

new 类名()

例如:

System.out.println(new Person().toString());

---

匿名对象只能使用一次, 使用完毕后, 被GC视为垃圾, 进行回收 !
内部类: (掌握)

内部类 就是一个类中的成员类 :

package cn.xdl.demo6;

public class Outer {
private String name;
public void say() {
System.out.println(“哈哈哈哈哈哈”);
}
public String getName() {
return name;
}

public void setName(String name) {
    this.name = name;
}

//TODO-----------------------------------------------

class Inner{
    public void hahaha() {
        System.out.println("我是Inner类的HaHaHa方法, 但是我可以访问到:"+name);
    }
}

}

观察上述的代码 :

缺点:
一个类在设计时, 应该只包含特征和行为, 定义内部类 打破了原有的格式!

优点:
对于内部类(Inner)来说, 优点很大 , 简化程序的开发, 因为再Inner中可以直接访问Outer中的私有属性

内部类对象定义的格式:

步骤:

1.  创建外部类对象: 

    外部类类名 外部类对象名 = new 外部类类名();
2.  通过外部类对象, 创建内部类对象
    外部类类名.内部类类名 内部类对象名= 外部类对象名.new 内部类类名();

内部类经过javac编译器编译后, 产生的class文件为:

外部类名$内部类名.class

匿名内部类 (掌握)

没有给类添加名称 , 只能使用一次的内部类, 我们称其为匿名内部类 !

语法:

new 父类名称(){
//匿名类的代码块
}

例如:

interface Person{

}

public static void main(String[] args){
Person p = new Person(){

}

}

类似于:

interface Person{

}

class Person_Demo implements Person{

}
public static void main(String[] args){
Person p = new Person_Demo();
}

回调接口模式:
A.java:
public class A {
public void say(B b) {
b.run(“A传递的参数!”);
}
}

B.java:
public interface B {
void run(String text);
}
Demo.java:
public class Demo {

static B b = new B() {
    @Override
    public void run(String text) {
        System.out.println("run方法正在执行, 打印的内容为:"+text);
    }
};
public static void main(String[] args) {
    A a = new A();
    a.say(b);
}

}
静态内部类 了解

静态内部类使用上 基本 与 外部类一致 !

格式:

static class 类名{
}

创建静态内部类对象的格式:

外部类名.内部类名 对象名 = new 外部类名.内部类名();