0013_抽象类与接口的应用及设计模式

于 2016-08-23 18:16:39 发布
阅读量255 收藏
点赞数
分类专栏： Java 文章标签： Java Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011633009/article/details/52291185
版权

为抽象类与接口实例化

在Java中可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类和接口的时候就可以调用本子类中所覆写过的方法了。

之所以抽象类和接口不能直接实例化，是因为其内部包含了各个抽象方法，抽象方法本身都是未实现的方法，所以无法调用。

通过对象多态性可以发现，子类发生了向上转型关系之后，所调用的全部方法都是被覆写过的方法。

abstract class A{	// 定义抽象类A
	public abstract void print() ;	// 定义抽象方法print()
};
class B extends A {	// 定义子类，继承抽象类
	public void print(){	// 覆写抽象方法
		System.out.println("Hello World!!!") ;
	}
};
public class AbstractCaseDemo01{
	public static void main(String args[]){
		A a = new B() ;	// 通过子类为抽象类实例化
		a.print() ;
	}
};

可以继续使用此概念，为一个接口实例化

interface A{	// 定义抽象类A
	public abstract void print() ;	// 定义抽象方法print()
};
class B implements A {	// 定义子类，继承抽象类
	public void print(){	// 覆写抽象方法
		System.out.println("Hello World!!!") ;
	}
};
public class InterfaceCaseDemo01{
	public static void main(String args[]){
		A a = new B() ;	// 通过子类为抽象类实例化
		a.print() ;
	}
};
证明，如果要使用抽象类或接口，则只能按照以上的操作完成。


抽象类的实际应用——定义模板

设想这样一种场景：假设人分为学生和老师，学生和老师都可以说话，但是学生和老师说话的内容是不一样的，也就是说“说话”这个功能应该是一个具体功能，而说话的内容就要由学生和老师来决定了。此时就可以使用抽象类实现这种场景。

abstract class Person{
	private String name ;	// 定义name属性
	private int age ;	// 定义age属性
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public void say(){	// 人说话是一个具体的功能
		System.out.println(this.getContent()) ;	// 输出内容
	}
	public abstract String getContent() ;	// 说话的内容由子类决定
};
class Student extends Person{
	private float score ;
	public Student(String name,int age,float score){
		super(name,age) ;    // 调用父类中的构造方法
		this.score = score ;
	}
	public String getContent(){
		return	"学生信息 --> 姓名：" + super.getName() + 
				"；年龄：" + super.getAge() + 
				"；成绩：" + this.score ;
	}
};
class Teacher extends Person{
	private float salary ;
	public Teacher(String name,int age,float salary){
		super(name,age) ;	// 调用父类中的构造方法
		this.salary = salary ;
	}
	public String getContent(){
		return	"老师信息 --> 姓名：" + super.getName() + 
				"；年龄：" + super.getAge() + 
				"；工资：" + this.salary ;
	}
};
public class AbstractCaseDemo02{
	public static void main(String args[]){
		Person per1 = null ;	// 声明Person对象
		Person per2 = null ;	// 声明Person对象
		per1 = new Student("张三",20,99.0f) ;	// 学生是一个人
		per2 = new Teacher("李四",30,3000.0f) ;	// 老师是一个人
		per1.say() ;	// 学生说学生的话
		per2.say() ;	// 老师说老师的话
	}
};

抽象类的实际应用——制定标准

接口在实际中更多的作用是用来制定标准的。比如说：U盘和打印机都可以插在电脑上使用，这是因为它们都实现了USB的接口，对于电脑来说，只要是符合了USB接口标准的设备就都可以插进来。

interface USB{	// 定义了USB接口
	public void start() ;	// USB设备开始工作
	public void stop() ;	// USB设备结束工作
}
class Computer{
	public static void plugin(USB usb){	// 电脑上可以插入USB设备
		usb.start() ;
		System.out.println("=========== USB 设备工作 ========") ;
		usb.stop() ;
	}
};
class Flash implements USB{
	public void start(){	// 覆写方法
		System.out.println("U盘开始工作。") ;
	}
	public void stop(){	// 覆写方法
		System.out.println("U盘停止工作。") ;
	}
};
class Print implements USB{
	public void start(){	// 覆写方法
		System.out.println("打印机开始工作。") ;
	}
	public void stop(){	// 覆写方法
		System.out.println("打印机停止工作。") ;
	}
};
public class InterfaceCaseDemo02{
	public static void main(String args[]){
		Computer.plugin(new Flash()) ;
		Computer.plugin(new Print()) ;
	}
};
如果深入学习的话，接口实际上还表示将方法的视图暴露给远程的客户端。


工厂设计模式

先来看如下问题：

interface Fruit{    // 定义一个水果接口
	public void eat() ;    // 吃水果
}
class Apple implements Fruit{
	public void eat(){
		System.out.println("** 吃苹果。") ;
	}
};
class Orange implements Fruit{
	public void eat(){
		System.out.println("** 吃橘子。") ;
	}
};
public class InterfaceCaseDemo03{
	public static void main(String args[]){
		Fruit f = new Apple() ;	   // 实例化接口
		f.eat() ;
	}
};
这样的代码有问题没有?

分析：主方法，应该就表示一个客户端，主方法的代码越少越好。此时，直接在主方法中指定了要操作的子类，那么如果要更换子类，则肯定要修改客户端，这就表示跟特定的子类紧密耦合在一起了。

此过渡端在程序中就成为工厂设计

interface Fruit{    // 定义一个水果接口
	public void eat() ;    // 吃水果
}
class Apple implements Fruit{
	public void eat(){
		System.out.println("** 吃苹果。") ;
	}
};
class Orange implements Fruit{
	public void eat(){
		System.out.println("** 吃橘子。") ;
	}
};
class Factory{	// 定义工厂类
	public static Fruit getInstance(String className){
		Fruit f = null ;
		if("apple".equals(className)){	// 判断是否要的是苹果的子类
			f = new Apple() ;
		}
		if("orange".equals(className)){	// 判断是否要的是橘子的子类
			f = new Orange() ;
		}
		return f ;
	}
};
public class InterfaceCaseDemo05{
	public static void main(String args[]){
		Fruit f = Factory.getInstance(args[0]) ;	// 实例化接口
		if(f!=null){	// 判断是否取得实例
			f.eat() ;
		}
	}
};


代理设计模式

所谓的代理设计就是指一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。好比在生活中经常使用到的代理上网那样，客户端通过网络代理连接网络，由代理服务器完成用户权限、访问权限等与上网操作相关的操作。

不管是代理操作也好，还是真实的操作也好，其共同目的就是上网，所以用户关心的只是上网，至于里面是如何操作的用户并不关心。

interface Network{
	public void browse() ;	  // 浏览
}
class Real implements Network{
	public void browse(){
		System.out.println("上网浏览信息") ;
	}
};
class Proxy implements Network{
	private Network network ;    // 代理对象
	public Proxy(Network network){
		this.network = network ;
	}
	public void check(){
		System.out.println("检查用户是否合法。") ;
	}
	public void browse(){
		this.check() ;
		this.network.browse() ;	   // 调用真实的主题操作
	}
};
public class ProxyDemo{
	public static void main(String args[]){
		Network net = null ;
		net  = new Proxy(new Real()) ;   //  指定代理操作
		net.browse() ;	 // 客户只关心上网浏览一个操作
	}
};


适配器设计模式

对于Java程序来说，如果一个类要实现一个接口，则肯定要覆写此接口中的全部抽象方法，那么如果此时一个接口中定义的抽象方法过多，但是在子类中又用不到这么多抽象方法的话，则肯定很麻烦，所以此时就需要一个中间的过渡，但是此过渡类又不希望被直接使用，所以将此过渡类定义成抽象类最合适，即一个接口首先被一个抽象类（此抽象类通常称为适配器类）实现，并在此抽象类中实现若干方法（方法体为空），则以后的子类直接继承此抽象类就可以有选择地覆写所需要的方法。

interface Window{    // 定义Window接口，表示窗口操作
	public void open() ;    // 打开
	public void close() ;	// 关闭
	public void activated() ;    // 窗口活动
	public void iconified() ;    // 窗口最小化
	public void deiconified();   // 窗口恢复大小
}
abstract class WindowAdapter implements Window{
	public void open(){} ;	 // 打开
	public void close(){} ;	 // 关闭
	public void activated(){} ;    // 窗口活动
	public void iconified(){} ;    // 窗口最小化
	public void deiconified(){};   // 窗口恢复大小
};
class WindowImpl extends WindowAdapter{
	public void open(){
		System.out.println("窗口打开。") ;
	}
	public void close(){
		System.out.println("窗口关闭。") ;
	}
};
public class AdapterDemo{
	public static void main(String args[]){
		Window win = new WindowImpl() ;
		win.open() ;
		win.close() ;
	}
};
此种设计思路，在Java的图形界面编程上使用的非常多，在Java EE的开发中并不是很常见。


内部类的扩展

在一个抽象类中也可以包含一个接口。

abstract class A{	// 定义抽象类
	public abstract void printA() ;	// 抽象方法
	interface B{	// 定义内部接口
		public void printB() ;	// 定义抽象方法
	}
};
class X extends A{	// 继承抽象类
	public void printA(){
		System.out.println("HELLO --> A") ;
	}
	class Y implements B{	// 定义内部类实现内部接口
		public void printB(){
			System.out.println("HELLO --> B") ;
		}
	};
};
public class InnerExtDemo01{
	public static void main(String args[]){
		A.B b = new X().new Y() ;
		b.printB() ;
	}
};
反之，在一个接口中也可以定义一个抽象类。
 
interface A{	// 定义接口
	public void printA() ;	// 抽象方法
	abstract class B{	// 定义内部抽象类
		public abstract void printB() ;	// 定义抽象方法
	}
};
class X implements A{	// 实现接口
	public void printA(){
		System.out.println("HELLO --> A") ;
	}
	class Y extends B{	// 继承抽象类
		public void printB(){
			System.out.println("HELLO --> B") ;
		}
	};
};
public class InnerExtDemo02{
	public static void main(String args[]){
		A.B b = new X().new Y() ;
		b.printB() ;
	}
};
但是，从实际的个人的开发角度来讲，此种设计并不是很常见，因为代码的结构有些混乱了。


抽象类与接口之间的关系


在开发中，一个类永远不要去继承一个已经实现好的类，要么继承抽象类，要么实现接口。如果接口和抽象类同时都可以使用的话，那么优先使用接口，避免单继承局限。

hi_guys
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值