java-面向对象5-抽象类与抽象方法和接口

---

前言

本文主要介绍java中抽象类与抽象方法、接口

1、抽象类与抽象方法

将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

抽象类与抽象方法：
抽象类:用abstract关键字来修饰的类。
抽象方法:用abstract关键字来修饰的方法。

• 抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如：public abstract void talk();

说明：

• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
• 不能用abstract修饰变量、代码块、构造器；
• 不能用abstract修饰私有方法、静态方法、final的方法、final的类。

abstract class A {
	abstract void m1();

	public void m2() {
		System.out.println("A类中定义的m2方法");
	}
}

class B extends A {
	void m1() {
		System.out.println("B类中定义的m1方法");
	}
}

public class Abstract {
	public static void main(String[] args) {
		A a = new B();
		a.m1();//B类中定义的m1方法
		a.m2();//A类中定义的m2方法
	}
}

抽象类匿名子类的应用：

abstract class A {
	abstract void m1();

	public void m2() {
		System.out.println("A类中定义的m2方法");
	}
}

class B extends A {
	void m1() {
		System.out.println("B类中定义的m1方法");
	}
}

public class AbstractTest {
	public static void main(String[] args) {
		// 抽象类的匿名子类非匿名对象
		A a = new A() {
			@Override
			void m1() {
				System.out.println("抽象类的匿名子类非匿名对象中定义的m1方法");
			}
		};
		method(a);
		System.out.println("------");
		// 抽象类的匿名子类匿名对象
		method(new A() {
			@Override
			void m1() {
				System.out.println("抽象类的匿名子类匿名对象中定义的m1方法");
			}
		});
	}

	public static void method(A a) {
		a.m1();
	}

}

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

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

public class TemplateTest {
	public static void main(String[] args) {
		SubTemplate su=new SubTemplate();
		su.getTime();
	}
}

abstract class Template {
	public final void getTime() {
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		System.out.println("执行时间是：" + (end - start));
	}

	public abstract void code();
}

class SubTemplate extends Template {
	public void code() {
		for (int i = 0; i < 10000; i++) {
			System.out.println(i);
		}
	}
}

模板方法应用场景：

• 数据库访问的封装
• Junit单元测试
• JavaWeb的Servlet中关于doGet/doPost方法调用
• Hibernate中模板程序
• Spring中JDBCTemlate、HibernateTemplate等

2、接口(interface)

接口的定义：

• 接口(interface)是抽象方法和常量值定义的集合。

接口的特点：

• 用interface来定义。
• 接口中的所有成员变量都默认是由public static final修饰的。
• 接口中的所有抽象方法都默认是由public abstract修饰的。
• 接口中没有构造器。
• 接口采用多继承机制。
• 接口实际上是一种规范。

接口的定义：

• 定义Java类的语法格式：先写extends，后写implements
  • class SubClass extends SuperClass implements InterfaceA{ }
• 一个类可以实现多个接口，接口也可以继承其它接口。
• 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
• 接口的主要用途就是被实现类实现。（面向接口编程）
• 与继承关系类似，接口与实现类之间存在多态性
• 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲， 接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义 (JDK7.0及之前)，而没有变量和方法的实现。

interface Attackable{
	void attack();
}


interface Flyable{
	//全局常量
	public static final int MAX_SPEED = 7900;
	//省略了public static final
	int MIN_SPEED = 1;
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
}

class Plane implements Flyable{

	@Override
	public void fly() {
		//具体实现方法
	}

	@Override
	public void stop() {
		//具体实现方法
	}
	
}
// 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类
abstract class Kite implements Flyable{
	@Override
	public void fly() {
		
	}	
}
//接口也可以继承其它接口
interface Kite1 extends Attackable,Flyable{
	void myMethod();
}
//一个类可以实现多个接口
class Bullet extends Object implements Flyable,Attackable{

	@Override
	public void attack() {
		//具体实现方法
	}

	@Override
	public void fly() {
		//具体实现方法
	}

	@Override
	public void stop() {
		//具体实现方法
	}
}

接口实现子类的应用：

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED = 2;
		
		
		
		//1.创建了接口的非匿名实现类的非匿名对象
		Plane plane = new Plane();
		method(plane);
		//2. 创建了接口的非匿名实现类的匿名对象
		method(new Plane());
		//3. 创建了接口的匿名实现类的非匿名对象
		Flyable flyable =new Flyable() {
			@Override
			public void stop() {
				
			}
			
			@Override
			public void fly() {
				
			}
		};
		method(flyable);
		//4. 创建了接口的匿名实现类的匿名对象
		method(new Flyable() {
			@Override
			public void stop() {
				
			}
			
			@Override
			public void fly() {
				
			}
		});
	}
	
	public static void method(Flyable flyable) {
		flyable.fly();
		flyable.stop();
	}
}

接口的应用：代理模式(Proxy)：
概述：
代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

应用场景：

• 安全代理：屏蔽对真实角色的直接访问。
• 远程代理：通过代理类处理远程方法调用（RMI）
• 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象
  分类：
• 静态代理（静态定义代理类）
• 动态代理（动态生成代理类）

/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
	public static void main(String[] args) {
		Server server = new Server();
		ProxyServer proxyServer = new ProxyServer(server);
		proxyServer.browse();
	}
}

interface NetWork {
	public void browse();
}

//被代理类
class Server implements NetWork {
	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}
}

//代理类
class ProxyServer implements NetWork {
	private NetWork work;

	public ProxyServer(NetWork work) {
		this.work = work;
	}

	public void check() {
		System.out.println("联网之前的检查工作");
	}

	@Override
	public void browse() {
		check();
		work.browse();
	}
}

Java 8中关于接口的改进：
Java 8中，可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用 static关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用default关键字修饰。可以通过实现类对象来调用。 我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。

• 比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。

/*
 * JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
 * 
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	//默认方法
	public default void method2(){
		System.out.println("CompareA：上海");
	}
	
	default void method3(){
		System.out.println("CompareA：上海");
	}
}

说明：

• 接口中定义的静态方法，只能通过接口来调用。
• 通过实现类的对象，可以调用接口中的默认方法。
  • 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
• 如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
• 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
  • 那么在实现类没有重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法
  • 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略

class SuperClass {

	public void method3() {
		System.out.println("SuperClass:北京");
	}

}

interface CompareA {

	// 静态方法
	public static void method1() {
		System.out.println("CompareA:北京");
	}

	// 默认方法
	public default void method2() {
		System.out.println("CompareA：上海");
	}

	default void method3() {
		System.out.println("CompareA：上海");
	}
}

interface CompareB {

	default void method3() {
		System.out.println("CompareB：上海");
	}

}

class SubClass extends SuperClass implements CompareA, CompareB {
	public void method2() {
		System.out.println("SubClass：上海");
	}

	public void method3() {
		System.out.println("SubClass：深圳");
	}

	// 子类(或实现类)的方法中调用父类、接口中被重写的方法
	public void myMethod() {
		method3();// 调用自己定义的重写的方法
		super.method3();// 调用的是父类中声明的
		// 调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}
}

public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();

		// 接口中定义的静态方法，只能通过接口来调用。
		CompareA.method1();
		// 通过实现类的对象，可以调用接口中的默认方法。
		// 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
		s.method2();
		// 如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
		// 那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。-->类优先原则
		// 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
		// 那么在实现类没有重写此方法的情况下，报错。-->接口冲突。需要我们必须在实现类中重写此方法
		s.method3();
	}
}

3 接口和抽象类之间的对比