Java接口与接口实现实验_【java笔记】类, 抽象类, 接口的简单实验

要接触了 抽象，继承，多态，封装的java。

为了加深理解自己做了一个简单的实验。

1.类只能继承一个。

2.抽象类也只能继承一个。

3.接口可以继承多个。

4.不能同时继承类和接口，也不能同时继承抽象类和接口。

我先创建了以下文件。

图片备用地址

文件目录结构

先看看每个文件的代码

【AnimalAbstract】抽象类里添加了2个函数，其中一个是抽象函数。

package animals.animal;

public abstract class AnimalAbstract {

public void eat(String name){

System.out.println("eat:" + AnimalAbstract.class + " | name:" + name);

};

public abstract void sleep(String name);

}

【AnimalClass】一个普通的类和函数。

package animals.animal;

public class AnimalClass {

public void smile(String name){

System.out.println("smile:" + AnimalAbstract.class + " | name:" + name);

};

}

【AnimalClass】两个不同的接口。

package animals.animal;

public interface AnimalInterfaceJump {

public void jump (String name);

}

package animals.animal;

public interface AnimalInterfaceRun {

public void run (String name);

}

【Cat】继承了一般类

package animals.MammalInt;

import animals.animal.*;

public class Cat extends AnimalClass {

}

【Dog】继承了抽象类，实现了AnimalAbstract的sleep函数

package animals.MammalInt;

import animals.animal.AnimalAbstract;

public class Dog extends AnimalAbstract {

@Override

public void sleep(String name) {

System.out.println("sleep:" + Dog.class + " | name:" + name);

}

}

【Sheep】继承了两个接口，以及实现了两个接口的函数

package animals.MammalInt;

import animals.animal.AnimalInterfaceRun;

import animals.animal.AnimalInterfaceJump;

public class Sheep implements AnimalInterfaceRun, AnimalInterfaceJump {

@Override

public void run(String name) {

System.out.println("run:" + Sheep.class + " | name:" + name);

}

@Override

public void jump(String name) {

System.out.println("jump:" + Sheep.class + " | name:" + name);

}

}

package animals;

import animals.animal.AnimalAbstract;

import animals.animal.AnimalClass;

import animals.animal.AnimalInterfaceRun;

import animals.animal.AnimalInterfaceJump;

import animals.MammalInt.Cat;

import animals.MammalInt.Dog;

import animals.MammalInt.Sheep;

public class main {

public static void main(String[] args) {

System.out.println("-------------class------------");

// 继承一般类可以自由调用父类的函数

AnimalClass animalClass = new Cat();

animalClass.smile("catName");

System.out.println("-------------abstract------------");

// 继承抽象类，可以调用实现后的函数

AnimalAbstract animalAbstract = new Dog();

animalAbstract.sleep("dogName");

animalAbstract.eat("dogName");

System.out.println("-------------interface------------");

// 只能调用接口内的实现好的函数

AnimalInterfaceRun animalInterfaceRun = new Sheep();

animalInterfaceRun.run("sheepName");

//animalInterfaceRun.jump("sheepName"); 这么写会出错，原因大家应该明白...^^

AnimalInterfaceJump animalInterfaceJump = new Sheep();

animalInterfaceJump.jump("sheepName");

}

}

编译以后，可以查看结果

$ javac animals/animal/AnimalAbstract.java animals/animal/AnimalClass.java animals/animal/AnimalInterfaceRun.java animals/animal/AnimalInterfaceJump.java animals/MammalInt/Cat.java animals/MammalInt/Dog.java animals/MammalInt/Sheep.java animals/main.java

$ java animals.main

-------------class------------

smile:class animals.animal.AnimalAbstract | name:catName

-------------abstract------------

sleep:class animals.MammalInt.Dog | name:dogName

eat:class animals.animal.AnimalAbstract | name:dogName

-------------interface------------

run:class animals.MammalInt.Sheep | name:sheepName

jump:class animals.MammalInt.Sheep | name:sheepName

做了最最基本的简单测试，别见笑...^^

欢迎大家的意见和交流

email: li_mingxie@163.com