(八) 面向对象 - 抽象类与接口

一、抽象类

 

一、介绍

 
抽象类与抽象方法：

有时将一个对象设计的比较抽象，以至于没有具体的实例，这样的类称之为抽象类。

对于某个方法的设计不提供具体实现，而是由子类来实现这个方法，这样的方法称之为抽象方法。

含义一个或多个抽象方法的类称之为抽象类。

 
 
定义：

1、定义抽象类 与 抽象方法：

public abstract class AbstractClass {
    ....
        
    public abstract void printNum(int num);
    
    ....
}

在类上添加abstract关键字定义抽象类，在方法上添加abstract关键字定义抽象方法。

 
2、继承抽象类与实现抽象方法：

public class ClassImpl extends AbstractClass{

    @Override
    public void printNum(int num) {
        System.out.println(num);
    }
} 

 
 

特点：

有抽象方法的类必须声明为抽象类。

抽象类存在构造方法，但不能被实例化，只能够用来被继承，子类必须实现父类的全部抽象方法，没有全部实现，那么这个类因该声明为抽象类。

不能够用abstrart声明变量，代码块，构造方法。

不能够用abstract来声明 fianl的类（不可被继承），私有方法，静态方法（属于类，无法被重写），fianl的方法（不可被重写）。

 
 

二、接口

 

一、介绍

接口：

接口是抽象方法与全局常量(全局常量必须初始化)的集合，接口的本质是契约、标准、规范，制定好后大家都 要遵守。

 
定义：

定义接口：

public interface InterfaceClass {
    public static final int NUM = 1;
    
    public abstract void print();
    
}

使用interface关键字定义接口，由于接口是全局常量与抽象方法的集合，因此可以去掉public static final 与 public abstract。

 
实现接口：

public class ImplementsClass implements InterfaceClass{

    @Override
    public void print() {
        System.out.println("实现方法");
    }
}

 
 

二、特点

使用interface来定义

类中所有的成员变量，全部是pulic static final来修饰

类中的所有方法，都是用public abstract来修饰

采用多继承机制，接口可以继承多个接口，但不能继承类。

没有构造器，因此也无法new。

 
 

三、注意点

如果一个类既继承了一个类，有实现了一个接口，那么先写extends然后写implements。

一个类可以实现多个接口，接口又可以继承其他接口，如果实现这个接口，但没有全部重写里面的抽象方法，那么这个实现的类为抽象类。

接口的主要用途是被实现类实现，与类相似接口与实现类也存在多态。

 
 

四、示例

class A{
    
    
}

interface B extends C,D{
    
}

interface C{
    
}

interface D{
    
}

class E extends A implements B, Serializable{
    
}

 
 

五、JDK1.8新增默认方法与静态方法

介绍：

在JDK1.8中新增了许多新特性，同时JDK1.8也是长期支持的版本，因此了解新特性十分有必要，针对接口新增了默认方法与静态方法。

 
静态方法：使用static修饰，可以直接使用接口来调用

​ 比如：你可以在标准库中 找到像Path/Paths这样成对的接口和类。

public interface Path
   extends Comparable<Path>, Iterable<Path>, Watchable
{
   ....
       
    public static Path of(String first, String... more) {
       return FileSystems.getDefault().getPath(first, more);
   }
   
   ....
   
}

 
默认方法：使用default修饰，可以通过实现类对象来调用

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

public interface Collection<E> extends Iterable<E> {
    
    .....
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    
    .....
}

 

定义：

interface A{
	public static int getInteger(){
		return 1;
	}
	public default double getDouble(){
		return 1.1;
	}
}

使用static与default关键字定义。

 
问题：

默认方法的接口冲突问题：

同一个类实现了两个接口，一个接口中的定义了一个默认方法，另一个接口也定义了同名同参数的方法，会出现接口冲突问题。

 
注意：

静态方法不会，因为可以直接通过 接口名.静态方法 调用；同一个类继承了类又实现了接口，并且接口与类定义同名同参数的方法，则遵循类优先的原则。

 
解决方法：

必须覆盖接口中同名同参数的方法。

interface A{
	public static int getInteger(){
		return 1;
	}
	public default double getDouble(){
		return 1.1;
	}
}


interface B{
	public static int getInteger(){
		return 1;
	}
	public default double getDouble(){
		return 1.1;
	}
}
				
class Z{
	public static int getInteger(){
		return 1;
	}
				
}
				
class C extends Z implements A,B{
				
	@Override
	public double getDouble() {
		//return 0;
		return A.super.getDouble();
		//or return B.super.getDouble();
	}
}

public  class TestClass {

    public static void main(String[] args) {
		C c = new C();
        c.getDouble();
    }
}

 
 

六、接口与抽象类pk

抽象类：

抽象类提取的是具有 is - a 特征关系的类的共同行为，有构造方法但不能new，抽象类中的数据不仅仅为常量与抽象方法，一个类只能继承一个抽象类。

 
接口：

接口提取的是仅仅是具有相同的行为特征的类的共同行为，无构造方法且不能够new，接口中的数据仅仅为常量与抽象方法（JDK1.8 新增默认方法与静态方法），一个类可以实现多个接口。

 
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则 必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 “能不能” 的关系。

 
 

三、设计模式之模板模式

一、介绍

当某个功能的一部分功能是确定的，但又有一部分功能是不确定的，此时我们不确定的部分暴露出去，让子类去实现。
 
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

 
由父类决定算法逻辑代码，由子类实现逻辑细节。

 
 

二、示例代码

public class Template {

    public final void print(String message){
        System.out.println("=============");
        printTask(message);
        System.out.println("========");
    }

    protected abstract void printTask(String message);

}


public class ExtendClass extends Template { 
    @Override
    protected void printTask(String message) {
         System.out.println("打印信息：" +message);
    }
    
    
    public static void main(String[] args) {
        Template template = new ExtendClass();
        template.print("1998-12-17");
    }
}