Java抽象类与接口详解（小白必看）

柔光的暖阳◎ 2023-07-22 16:24 155阅读 0赞

### 目录 ###

*   *  抽象类
     *  接口
     *   *  接口与多继承
         *  接口单继承
         *  Java 8新特性默认方法和静态方法
     *  抽象类与接口区别

## 抽象类 ##

抽象类：用abstract修饰的类叫做抽象类。  
在讲抽象类之前有必要强调一下abstract修饰符：

*  abstract修饰的类为抽象类，此类不能有对象，（无法对此类进行实例化，说白了就是不能new）；
 *  abstract修饰的方法为抽象方法，此方法不能有方法体（就是什么内容不能有）；

抽象类的示例代码：

public abstract class Figure {  
    	// 绘制几何图形方法 
    	public abstract void onDraw(); 
    }

关于抽象类的使用特点：

*  抽象类不能有对象，（不能用new此关键字来创建抽象类的对象）；
 *  有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法；可以有0到n个抽象方法，以及0到n具体方法。
 *  抽象类中的抽象方法必须在子类中被重写。抽象方法生来就是要被重写的，而且是必须重写。
 *  抽象类和普通类一样，各种形式的成员变量都可以声明，也需要构造方法。

看示例代码：

public abstract class Figure { 
    //抽象方法
        public abstract void onDraw();
    }
    //几何图形椭圆形
    class Ellispe extends Figure{ 
    //绘制几何图形方法
        @Override
        public void onDraw() { 
            System.out.println("绘制椭圆");
        }
    }
    //几何图形三角形
    class Triangle extends Figure{ 
    // 绘制几何图形方法
        @Override
        public void onDraw() { 
            System.out.println("绘制长方形");
        }
    }
    class Test{ 
        public static void main(String[] args) { 
    
    // f1变量指向父类型，指向子类实例，发生多态
            Figure f2 = new Ellispe();
            f2.onDraw();
    // f3变量指向父类型，指向子类实例，发生多态
            Figure f3 = new Triangle();
            f3.onDraw();
    // f4指向子类型，指向子类实例
            Triangle f4 = new Triangle();
            f4.onDraw();
        }
    }

注意：抽象类不能被实例化,只有具体类才能被实例化。

## 接口 ##

接口就是一个规范和抽象类比较相似。它只管做什么，不管怎么做。通俗的讲，接口就是某个事物对外提供的一些功能的声明，其定义和类比较相似，只不过是通过interface关键字来完成。

比抽象类更加抽象的是接口，在接口中所有的方法都是抽象的。

其中重要的几个知识点：

*  在接口中成员变量都静态成员变量，即省略了public static final修 饰符。
 *  接口中的所有方法默认为抽象方法，即省略了public关键字。
 *  声明接口使用interface关键字，interface前面的修饰符是public或省略。
 *  某个类实现接口时，要在声明时使用implements关键字，当实现多个接口之间用逗号（,）分隔。
 *  实现 接口时要实现接口中声明的所有原有的抽象方法。

声明接口示例代码：

public interface Figure { 
    	//接口中静态成员变量 
    	String name = "几何图形";//省略public static final
    	// 绘制几何图形方法 
    	void onDraw();//省略public
    }

实现接口示例代码：

//几何图形椭圆形
    class Ellispe implements Figure{ 
    //绘制几何图形方法
        @Override
        public void onDraw() { 
            System.out.println("绘制椭圆");
        }
    }
    //几何图形三角形
    class Triangle implements Figure{ 
    // 绘制几何图形方法
        @Override
        public void onDraw() { 
            System.out.println("绘制长方形");
        }
    }
    class Test{ 
        public static void main(String[] args) { 
    // f1变量指向父类型，指向子类实例，发生多态
            Figure f2 = new Ellispe();
            f2.onDraw();
    // f3变量指向父类型，指向子类实例，发生多态
            Figure f3 = new Triangle();
            f3.onDraw();
            //接口Figure中声明 了成员变量，它是静态成员变量，访问name静态变量
            System.out.println(f3.name);
            System.out.println(Figure.name);
    
    // f4指向子类型，指向子类实例
            Triangle f4 = new Triangle();
            f4.onDraw();
            
        }
    }

上述代码中实例化两个具体类Triangle和Ellipse，对象f1和f2是Figure接口引用类型。

**注意：接口与抽象类一样都不能被实例化。**

### 接口与多继承 ###

在Java中只允许继承一个类，但可实现多个接口。通过实现多个接口方式满足多继承的设计需求。如 果多个接口中即便有相同方法，它们也都是抽象的，子类实现它们不会有冲突。

多继承类图，其中的有两个接口InterfaceA和InterfaceB，从类图中可以见两个接口中都有 一个相同的方法void methodB()。AB实现了这两个接口，继承了Object父类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTM2NjQ5OQ_size_16_color_FFFFFF_t_70]  
接口InterfaceA代码如下：

public interface InterfaceA { 
    
    	void methodA();
    	
    	void methodB(); 
    }

接口InterfaceB代码如下：

public interface InterfaceB { 
    	
    	void methodB();
    	
    	void methodC(); 
    }

从代码中可见两个接口都有两个方法，其中方法methodB()完全相同。  
实现接口InterfaceA和InterfaceB的AB类代码如下：

public class AB extends Object implements InterfaceA, InterfaceB {  		
    	@Override 
    	public void methodC() {  
    	} 
    	@Override 
    	public void methodA() {  
    	} 
    	@Override 
    	public void methodB() {  
    	}
    
    }

**注意在AB类声明时，实现两个接口，接口之间使用逗号 （，）分隔**

### 接口单继承 ###

如图所示，其中InterfaceB继承了 InterfaceA，在InterfaceB中还覆盖了InterfaceA中的methodB()方法。ABC是InterfaceB接口的实现类，从 图中可见ABC需要实现InterfaceA和InterfaceB接口中的所有方法。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTM2NjQ5OQ_size_16_color_FFFFFF_t_70 1]  
接口InterfaceA代码如下：

public interface InterfaceA { 
    
    	void methodA();
    	
    	void methodB(); 
    }

接口InterfaceB代码如下：

public interface InterfaceB extends InterfaceA { 
    
    	@Override
    	void methodB();
    	
    	void methodC(); 
    }

InterfaceB继承了InterfaceA，声明时也使用extends关键字。InterfaceB 中的methodB()覆盖了 InterfaceA，事实上在接口中覆盖方法，并没有实际意义，因为它们都是抽象的，都是留给子类实现 的。

实现接口InterfaceB的ABC类代码如下：

public class ABC implements InterfaceB {  		
    	@Override 
    	public void methodC() {  
    	} 
    	@Override 
    	public void methodA() {  
    	} 
    	@Override 
    	public void methodB() {  
    	}
    }

**ABC类实现了接口InterfaceB，事实上是实现InterfaceA和InterfaceB中所有方法，相当于同时实现 InterfaceA和InterfaceB接口。**

### Java 8新特性默认方法和静态方法 ###

在Java 8之前，尽管Java语言中接口已经非常优秀了，但相比其他面向对象的语言而言Java接口存在如 下不足之处：

*  不能可选实现方法，接口的方法全部是抽象的，实现接口时必须全部实现接口中方法，哪怕是 有些方法并不需要，也必须实现。
 *  没有静态方法。

**针对这些问题，Java 8在接口中提供了声明默认方法和静态方法的能力。**

接口示例代码如下：

public interface InterfaceA { 
    	void methodA();
    	String methodB();
    	
    	// 默认方法 
    	default int methodC() {  
    		return 0; 
    	}	
    	// 默认方法 
    	default String methodD() {  
    		return "这是默认方法..."; 
    	}	
    	// 静态方法 
    	static double methodE() {  
    		return 0.0; 
    	}
    }

在接口InterfaceA中声明了两个抽象方法methodA和methodB，两个默认方法methodC和methodD，还有 声明了静态方法methodE。

接口中的默认方法类似于类中具体方法，给出了具体实现，只是方法修饰 符是`default`。接口中静态方法类似于类中静态方法。

实现接口示例代码如下：

public class ABC implements InterfaceA {  
    	@Override 
    	public void methodA() {  
    	} 
    	@Override 
    	public String methodB() {  
    		return "实现methodB方法..."; 
    	} 
    	@Override 
    	public int methodC() {  
    		return 500; 
    	}
    }

**实现接口时接口中原有的抽象方法在实现类中必须实现。默认方法可以根据需要有选择实现（覆 盖）。静态方法不需要实现，实现类中不能拥有接口中的静态方法。**

上述代码中ABC类实现了InterfaceA接口，InterfaceA接口中的两个默认方法ABC只是实现（覆盖）了 methodB。  
调用代码如下：

public class HelloWorld { 
    
    	public static void main(String[] args) {  
    		//声明接口类型，对象是实现类，发生多态 
    		InterfaceA abc = new ABC(); 
    		// 访问实现类methodB方法 
    		System.out.println(abc.methodB()); 
    		// 访问默认方法methodC 
    		System.out.println(abc.methodC()); 
    		// 访问默认方法methodD 
    		System.out.println(abc.methodD()); 
    		// 访问InterfaceA静态方法methodE 
    		System.out.println(InterfaceA.methodE());
    	}
    }

运行结果：

实现methodB方法... 
    500
    这是默认方法... 
    0.0

## 抽象类与接口区别 ##

*  接口支持多继承，而抽象类（包括具体类）只能继承一个父类。
 *  接口中不能有实例成员变量，接口所声明的成员变量全部是静态常量，即便是变量不加public static final修饰符也是静态常量。抽象类与普通类一样各种形式的成员变量都可以声明。
 *  接口中没有包含构造方法，由于没有实例成员变量，也就不需要构造方法了。抽象类中可以有 实例成员变量，也需要构造方法。
 *  抽象类中可以声明抽象方法和具体方法。Java 8之前接口中只有抽象方法，而Java 8之后接口中 也可以声明具体方法，具体方法通过声明默认方法实现。

--------------------

以上内容仅供参考学习，如有侵权请联系我删除！  
如果这篇文章对您有帮助，左下角的大拇指就是对博主最大的鼓励。  
您的鼓励就是博主最大的动力！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTM2NjQ5OQ_size_16_color_FFFFFF_t_70]: /images/20230528/24750faaa6134267b061d503a6c6ff21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTM2NjQ5OQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/ba99a545ff7e4e3ea8d6ac3dfb2986af.png