6.5 抽象类与抽象方法
1. 抽象类的引入
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一 般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
2. abstract关键字
可以修饰的结构：类、方法，代表抽象的
不能修饰的结构：变量、代码块、构造器、私有方法、静态方法、final的方法、final的类
4. 抽象类：用abstract修饰的类
特点：
- 抽象类不能实例化
- 抽象类中一定有构造器，便于子类实例化时调用
- 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
例子
abstract class Person {
private int id;
public void eat() {
System.out.println("吃饭");
}
}
class Student extends Person {
}
public class PersonTest {
public static void main(String[] args) {
Person p = new Person(); // 会报错，不合法
}
}
5. 抽象方法：用abstract修饰的方法
特点：
-
抽象方法只有方法的声明，没有方法体
-
包含抽象方法的类，一定是一个抽象类；反之，抽象类中可以没有抽象方法的。
-
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
例子
abstract class Person {
private int id;
public abstract void eat();
}
class Student extends Person {
public void eat() { // 如果不声明为抽象类则必须实现，否则报错，也可以将该类声明为抽象的
System.out.println("学生要吃饭");
}
}
public class PersonTest {
public static void main(String[] args) {
Student s = new Student();
}
}
6. 抽象类的匿名子类
public class PersonTest {
public static void main(String[] args) {
method(new Student()); // 匿名对象
Worker worker = new Worker();
method1(worker); // 非匿名的类非匿名的对象
method1(new Worker()); // 非匿名的类匿名的对象
// 创建了一匿名子类的对象：p
Person p = new Person(){
@Override
public void eat() {
System.out.println("吃东西");
}
@Override
public void breath() {
System.out.println("好好呼吸");
}
};
method1(p); // 匿名的类非匿名的对象
//创建匿名子类的匿名对象
method1(new Person(){ // 匿名的类匿名的对象
@Override
public void eat() {
System.out.println("吃好吃东西");
}
@Override
public void breath() {
System.out.println("好好呼吸新鲜空气");
}
});
}
public static void method1(Person p){
p.eat();
p.breath();
}
public static void method(Student s){
}
}
class Worker extends Person{
@Override
public void eat() {
}
@Override
public void breath() {
}
}
7. 抽象类的应用——模板方法设计模式
7.1 模板方法设计模式所解决的问题：
当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。 例如：在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现，这就是一种模板模式。
public class TemplateTest {
public static void main(String[] args) {
Template template = new SubTemplate();
template.templateMethod();
// 输出：
// 该方法是特定的方法，抽象类中具体实现的方法
// 抽象方法的具体实现
}
}
abstract class Template {
public void templateMethod() {
specificMethod();
abstractMethod();
}
public void specificMethod() {
System.out.println("该方法是特定的方法，抽象类中具体实现的方法");
}
public abstract void abstractMethod();
}
class SubTemplate extends Template {
@Override
public void abstractMethod() {
System.out.println("抽象方法的具体实现");
}
}
7.2 实际应用例子
问题描述：当一个人前往银行一般会经历以下步骤，首先会到自助取号机处取号，随后排队等待办理业务，当叫到自己后前往柜台办理相应业务，办理完后会对工作人员进行评价，随后即可离开；其中每个人办理的业务可能不同，但其他的内容是一样的，这就可以使用模板方法设计模式。
代码实现：
public class BankTest {
public static void main(String[] args) {
BankProcessTemplate depositorProcess = new DepositorProcess();
depositorProcess.process();
BankProcessTemplate withdrawerProcess = new WithdrawerProcess();
withdrawerProcess.process();
}
}
abstract class BankProcessTemplate {
public void takeNumber() {
System.out.println("我要取号");
}
public void lineUp() {
System.out.println("我正在排队");
}
public abstract void handleBankingBusiness();
public void evaluate() {
System.out.println("我要对服务进行评价");
}
public void leave() {
System.out.println("我要离开了");
}
public final void process() {
takeNumber();
lineUp();
handleBankingBusiness();
evaluate();
leave();
}
}
class DepositorProcess extends BankProcessTemplate {
@Override
public void handleBankingBusiness() {
System.out.println("这是我要处理的业务：我需要存款");
}
}
class WithdrawerProcess extends BankProcessTemplate {
@Override
public void handleBankingBusiness() {
System.out.println("这是我要处理的业务：我需要取款");
}
}
7.3 常见的用到了模板设计模式的地方
- 数据库访问的封装
- Junit单元测试
- JavaWeb的Servlet中关于doGet/doPost方法调用
- Hibernate中模板程序
- Spring中JDBCTemlate、HibernateTemplate等
6.6 接口(interface)
1. 接口概述
- 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
- 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
- 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 “能不能” 的关系。
- 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都 要遵守。
2. 接口相关概念
接口(interface)是抽象方法和常量值定义的集合。
接口的特点：
-
用interface来定义。
-
Java中，接口和类是并列的两个结构
-
接口中的所有成员变量(全局常量)都默认是由
public static final修饰的 -
接口中的所有抽象方法都默认是由
public abstract修饰的 -
接口中不能定义构造器的；即接口不可以实例化
-
Java开发中，接口通过让类去实现(implements)的方式来使用**（面向接口编程）**
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
-
Java类可以实现多个接口 —> 弥补了Java单继承性的局限性，如果实现的接口或继承的类中相同名称的属性并且进行调用时，则会报错
The field x is ambiguous格式：
class AA extends BB implements CC,DD,EE {} -
接口与接口之间可以继承，且可以多继承
例如：
interface CC extends AA,BB {} -
接口的具体使用，体现多态性
-
接口，实际上可以看做是一种规范
3. 接口的使用：定义接口中的成员
接口也可以使用匿名实现类，使用方法同抽象类的匿名子类
JDK7及以前：只能定义全局常量和抽象方法
-
全局常量：
public static final的，可以省略不写，默认就是 -
抽象方法：
public abstract的，可以省略不写，默认就是 -
例子：
public interface Runner { public static final int ID = 1; public abstract void start(); public abstract void run(); public abstract void stop(); } // 相同 public interface Runner { int ID = 1; void start(); public void run(); void stop(); }
JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
-
静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。
-
默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。
-
例子：
interface AA { double PI = 3.14; public default void method() { System.out.println("北京"); } // 省略了public default String method1() { return "上海"; } // 省略了public static void method2() { System.out.println("hello lambda!"); } } class BB implements AA { public void myMethod(){ //调用接口中的默认方法 AA.super.method(); } } public class AATest { public static void main(String[] args) { AA.method2(); BB bb = new BB(); // bb.method2(); // 报错 bb.method1(); } } -
特点：
-
接口中定义的静态方法，只能通过接口来调用。
-
通过实现类的对象，可以调用接口中的默认方法。
-
实现类调用接口中的默认方法：“接口.super.方法”
-
若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。
-
若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。
-
4. 接口的应用：代理设计模式
4.1 代理设计模式概述
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。
静态代理模式的实现
public class ProxyTest {
public static void main(String[] args) {
Subject subject = new ProxySubject(new RealSubject());
subject.request();
}
}
// 抽象主题
interface Subject {
void request();
}
// 真实的主题（被代理类）
class RealSubject implements Subject {
@Override
public void request() {
System.out.println("真实的主题方法");
}
}
// 代理类
class ProxySubject implements Subject {
private Subject subject = null;
public ProxySubject(Subject subject) {
this.subject = subject;
}
@Override
public void request() {
preRequest();
subject.request();
postRequest();
}
public void preRequest() {
System.out.println("处理真实的主题前需要做的任务");
}
public void postRequest() {
System.out.println("处理真实的主题后需要做的任务");
}
}
4.2 实际应用例子
问题描述：
现有一个房东需要出租房屋，因此他寻找了一家中介公司，将房子出租的消息挂在了中介公司，恰好有个人需要住房，他找到了该中介公司，该中介公司带着该客户前往房子查看，随后告诉房东进行出租，并收取了一定的中介费。
代码实现——静态代理
public class LeaseTest {
public static void main(String[] args) {
// 可以看作客户找中介租房子
Intermediary intermediary = new Intermediary(new LandlordOrLandlady());
intermediary.lease();
}
}
interface Lease {
void lease();
}
class LandlordOrLandlady implements Lease {
@Override
public void lease() {
System.out.println("我是房东，我要出租房屋");
}
}
class Intermediary implements Lease {
private LandlordOrLandlady landlady;
public Intermediary(LandlordOrLandlady landlady) {
this.landlady = landlady;
}
public void seeHouse() {
System.out.println("我是中介，现在我们去看房子");
}
@Override
public void lease() {
seeHouse();
landlady.lease();
charge();
}
public void charge() {
System.out.println("我是中介，现在房子已经出租，请交一下中介费");
}
}
4.3 代理设计模式的应用场景
-
安全代理：屏蔽对真实角色的直接访问。
-
远程代理：通过代理类处理远程方法调用（RMI）
-
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象
比如开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有 100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
分类
- 静态代理（静态定义代理类）
- 动态代理（动态生成代理类）
6.7 类的内部成员之五： 内部类
1. 内部类的概述
-
当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类
-
在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类
-
内部类一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称，内部类的名字不能与包含它的外部类类名相同
-
分类： 成员内部类：static成员内部类（静态内部类）和非static成员内部类（非静态内部类）
局部内部类（不谈修饰符）：可以声明在方法内、代码块内、构造器内；匿名内部类（局部内部类的简写）
2. 成员内部类
成员内部类作为外部类的成员的角色：
- 和外部类不同，成员内部类还可以声明为private或protected
- 可以调用外部类的结构
- 成员内部类可以声明为static的，但此时就不能再使用外层类的非static的成员变量
成员内部类作为类的角色：
- 可以在内部定义属性、方法、构造器等结构
- 可以声明为abstract类 ，因此可以被其它的内部类继承
- 可以声明为final的，表示此类不能被继承
- 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）
其他注意事项：
- 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
- 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
- 成员内部类可以直接使用外部类的所有成员，包括私有的数据
- 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的
例子：
class A {
private String name;
static class B {
private int id;
public void eat() {
// System.out.println(name); // 报错
System.out.println("吃");
}
}
class C {
private String name;
public void eat() {
System.out.println(A.this.name); // 同名这样调
System.out.println(name);
System.out.println("吃");
}
}
}
public class InnerClassTest {
public static void main(String[] args) {
// 创建静态内部类对象
A.B b = new A.B();
b.eat();
// 创建非静态内部类对象
A a = new A();
A.C c = a.new C();
c.eat();
}
}
3. 局部内部类
使用
- 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
- 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型
特点：
- 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
- 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
- 局部内部类可以使用外部类的成员，包括私有的。
- 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
- 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
- 局部内部类不能使用static修饰，因此也不能包含静态成员
例子：
class A {
public void method() {
class B {
private String name;
public void eat() {
System.out.println("吃");
}
}
B b = new B();
b.eat();
}
}
public class InnerClassTest {
public static void main(String[] args) {
A a = new A();
a.method();
}
}
匿名内部类
-
匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
-
格式：
new 父类构造器（实参列表）|实现接口(){ //匿名内部类的类体部分 } -
匿名内部类的特点
- 匿名内部类必须继承父类或实现接口
- 匿名内部类只能有一个对象
- 匿名内部类对象只能使用多态形式引用
-
例子
interface B { void eat(); } class A { public B method() { return new B() { @Override public void eat() { System.out.println("吃"); } }; } } public class InnerClassTest { public static void main(String[] args) { A a = new A(); B b = a.method(); b.eat(); } }
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
