面向对象编程答案3

1. 定义一个动物类，里面有一个方法voice(),
定义一个类Cat,实现voice方法
然后增加一种新的动物类型：Pig(猪)，实现voice()方法。
定义一个Dog类，实现voice方法
定义一个Store（宠物店）类的getInstance方法：
如果传入的参数是字符串dog，则返回一个Dog对象；
如果传入pig，则返回一个Pig对象；否则，返回一个Cat对象。

abstract class Animal{
    public abstract void voice();
}
class Pig implements Animal{
    public void voice(){
        System.out.println("henghengheng");
    }
}
class Dog implements Animal{
    public void voice(){
        System.out.println("wangwangwang");
    }
}
class Cat implements Animal{
    public void voice(){
        System.out.println("喵喵喵");
    }
}
class Store{
    public Animal getInstance(String name){
        if("Pig".equals(name)){
            return new Pig();
        }else if("Dog".equals(name)){
            return new Dog();
        }else{
            return new Cat();
        }
    }
}

2. 
        1）定义一个抽象类Animal，其中包括属性name，相关构造方法，抽象方法enjoy()表示动物高兴时动作。  
    2）定义Cat类继承于Animal类，其中包括属性eyesColor，相关构造方法，同时具体化父类中的抽象方法。  
    3）定义Dog类继承于Animal类，其中包括属性furColor，相关构造方法，同时具体化父类中的抽象方法。  
    4）定义Lady类，其中包括属性name,以及Animal 类型的属性pet表示女士所养的宠物，定义构造方法，
        生成女士对象时初始化姓名和她所养的宠物。
           定义一个方法：myPetEnjoy表示此女士的宠物在高兴时的动作。提示：对于此类的定义中需要使用到多态性。 
    5）定义测试类。
            创建一个张女士，养了一只猫，让这只猫笑一笑

            创建一个王女士，养了一只狗，让这只狗叫一叫
 

public abstract class Animal {
	String name;
	public Animal() {
		
	}
	public Animal(String name) {
		this.name = name;
	}
	abstract public void enjoy();
}

class Cat extends Animal{
	String eyesColor;
	public Cat() {}
	public Cat(String eyesColor,String name) {
		this.eyesColor = eyesColor;
		this.name = name;
	}
	@Override
	public void enjoy() {
		System.out.println("miao~,我叫"+name+",我的眼睛是"+eyesColor+",我很快乐");
	}
}
class Dog extends Animal{
	String furColor;
	public Dog() {	}
	public Dog(String name,String furColor) {
		this.name = name;
		this.furColor = furColor;
	}
	@Override
	public void enjoy() {
		System.out.println("wang~,我叫"+name+",我的皮毛是"+furColor+",我很快乐");
	}
}
public class Lady {
	String name;
	Animal pet;
	public Lady() {}
	public Lady(String name,Animal pet) {
		this.name = name;
		this.pet= pet;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Animal getPet() {
		return pet;
	}
	public void setPet(Animal pet) {
		this.pet = pet;
	}
	public void myPetEnjoy() {
		pet.enjoy();
		System.out.println("我叫"+this.name+",我的宠物很高兴,我也很高兴");
	}
}
public class AbstractClassTest2 {

	public static void main(String[] args) {
		Animal a = new Dog("旺财","豹纹");
		Lady lady = new Lady("凤姐",a);
		lady.myPetEnjoy();

		System.out.println("过了10多年,旺财不幸去世了,凤姐又领养了一只宠物");
		Animal b = new Cat("粉色","喵星人");
		lady.setPet(b);
		lady.myPetEnjoy();
		
		Lady lady2 = new Lady();
		lady2.setName("芙蓉姐姐");
		lady2.setPet(new Dog("辛巴","huase"));
		lady2.myPetEnjoy();
	}

}

 3. 

        按如下要求编写Java程序：
    （1）编写接口InterfaceA，接口中含有方法void printCapitalLetter()。
    （2）编写接口InterfaceB，接口中含有方法void printLowercaseLetter()。
    （3）编写非抽象类Print，该类实现了接口InterfaceA和InterfaceB。
        要求printCapitalLetter()方法实现输出大写英文字母表的功能，printLowercaseLetter()方法实现输出小写英文字母表的功能。
    （4）再写一个主类Test，在main方法中创建Print的对象并赋值给InterfaceA的变量a，由变量a调用printCapitalLetter方法，

        然后再创建Print的对象并将该对象赋值给InterfaceB的变量b，由变量b调用printLowercaseLetter方法
 

public interface InterfaceA {
	void printCapitalLetter();
}

public interface InterfaceB {
	void printLowercaseLetter();
}
public class Print implements InterfaceA,InterfaceB{

	@Override
	public void printLowercaseLetter() {
		for(char i='a';i<='z';i++) {
			System.out.print(i+" ");
		}
		System.out.println();
	}

	@Override
	public void printCapitalLetter() {
		for(char i='A';i<='Z';i++) {
			System.out.print(i+" ");
		}
		System.out.println();
	}
 
}
public class InterfaceDemo3 {

	public static void main(String[] args) {
		InterfaceA a = new Print();
		a.printCapitalLetter();
		
		InterfaceB b = new Print();
		b.printLowercaseLetter();
		
	}
}

4.

            （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 A {               // 定义第1个接口
    double PI = 3.14;
    double getArea();
}
interface B {               // 定义第2个接口
    void setColor(String c);
}
interface C extendsA, B { // 接口的多重继承
    void getVolume();
}
class Cylinderimplements C {       // 以第3个接口实现类
    double radius;
    double height;
    String color;
    public Cylinder(double r, double h) {
        radius = r;
        height = h;
    }
    public double getArea() {       // 实现第1个接口的方法
        return PI * radius * radius;
    }
    public void setColor(String c) { // 实现第2个接口的方法
        color = c;
        System.out.println("形状的颜色："+ color);
    }
    public void getVolume() {       // 实现第3个接口的方法
        System.out.println("圆柱体的体积："+ getArea() * height);
    }
}
class Test {
    public static void main(String args[]) {
        Cylinder One = new Cylinder(3.0, 5);
        One.setColor("红色");
        One.getVolume();
    }
}
程序的输出结果：
形状的颜色：红色
圆柱体的体积：141.29999999999998

5. 

        （*）按如下要求编写Java程序：
        （1）编写一个接口：OneToN，只含有一个方法int dispose(int n)。
        （2）编写一个非抽象类Sum来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 + 2 + … + n。
        （3）编写另一个非抽象类Pro来实现接口OneToN，实现int dispose (int n)接口方法时，要求计算1 * 2 * … * n。
        （4）编写测试类Test，在main方法中使用接口回调技术来测试实现接口的类。
 

interface OneToN {
    int dispose(int n);
}
class Sumimplements OneToN {
    public int dispose(int n) {
        int s= 0, i;
        for (i = 1; i <= n;i++)
            s += i;
        return s;
    }
}
class Proimplements OneToN {
    public int dispose(int n) { // 实现接口中的dispose方法
        int m = 1, i;
        for (i = 1; i <= n; i++)
            m *= i;
        return m;
    }
}
public class Test {
    public static void main(String args[]) {
        int n = 10;
        OneToN s = new Sum();
        OneToN p = new Pro();
        System.out.println("1至" + n +"的和为" + s.dispose(n));
        System.out.println("1至" + n +"的积为" + p.dispose(n));
    }
}
程序的输出结果：
1至10的和为55
1至10的积为3628800