面向对象编程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.299999999999985.
（*）按如下要求编写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腾讯云开发者
