java作业03

package homework03;
import java.util.Scanner;
/*
 * 编写一个类，该类有一个方法
 * public int f（int a，int b）{
 * 
 * }
 * 然后编写一个该类的子类，要求重写方法f()，而且重写的方法将返回两个整数的最小公倍数。要求：
 * 在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m,然后将a*b/m返回；在应用程序的
 * 主类中分别使用父类和子类创建对象，并分别调用方法f()计算两个正整数的最大公约数和最小公倍数。
 */
class Father{
	public int f(int a,int b){  //返回最大公约数
		int r;
		do {
			if (a < b) {
				int t = a;
				a = b;
				b = t;
			}
			r = a % b;
			a= b;
			b = r;
		} while (r != 0);
		return a;
	}
}
class Son extends Father{
	public int f(int a,int b){  //重写父类函数public int f(int a,int b);返回最小公倍数。
		return a*b/super.f(a, b);
	}
}
public class ch05_1 {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		System.out.println("请输入第一个整数 : ");
		int a = s.nextInt();
		System.out.println("请输入第二个整数 : ");
		int b = s.nextInt();
		System.out.println("由父类的方法计算的最大公约数："+new Father().f(a,b));
		System.out.println("由子类重写的方法计算的最小公倍数："+new Son().f(a, b));
	}
}

运行示例：

请输入第一个整数 :

12

请输入第二个整数 :

9

由父类的方法计算的最大公约数：3

由子类重写的方法计算的最小公倍数：36

package homework03;
/*
 * 首先编写一个抽象类，要求该类有如下3个抽象方法：
 * public abstract void f(int x);
 * public abstract void g(int x,int y);
 * public abstract double h(double x);
 * 然后分别给出该类的3个子类。要求：在应用程序的主类中使用这些子类创建对象，然后让它们的
 * 上转型对象调用方法：f(),g()和h()。
 */
abstract class F{
	public abstract void f(int x);
	public abstract void g(int x,int y);
	public abstract double h(double x);
}
class s1 extends F{
	public void f(int x) {
		System.out.println("子类1的f函数 打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类1的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类1的h函数 打印参数(double)："+x);
		return x;
	}
}
class s2 extends F{
	public void f(int x) {
		System.out.println("子类2的f函数打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类2的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类2 h函数 打印参数(double)："+x);
		return x;
	}
}
class s3 extends F{
	public void f(int x) {
		System.out.println("子类3的f函数 打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类3的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类3的h函数 打印参数(double)："+x);
		return x;
	}
}
public class ch05_2 {
	public static void main(String[] args) {
		F testF=new s1(); //上转对象
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
		testF=new s2(); //上转对象
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
		testF=new s3();//上转对象
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
	}
}

运行结果：

子类1的f函数 打印参数：2

子类1的g函数 打印参数(int)x=：2 y=2

子类1的h函数 打印参数(double)：2.0

子类2的f函数打印参数：2

子类2的g函数 打印参数(int)x=：2 y=2

子类2 h函数 打印参数(double)：2.0

子类3的f函数 打印参数：2

子类3的g函数 打印参数(int)x=：2 y=2

子类3的h函数 打印参数(double)：2.0

package homework03;
/*
 * 编写一个类，要求该类实现一个接口，该接口有如下3个抽象方法：
 * public abstract void f(int x);
 * public abstract void g(int x,int y);
 * public abstract double h(double x);
 * 要求：在应用程序的主类中使用该类创建对象，并使用接口回调来调用这些方法：f(),g()和h();
 */
interface InterfaceTest{
	public abstract void f(int x);
	public abstract void g(int x,int y);
	public abstract double h(double x);
}
class a1 implements InterfaceTest{
	public void f(int x) {
		System.out.println("子类1的f函数 打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类1的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类1的h函数 打印参数(double)："+x);
		return x;
	}
}
class a2 implements InterfaceTest{
	public void f(int x) {
		System.out.println("子类2的f函数打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类2的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类2 h函数 打印参数(double)："+x);
		return x;
	}
}
class a3 implements InterfaceTest{
	public void f(int x) {
		System.out.println("子类3的f函数 打印参数："+x);
	}
	public void g(int x, int y) {
		System.out.println("子类3的g函数 打印参数(int)x=："+x+"  y="+y);
	}
	public double h(double x) {
		System.out.println("子类3的h函数 打印参数(double)："+x);
		return x;
	}
}
public class ch05_3 {
	public static void main(String[] args) {
		InterfaceTest testF=new a1(); //接口回调
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
		testF=new a2(); //接口回调
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
		testF=new a3();//接口回调
		testF.f(2);
		testF.g(2, 2);
		testF.h(2);
		
	}
}

结果如第二题所示。