java抽象类与接口——设计模式

简介: 1、工厂模式先看程序1:package com.java.abs;interface Fruit {// 定义一个接口水果 public void eat();}class Apple implements Fruit { public void eat() { System.

1、工厂模式

先看程序1:


package com.java.abs;

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 InterfaceCaseDemo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fruit f = new Apple();// 实例化接口
		f.eat();
	}

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

JVM的工作原理:程序→JVM→操作系统

图1图1


此过渡段就称为工厂设计


改进后的程序

package com.java.abs;

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".equalsIgnoreCase(className)) {
			/*
			 * 一般字符串比较,不写成className.equalsIgnoreCase("Apple")
			 * 因为className为空时,空的对象无法调用方法,即产生空指针异常!
			 */
			f = new Apple();
		}
		if ("Orange".equalsIgnoreCase(className)) {
			f = new Orange();
		}
		return f;
	}
}

public class InterfaceCaseDemo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fruit f = Factory.getInstance(args[0]);// 实例化接口args[0]通过初始化参数设置。在dos下运行才可以设置
		if (f != null) {
			f.eat();
		}
	}
}
2、代理模式

package com.java.abs;
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 InterfaceCaseDemo2 {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Network net = null;
		net = new Proxy(new Real());// 制定代理操作    构造方法的参数是 new Real
		net.browse();
	}


}
图2 图2


3、适配器模式(多用于java图形化界面)
对于java程序来说:如果要实现一个接口,则肯定要覆写接口中的全部抽象方法,那么如果,接口中方法太多,但是子类有用不到那么多的抽象方法,则很麻烦,此时需要一个中间过渡,但是此过渡类有不希望被直接使用,所以将此过渡类定义成抽象类比较合适,即一个接口首先被一个抽象类(称作适配器类),并在此抽象类中实现若方法(方法体为空),则以后的子类直接继承此抽象类,就可以有选择的覆写所需要的方法了。

图3图3


package com.java.extend;

interface Windows {
	public void open();

	public void close();

	public void activated();

	public void iconified();

	public void deiconified();

}

abstract class WindowAdapter {
	public void open() {
	}

	public void close() {
	}

	public void activated() {
	}

	public void iconified() {
	}

	public void deiconified() {
	}
}

class WindowsImpl extends WindowAdapter {

	public void open() {
		System.out.println("打开窗口");
	}

	public void close() {
		System.out.println("关闭窗口");
	}
}

public class AdapterDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		WindowsImpl wd = new WindowsImpl();
		wd.open();
		wd.close();
	}
}

抽象类与接口杂谈——内部类的扩展

在一个抽象类中定义一个接口,用内部类来继承并实现内部接口。反之,在一个接口中也可以定义一个抽象类程序2,但是实际中并不常见!

程序1:

package com.java.extend;

abstract class A2 {
	public abstract void printA();

	interface B {
		public void printB();
	}
}

class X extends A2 {
	public void printA() {
		System.out.println("打印A1");
	}

	class Y implements B {
		public void printB() {
			System.out.println("打印B");
		}
	}
}

public class InnerExtend extends X {
	public static void main(String args[]) {
		A2.B b = new X().new Y();
		b.printB();
	}
}

程序2

package com.java.extend;


interface AA {
	public abstract void printA();


	abstract class B {
		public abstract void printB();
	}
}


class X1 implements AA {
	public void printA() {
		System.out.println("打印A1");
	}


	class Y extends B {
		public void printB() {
			System.out.println("打印B");
		}
	}
}


public class InnerExtend2 extends X1 {
	public static void main(String args[]) {
		B b = new X1().new Y();
		b.printB();
	}
}

抽象类和接口的关系

图4

接口和抽象类是使用普通子类,子类必须覆写全部抽象方法,写出方法体;

相关文章
|
3天前
|
Java 开发者
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
在Java多线程编程的世界里,Lock接口正逐渐成为高手们的首选,取代了传统的synchronized关键字
18 4
|
10天前
|
安全 Java
在 Java 中使用实现 Runnable 接口的方式创建线程
【10月更文挑战第22天】通过以上内容的介绍,相信你已经对在 Java 中如何使用实现 Runnable 接口的方式创建线程有了更深入的了解。在实际应用中,需要根据具体的需求和场景,合理选择线程创建方式,并注意线程安全、同步、通信等相关问题,以确保程序的正确性和稳定性。
|
8天前
|
Java
Java基础(13)抽象类、接口
本文介绍了Java面向对象编程中的抽象类和接口两个核心概念。抽象类不能被实例化,通常用于定义子类的通用方法和属性;接口则是完全抽象的类,允许声明一组方法但不实现它们。文章通过代码示例详细解析了抽象类和接口的定义及实现,并讨论了它们的区别和使用场景。
|
8天前
|
Java 测试技术 API
Java零基础-接口详解
【10月更文挑战第19天】Java零基础教学篇,手把手实践教学!
16 1
|
10天前
|
Java 测试技术 开发者
Java零基础-抽象类详解
【10月更文挑战第17天】Java零基础教学篇,手把手实践教学!
10 2
|
12天前
|
Java 测试技术 开发者
Java零基础-抽象类详解
【10月更文挑战第15天】Java零基础教学篇,手把手实践教学!
17 2
|
13天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
13 3
|
13天前
|
Java
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
27 2
|
13天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
26 2
|
13天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
25 1