9.封装一个小猫类

package com.duixiang.Demo11;

public class Cat {
    private String name;
    private int age;
    private String color;
//    static int count;
//    private Cat[]arr;

    public String getName() {
//        arr[count].name = name;
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
//        arr[count].age = age;
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
//        arr[count].color = color;
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //    {
//        count++;
//    }
//    KuaiDi x = new KuaiDi();


    public void show() {
//        for(Cat a :arr){
//            System.out.println(a.name+a.color+a.age);
        System.out.println(name + age + "岁" + color);
    }
//        }


}
package com.duixiang.Demo11;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        Cat mao = new Cat();
        Cat mao2 = new Cat();
        mao.setName("小花");
        mao.setAge(3);
        mao.setColor("白色");
        mao2.setName("小白");
        mao2.setAge(3);
        mao2.setColor("花色");

        Scanner sc = new Scanner(System.in);
        int a = 0;
        while (a>=0){
            String aa = sc.nextLine();
            if(aa.equals(mao.getName())){
                mao.show();
                break;
            } else if (aa.equals(mao2.getName())) {
                mao2.show();
                break;
            }else {
                System.out.println("请重新输入");
            }
            a++;
        }





    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: 好的,我可以回答这个问题。以下是一个用 C 语言实现封装、继承和多态的例子: ```c #include <stdio.h> // 定义一个 Animal typedef struct { const char* name; int age; } Animal; // 定义一个 Animal 的构造函数 void Animal_init(Animal* animal, const char* name, int age) { animal->name = name; animal->age = age; } // 定义一个 Animal 的成员函数 void Animal_say(Animal* animal) { printf("%s is %d years old.\n", animal->name, animal->age); } // 定义一个派生 Cat,继承自 Animal typedef struct { Animal base; const char* color; } Cat; // 定义一个 Cat 的构造函数 void Cat_init(Cat* cat, const char* name, int age, const char* color) { Animal_init(&cat->base, name, age); cat->color = color; } // 定义一个 Cat 的成员函数,覆盖了 Animal 的成员函数 void Cat_say(Cat* cat) { printf("%s is a %s cat.\n", cat->base.name, cat->color); } int main() { // 创建一个 Animal 对象 Animal animal; Animal_init(&animal, "Tom", 3); Animal_say(&animal); // 创建一个 Cat 对象 Cat cat; Cat_init(&cat, "Kitty", 2, "white"); Cat_say(&cat); // 多态调用 Animal 的成员函数 Animal* ptr = &cat.base; Animal_say(ptr); return ; } ``` 这个例子中,Animal 是一个Cat一个派生,继承自 Animal。Animal 和 Cat 都有一个构造函数和一个成员函数,Animal 的成员函数是 say,Cat 的成员函数也是 say,但是覆盖了 Animal 的成员函数。在 main 函数中,我们创建了一个 Animal 对象和一个 Cat 对象,并分别调用了它们的成员函数。最后,我们还演示了多态的用法,通过一个 Animal 指针来调用 Cat 的成员函数。 ### 回答2: 下面是一个使用C语言编写的封装、继承和多态的示例: ```c #include <stdio.h> // 定义基动物 typedef struct { const char* name; void (*makeSound)(void); // 定义抽象方法,后续通过继承实现 } Animal; // 定义基方法 void Animal_makeSound(void) { printf("动物发出了声音\n"); } // 初始化基对象 void Animal_init(Animal* animal, const char* name) { animal->name = name; animal->makeSound = Animal_makeSound; } // 定义子猫 typedef struct { Animal base; // 子包含基对象 } Cat; // 子方法的实现 void Cat_makeSound(void) { printf("猫发出了“喵~”的声音\n"); } // 初始化子对象 void Cat_init(Cat* cat, const char* name) { Animal_init(&(cat->base), name); cat->base.makeSound = Cat_makeSound; } int main() { // 创建基对象 Animal animal; Animal_init(&animal, "动物"); animal.makeSound(); // 创建子对象 Cat cat; Cat_init(&cat, "小猫"); cat.base.makeSound(); return 0; } ``` 在这个例子中,我们首先定义了一个Animal,包含一个成员变量name和一个抽象方法makeSound。然后我们定义了一个方法Animal_makeSound,用于打印出动物发出声音的信息。 接下来,我们定义了一个Cat,包含一个对象base。子重写了基的抽象方法makeSound,并定义了一个方法Cat_makeSound,用于打印出猫发出声音的信息。 在主函数中,我们先创建了一个对象animal并调用其makeSound方法,然后创建了一个对象cat并调用其基对象的makeSound方法。运行程序后,输出为: ``` 动物发出了声音 猫发出了“喵~”的声音 ``` 这个例子展示了如何使用C语言实现封装、继承和多态的概念。封装通过将数据和功能封装在结构体中实现,继承通过在子中包含基对象实现,多态通过子重写基方法实现。 ### 回答3: C语言是一种面向过程的编程语言,不支持封装、继承和多态等面向对象的特性。但我们可以模拟实现这些特性。 首先,我们使用结构体来模拟封装。例如,我们可以创建一个汽车结构体,包含品牌、颜色等属性,并提供相应的函数对属性进行操作和访问。 ```c typedef struct Car { char brand[20]; char color[10]; int speed; void (*display)(struct Car *); } Car; void displayCar(Car *car) { printf("Brand: %s\n", car->brand); printf("Color: %s\n", car->color); printf("Speed: %d\n", car->speed); } int main() { Car car; strcpy(car.brand, "BMW"); strcpy(car.color, "Red"); car.speed = 180; car.display = displayCar; car.display(&car); return 0; } ``` 接下来,我们使用结构体的嵌套来模拟继承。例如,我们创建一个SUV结构体,作为Car结构体的子结构体,并拥有额外的属性。 ```c typedef struct SUV { Car car; int wheelSize; void (*displaySUV)(struct SUV *); } SUV; void displaySUV(SUV *suv) { printf("Brand: %s\n", suv->car.brand); printf("Color: %s\n", suv->car.color); printf("Speed: %d\n", suv->car.speed); printf("Wheel Size: %d\n", suv->wheelSize); } int main() { SUV suv; strcpy(suv.car.brand, "Toyota"); strcpy(suv.car.color, "Blue"); suv.car.speed = 200; suv.wheelSize = 18; suv.displaySUV = displaySUV; suv.displaySUV(&suv); return 0; } ``` 最后,我们使用函数指针和结构体的指针来实现多态。例如,我们为Car和SUV结构体定义相同的display函数指针,并通过传入不同的对象来实现多态。 ```c typedef struct Vehicle { char type[10]; void (*display)(void *); } Vehicle; void displayCar(void *car) { Car *c = (Car *)car; printf("Brand: %s\n", c->brand); printf("Color: %s\n", c->color); printf("Speed: %d\n", c->speed); } void displaySUV(void *suv) { SUV *s = (SUV *)suv; printf("Brand: %s\n", s->car.brand); printf("Color: %s\n", s->car.color); printf("Speed: %d\n", s->car.speed); printf("Wheel Size: %d\n", s->wheelSize); } int main() { Car car; strcpy(car.brand, "BMW"); strcpy(car.color, "Red"); car.speed = 180; SUV suv; strcpy(suv.car.brand, "Toyota"); strcpy(suv.car.color, "Blue"); suv.car.speed = 200; suv.wheelSize = 18; Vehicle vehicles[2]; vehicles[0].display = displayCar; vehicles[1].display = displaySUV; vehicles[0].display(&car); vehicles[1].display(&suv); return 0; } ``` 尽管以上例子可以模拟实现封装、继承和多态,但请注意在实际的C语言开发中,这些特性是由其他高级编程语言(如C++)提供的。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值