Java程序设计：必实验3 抽象类及接口

(1.1) 定义一个抽象类Human：包含一个成员变量String name；构造方法Human(String name)，用于初始化姓名name；一个抽象方法void  sayHello()。

package 必实验3;

//定义一个抽象类Human
abstract class Human
{
	//一个成员变量name
	String name;
	//含参构造函数，初始化姓名
	public Human(String n) {
		name = n;
	}
	//一个抽象方法
	abstract public void sayHello();
}

//定义Human的子类People对抽象类进行测试
class People extends Human
{
    public People(String n)
    {
    	super(n);
    }
    @Override
    public void sayHello()
    {
    	System.out.println("你好！我叫"+name+"!");
    }
}
public class Test_Human {
	
	public static void main(String[] args) {
		
		java.util.Scanner input =new java.util.Scanner(System.in);
        System.out.print("请输入姓名：");
        String name =input.next();
        
		Human people = new People(name);
		people.sayHello();
	}
}

(1.2) 定义三个继承抽象类Human的类，分别命名为Chinese、French和Japanese，在这三个类中重写sayHello()方法，分别输出一句中文、法语和日语的问候；

package 必实验3;

//Chinese类继承Human
class Chinese extends Human
{
	//调用父类的含参构造函数
	public Chinese(String n)
	{
		super(n);
	}
	//重写含参构造函数
	 @Override
	public void sayHello()
	{
		System.out.println("你好，我的名字是"+name);
	}
}

//French类继承Human
class French extends Human
{
	//调用父类的含参构造函数
	public French(String n)
	{
		super(n);
	}
	//重写含参构造函数
	 @Override
	public void sayHello()
	{
		System.out.println("Bonjour, mon nom est "+name);
	}
}

//Japanese类继承Human
class Japanese extends Human
{
	//调用父类的含参构造函数
	public Japanese(String n)
	{
		super(n);
	}
	//重写含参构造函数
	 @Override
	public void sayHello()
	{
		System.out.println("こんにちは、私の名前は"+name);
	}
}

public class Test_three {
	
	public static void main(String[] args) {
	 //构建Chinese对象并调用sayHello
     Human chinese = new Chinese("名井南");
     chinese.sayHello();
     
     
     //构建French对象并调用sayHello
     Human french = new French("Nom Yinan");
     french.sayHello();
     
     //构建Japanese对象并调用sayHello
     Human japanese = new Japanese("名井みなみ");
     japanese.sayHello();
	}	
	
}

(1.3) 定义一个测试类HumanTest：创建一个包含3个Human对象的数组，3个Human对象来自Chinese、French和Japanese类，循环调用该数组中的元素的sayHello ()方法。

package 必实验3;

//创建HumanTest类
class HumanTest
{
	//成员变量为human数组
	Human human[];
	//含参构造函数，初始化human数组
	public HumanTest(Human h[])
	{
		human = new Human[3];
		for(int i=0;i<3;i++)
		{
			human[i] = h[i];
		}
	}
	//定义成员display方法，循环调用该数组中的元素的sayHello方法
	public void display()
	{
		for(int i=0;i<3;i++)
		{
			human[i].sayHello();
		}
	}
}

public class Test_array {

	public static void main(String[] args) {
		  //创建一个包含3个Human对象的数组
	      Human hhuman[];
	      hhuman = new Human[3];
	      //3个Human对象来自Chinese、French和Japanese类
	      hhuman[0] = new Chinese("名井南");
	      hhuman[1] = new French("Nom Yinan");
	      hhuman[2] = new Japanese("名井みなみ");
	      //创建一个HumanTest对象来进行测试
	      HumanTest humanTest = new HumanTest(hhuman);
	      humanTest.display();
	}	
	
}

(1.4) 通过一个接口（命名为Human）和三个实现类（命名为Chinese、French和Japanese）来达到如上类似的效果。

package 必实验3_;

//定义Human接口
public interface Human {
	
	abstract void sayHello(String name);
}

package 必实验3_;

//用implements关键字继承Human接口
class Chinese implements Human
{
	 @Override
	public void sayHello(String name)
	{
		System.out.println("你好，我的名字是"+name);
	}
}

class French implements Human
{
	 @Override
	public void sayHello(String name)
	{
		System.out.println("Bonjour, mon nom est "+name);
	}
}

class Japanese implements Human
{
	 @Override
	public void sayHello(String name)
	{
		System.out.println("こんにちは、私の名前は"+name);
	}
}


public class Test_interface {

	public static void main(String[] args) {
		 //构建Chinese对象并调用sayHello
		 Human chinese = new Chinese();
		 chinese.sayHello("名井南");
		 
		 
		 //构建French对象并调用sayHello
		 Human french = new French();
		 french.sayHello("Nom Yinan");
		 
		 //构建Japanese对象并调用sayHello
		 Human japanese = new Japanese();
		 japanese.sayHello("名井みなみ");
	}
}