JAVA SE基础（三）——抽象类、接口（工厂方法、代理模式）

最新推荐文章于 2024-02-27 08:47:24 发布

原创最新推荐文章于 2024-02-27 08:47:24 发布 · 297 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

java se 专栏收录该内容

13 篇文章

订阅专栏

本文详细介绍了JAVA中的抽象类和接口，包括抽象类的特性、模板方法设计模式，以及接口的定义和作用。重点讲解了抽象类中的抽象方法、模板方法模式的应用，接口的多重继承和多态性，并探讨了工厂方法和代理模式的设计思想。

抽象类（abstract class）

模板方法（TemplateMethod）设计模式

抽象类（abstract class）

abstract关键字：抽象的，可以用来修饰类、方法
abstract：修饰类，抽象类

①不可被实例化

②抽象类中有构造器（所有的类都有构造器）

③抽象方法所在的类一定是抽象类

④抽象类中可以没有抽象方法（抽象类内仅有abstract class修饰，仅不可实例化，其余与一般类一致）

[当设计一个类，不需要创建此类的实例时，就可以考虑将其设置为抽象地，由其子类实现抽象方法 ]

abstract修饰方法：抽象方法——只声明，无定义

①格式：[权限修饰符] abstract [返回值类型] [方法名] （）；

②抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法

③若子类继承抽象类，并重写了所有的抽象方法，则此类是一个“实体类”，即可以实例化

④若子类继承抽象类，没有重写所有的抽象方法，此类中仍有抽象方法，则此类必须声明为抽象类

//抽象类中有抽象方法
abstract class Person{
	int id;
	String name;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	public abstract void eat();
	public abstract void walk();
}

//抽象类中无抽象方法
abstract class Person{
	int id;
	String name;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public void eat() {
		System.out.println("吃饭");
	}
	public void walk() {
		System.out.println("散步");
	}
}

//子类继承自抽象类
class Student extends Person{

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("学生吃饭");
	}

	@Override
	public void walk() {
		// TODO Auto-generated method stub
		System.out.println("学生走路");
	}
	
}

不可用来修饰属性、私有方法、构造器、静态方法、final的方法

①构造器不能被重写

②子类不能覆盖（重写）声明为private的方法

模板方法（TemplateMethod）设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
解决问题：

①当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

②编写一个抽象父类，父类提供了多个子类的通用方式，并把一个或多个方法留给其子类实现，就是一种模板模式。

/*
 * 模板方法设计模式
 */
public class TemplateTest {
	public static void main(String[] args) {
		new SubTemplate().spendTime();
	}

}

abstract class Template {
	public abstract void code();

	public void spendTime() {
		long start = System.currentTimeMillis();
		this.code();
		long end = System.currentTimeMillis();
		System.out.println("花费时间： " + (end - start));
	}
}

class SubTemplate extends Template{
	public void code() {
		boolean flag=false;
		for(int i=2;i<=10000;++i) {
			for(int j=2;j<=Math.sqrt(i);++j) {
				if(i%j==0) {
					flag=true;
					break;
				}
			}
			if(!flag) {
				System.out.println(i);
			}
			flag=false;
		}
	}
}

接口（interface）

有时必须从几个类种派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果；
接口就是抽象方法和常量值的定义的集合；
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现；
实现接口类：class SubClass implements InterfaceA{}；
一个类可以实现多个接口，接口也可以继承其他接口；

/*
 *接口是与类并行的一个概念
 *1、接口可以看作是一个特殊的抽象类，是常量与抽象方法的一个集合
 *2、接口没有构造器
 *3、接口定义的就是一种功能，此功能可以被类所实现（implements）
 *4、实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
 ****5、类可以实现多个接口————java中是单继承的
 ****6、接口与接口之间也是继承关系，而且可以实现多继承
*接口与实现类之间可以实现多态性

 */

interface InterfaceA{
	//常量：所有的常量都用public static final
	public static final int I = 2020;
	public static final boolean FALG = false;
	
	//抽象方法:所有的都用public abstract修饰
	public abstract void method1();
	void method2();
	
}
interface InterfaceB{}
//接口之间可以实现多继承
interface InterfaceC extends InterfaceA,InterfaceB{}
//抽象类实现接口
abstract class AbstractClassA implements InterfaceA{
	
}

//实现接口
class ClassA implements InterfaceA{
	public void method1() {
		System.out.println("ClassA   method1()");
	}
	public void method2() {
		System.out.println("ClassB   method2()");
	}
	
}
//继承抽象类，实现接口————多继承
class ClassB extends AbstractClassA implements InterfaceA{
	public void method1() {
		System.out.println("ClassB   method1()");
	}
	public void method2() {
		System.out.println("ClassB   method2()");
	}
}

接口的多态性


/*
 * 接口与具体的实现类之间也存在多态性
 */
public class InterfaceTest1 {
	public static void main(String[] args) {
		Person person = new Person();
		testrun(duck);//奔跑
		testswim(duck);//游泳
		testfly(duck);//飞行
	}
	
	public static void testrun(Runner r) {
		r.run();
	}
	public static void testswim(Swimmer s) {
		s.swim();
	}
	public static void testfly(Flier f) {
		f.fly();
	}

}

interface Runner{
	public abstract void run();
}

interface Swimmer{
	void swim();
}

interface Flier{
	void fly();
}

class Person implements Runner,Swimmer,Flier{

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("飞行");
		
	}

	@Override
	public void swim() {
		// TODO Auto-generated method stub
		System.out.println("游泳");
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("奔跑");
	}
	
}

【总结】：

①通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系

②通过接口可以知名多个类需要实现的方法，一般用于定义对象的扩张功能

③接口主要用来定义规范。接触耦合关系。

设计模式 — 接口

工厂方法（FactoryMethod）

概述：定义一个用于创建对象的接口，让子类决定实例化哪个类。FactoryMethod使一个类的实例化延迟到其子类
适用性：

①当一个类不知道它所必须创建的对象的类的时候

②当一个类需要由它的子类来指定它所创建的对象的时候

③当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候

示例

//工厂方法设计模式
public class FactoryMethodTest {
	public static void main(String[] args) {
		IWorkFactory i = new StudentWorkFactory();
		i.getWork().doWork();

		IWorkFactory i1 = new TeacherWorkFactory();
		i1.getWork().doWork();
	}

}

interface IWorkFactory {
	Work getWork();
}

class StudentWorkFactory implements IWorkFactory {

	@Override
	public Work getWork() {
		// TODO Auto-generated method stub
		return new StudentWork();
	}

}

class TeacherWorkFactory implements IWorkFactory {

	@Override
	public Work getWork() {
		// TODO Auto-generated method stub
		return new TeacherWork();
	}

}

interface Work {
	void doWork();
}

class StudentWork implements Work {

	@Override
	public void doWork() {
		// TODO Auto-generated method stub
		System.out.println("student work");
	}

}

class TeacherWork implements Work {

	@Override
	public void doWork() {
		// TODO Auto-generated method stub
		System.out.println("teacher work");
	}

}

代理模式（Proxy）

概述：为其他对象提供以一种代理以控制对这个对象的访问
适用：此类代理其他类执行操作
UML

示例：

//代理模式
public class ProxyTest {
	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();
/**代理类创建成功！
代理类开始执行！
=====被代理类开始执行=====
=====具体的操作=====
=====被代理类执行完毕=====
代理类执行结束！
*/
	}

}

interface Object{
	void action();
}
//代理类
class ProxyObject implements Object{
	Object obj;
	
	public ProxyObject() {
		System.out.println("代理类创建成功！");
		obj=new ObjectImpl();
	}
	public void action() {
		System.out.println("代理类开始执行！");
		obj.action();
		System.out.println("代理类执行结束！");
	}
	
}

//被代理类
class ObjectImpl implements Object{

	@Override
	public void action() {
		// TODO Auto-generated method stub
		System.out.println("=====被代理类开始执行=====");
		System.out.println("=====具体的操作=====");
		System.out.println("=====被代理类执行完毕=====");
	}
	
}