面向对象编程答案3

左手的ㄟ右手 2022-04-22 09:10 164阅读 0赞

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();
    	}
    
    }

按如下要求编写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();
    		
    	}
    }

（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

（\*）按如下要求编写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