从头开始学java--抽象类&接口

绝地灬酷狼 2022-08-06 00:19 114阅读 0赞

## 一.抽象类的定义 ##

抽象类，在类名定义前面加上abstract就成了抽象类。抽象类中包含抽象方法。

抽象方法，在方法前加上abstract就成了抽象方法。只定义了方法，没有实现。

抽象类，因为长得太抽象，java虚拟机都不认识，不能建立对象。只有用子类继承了抽象类，并且将抽象类定义的抽象方法实现了之后，才可以建立子类的对象。

一个例子：

abstract class Person
    {
    	//抽象方法
    	public abstract void eat();
    	
    	//abstract void eat(){} 这不是抽象方法，{}也是函数体
    	
    	//普通方法,抽象类中可以有普通方法，但是只要有一个抽象方法就是抽象类
    	public void walk()
    	{
    		System.out.println("I am person. I can walk");
    	}
    }
    
    class Student extends Person
    {
    	public void eat()
    	{
    		System.out.println("I am student. I eat 脑白金") ;
    	}
    }
    
    public class AbstractTest {
    	public static void main(String[] args)
    	{
    		Student student1 = new Student();
    		student1.eat();//输出为：  I am student. I eat 脑白金
    
    	}
    }

**要点：**

**1.抽象类不能用new创建对象。子类继承抽象类，将抽象类中的抽象方法实现后才可以创建对象，必须保证实现所有的抽象方法，子类如果还有抽象方法也不能创建对象。**

**2.包含抽象方法的类一定是抽象类。但是抽象类中可以包含非抽象方法。如要一个类不创建对象，可以定义为抽象类，但意义不大，不如构造函数私有化。**

**3.抽象类的形成：一种是直接定义了一个抽象方法。一种是继承了一个抽象类或者接口，但是没有实现所有的抽象方法。**

**4.抽象类的作用：强迫子类重写抽象方法，定义子类功能，但是由子类实现。**

**5.注意，abstract void eat()\{\}也是有函数体的，\{\}即函数体。抽象类没有函数体，所以不能有\{\}。**

## 二.抽象类的使用 ##

抽象类除了被继承之外，也可以使用，但是当然不是建立对象，而是用来引用抽象类的子类对象。即多态的一种表现形式。

abstract class Person
    {
    	//抽象方法
    	public abstract void eat();
    }
    
    class Student extends Person
    {
    	public void eat()
    	{
    		System.out.println("I am student. I eat 脑白金") ;
    	}
    }
    
    public class AbstractTest {
    	public static void main(String[] args)
    	{
    		Person person = new Student();
    		person.eat();//输出为   I am student. I eat 脑白金
    	}
    }

**要点：**

**抽象类使用： 抽象类 抽象类变量 = new 继承抽象类的子类（）；**

##    三.接口的定义 ##

接口可以看成一个特殊的抽象类，但是接口中的方法必须都是抽象的，不涉及任何实现细节。

定义一个接口用关键字interface 实现一个接口用implements关键字。

为什么要用接口呢？

当我们用一个类继承另一个类的时候，继承了类的方法与属性，但是有些属性不是所有类都具有的，在父类中不合适，但是还需要抽象出来，这时候就用到了接口。

接口一般表示类具有某种功能，表示HAS\_A而不是IS\_A

比如，是Person一定要吃，但是是Person不一定会speakEnglish，所以把这个方法定义在person类中不合适，应该放在接口中，供子类实现。

一个例子：

interface Speak
    {
    	//定义了一个方法，说英语。表示一种能力，供子类实现
    	public abstract void speakEnglish();
    }
    
    class Student implements Speak
    {
    	//Student类实现了speakEnglish()方法，具有了说英语的能力
    	public void speakEnglish()
    	{
    		System.out.println("I am student.I can speak English");
    	}
    }
    
    public class InterfaceTest {
    	public static void main(String[] args)
    	{
    		Student student = new Student();
    		student.speakEnglish();
    	}
    }

**要点：**

**1.接口不能创建对象，用法大致与抽象类相同。但是接口中不能有非抽象方法。**

**2.接口中定义方法的修饰符是固定的，public abstract 所以子类实现接口方法的时候必须也用public修饰。**

**3.java类之间不支持多继承，但是支持多实现，即一个类可以实现多个接口。但是接口可以继承接口，而且可以多继承。**

例子：

abstract class Person
    {
    	//定义一个抽象方法，是人就会吃，所以放在父类是合适的。但是吃什么是不一定的，所以定义为抽象方法，由子类具体实现
    	public abstract void eat();
    }
    
    interface Speak
    {
    	//定义了一个方法，说英语。表示一种能力，供子类实现
    	public abstract void speakEnglish();
    }
    
    interface Jump
    {
    	//定义个方法，大跳。表示一种能力，供子类实现
    	public abstract void jump();
    }
    
    class Student extends Person implements Speak,Jump
    {
    	//Student类继承了Person抽象类，实现eat方法
    	public void eat()
    	{
    		System.out.println("I am student. I eat 脑白金");
    	}
    	//Student类实现了speakEnglish()方法，具有了说英语的能力
    	public void speakEnglish()
    	{
    		System.out.println("I am student.I can speak English");
    	}
    	
    	//Student类实现了jump()方法。具有了大跳的能力
    	public void jump()
    	{
    		System.out.println("I am student.I can jump");
    	}
    }
    
    public class InterfaceTest {
    	public static void main(String[] args)
    	{
    		Student student = new Student();
    		student.eat();
    		student.speakEnglish();
    		student.jump();
    	}
    }

这个类中，Student类继承了Person类，实现了Speak和Jump接口。继承自己父类的方法，同时也具有了接口提供的能力。

输出如下：

![Center][]

## 四.接口中定义的常量 ##

接口中可以定义常量。接口中的常量和抽象方法都有固定的格式，必须按照格式书写，如果没写全java会给补全，但是不便理解。

例子：

interface Inter
    {
    	//定义在接口中的常量必须初始化
    	public static final int MAX_VALUE = 100;
    	public abstract void print();
    }
    
    //实现了接口，就可以直接使用接口中定义的常量
    class Myclass implements Inter
    {
    	public void print()
    	{
    		System.out.println(MAX_VALUE);
    	}
    }
    
    public class InterfaceTest2 {
    	public static void main(String[] args)
    	{
    		Myclass myclass = new Myclass();
    		myclass.print();//输出结果为  100
    	}
    }

**要点：**

**1.接口中定义常量的格式： public static final 类型 常量名**

**2.接口中定义抽象方法的格式：public abstract 返回值 方法名**

**3.实现了接口的类，可以直接使用接口中定义的常量。**

**4.接口定义常量的时候必须要初始化。**

![Center 1][]

[Center]: /images/20220806/b9834e422ea54c358b9b4d3df6f682d6.png
[Center 1]: /images/20220806/1ba09f083f744d32a97912d5c2827119.png