JAVA接口

1.说出下面程序的执行结果:

interface InterfaceA { 
	String S = "good "; 
	void f(); 
} 

abstract class ClassA { 
	abstract void g(); 
} 

class ClassB extends ClassA implements InterfaceA { 
	void g() { 
		System.out.print(S); 
	} 
	
	public void f() { 
		System.out.print(" "+ S); 
	} 
}
public class Test { 
	public static void main(String[] args) { 
		ClassA a = new ClassB(); //向上转型
		InterfaceA b = new ClassB(); 
		a.g(); 
		b.f(); 
	} 
} 

ClassB继承ClassA抽象类、实现InterfaceA接口，重写了ClassA的g()方法，实现了InterfaceA的f()方法以及继承了其常量（public static final）属性;

通过向上转型，定义了两个ClassB对象，输出结果为：good  good

2.编程题
利用接口做参数，写个计算器，能完成加减乘除运算。
（1）定义一个接口Compute含有一个方法int computer(int n, int m)。
（2）设计四个类分别实现此接口，完成加减乘除运算。
（3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。
（4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。

interface Computer{
	int computer(int n, int m);
}

class Mul implements Computer{
	public int computer(int n, int m){
		return (n * m);
	}
}

class Add implements Computer{
	public int computer(int n, int m){
		return (n + m);
	}
}

class Dev implements Computer{
	public int computer(int n, int m){
		if(m == 0){
			System.out.print("error by zero: ");
			return -1;
		}
		return (n / m);
	}
}

class Sub implements Computer{
	public int computer(int n, int m){
		return (n - m);
	}
}

class UseCompute{
	public void useCom(Computer com, int one, int two){
		System.out.println(com.computer(one, two));
	}
}

public class Test1{
	public static void main(String[] args){
		UseCompute uc = new UseCompute();
		int m = Integer.parseInt(args[0]);
		int n = Integer.parseInt(args[1]);
		
		uc.useCom(new Add(),m,n);
		uc.useCom(new Sub(),m,n);
		uc.useCom(new Mul(),m,n);
		uc.useCom(new Dev(),m,n);
	}
}

3.按如下要求编写Java程序：
（1）定义接口A，里面包含值为3.14的常量PI和抽象方法double area()。
（2）定义接口B，里面包含抽象方法void setColor(String c)。
（3）定义接口C，该接口继承了接口A和B，里面包含抽象方法void volume()。
（4）定义圆柱体类Cylinder实现接口C，该类中包含三个成员变量：底圆半径radius、
圆柱体的高height、颜色color。
（5）创建主类来测试类Cylinder。

interface IA{
	double PI = 3.14;
	double area();
}

interface IB{
	void setColor(String c);
}

interface IC extends IA,IB{
	void volume();
}

class Cylinder implements IC{
	double radius;
	double height;
	String color;
	
	public Cylinder(double radius, double height){
		this.radius = radius;
		this.height = height;
	}
	
	public double area(){
		return (2*PI*radius*radius + PI*2*radius*height);
	}
	
	public void setColor(String color){
		this.color = color;
	}
	
	public void volume(){
		System.out.println("volume: "+PI*radius*radius*height);
	}
}

public class Test2{
	public static void main(String[] args){
		Cylinder cy = new Cylinder(Double.parseDouble(args[0]), Double.parseDouble(args[1]));
		System.out.println("area: " + cy.area());
		
		cy.setColor(args[2]);
		System.out.println("color: " + cy.color);
		
		cy.volume();
	}
}

4.算法

它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身，一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。

public class Test3{
	public static void main(String[] args){
		for(int i = 1; i < 1000; i++)
		{
			if(IsPerfectNumber(i)){
				System.out.println(i);
			}
		}
	}
	
	public static boolean IsPerfectNumber(int num){
		int sum = 0;
		for(int j = 1; j < num; j++){
			if(num % j == 0){
				sum += j;
			}
		}
		if(sum == num){
			return true;
		}
		return false;
	}
}