Java类的继承案例

1.变异动物类Animal，定义两个成员变量name和age
2定义结构方法和初始化成员变量
3定义成员方法sayHollo（）显示动物信息
4.定义Cat和Dog类，继承与Animal类，调用父类结构方法，初始化成员变量
5.分别定义Cat类和Dog类，继承与Animal类，调用父类结构方法初始化成员变量

这个都要15块钱花钱解决, 你转行吧,你不适合这个行业

这种基础问题看一下教材吧

这个案例比较常见的，简单写了一个 你先看看，有问题再问我

public class Animal {
  protected string name;
  protected int age;

  public Animal(string name, int age) {
    this.name = name;
    this.age = age;
  }

  public void sayHello() {
    Console.WriteLine("My name is {0} and I am {1} years old.", name, age);
  }
}

public class Cat : Animal {
  public Cat(string name, int age) : base(name, age) {
  }
}

public class Dog : Animal {
  public Dog(string name, int age) : base(name, age) {
  }
}

使用方法如下：

Cat myCat = new Cat("Lucy", 5);
myCat.sayHello();

Dog myDog = new Dog("Buddy", 3);
myDog.sayHello();

输出结果如下：

My name is Lucy and I am 5 years old.
My name is Buddy and I am 3 years old.

在上面的代码中，Animal类有一个带有两个参数的构造函数来初始化成员变量name和age，还有一个成员方法sayHello()来打印动物的信息。Cat和Dog类分别继承于Animal类，并在构造函数中调用了基类的构造函数来初始化成员变量。最后，我们创建了一个Cat对象和一个Dog对象，并调用了它们各自的sayHello方法来输出动物信息。

// Animal类
public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("我是一只动物，我的名字是" + name + "，我今年" + age + "岁了。");
    }
}

// Cat类
public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
}

// Dog类
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
}

// 测试代码
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("小猫", 2);
        Dog dog = new Dog("小狗", 3);

        cat.sayHello();
        dog.sayHello();
    }
}

代码

public abstract class Animal {

    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void sayHello();

    public void show() {
        sayHello();
        System.out.println("name:" + this.name + ";age:" + this.age);
    }


    public static void main(String[] args) {
        Animal a = new Cat("小猫", 2);
        a.show();

        Animal b = new Dog("小狗", 3);
        b.show();
    }
}

public class Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void sayHello() {
        System.out.println("小猫打招呼用，喵喵喵.....");
    }


}
public class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void sayHello() {
        System.out.println("小狗打招呼用，汪汪汪.....");
    }
}

代码如下：

// 定义Animal类
class Animal {
    String name;
    int age;

    // 定义构造方法并初始化成员变量
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 定义sayHello方法，输出动物信息
    public void sayHello() {
        System.out.println("我是一只" + this.getClass().getSimpleName() + "，我的名字叫" + name + "，我今年" + age + "岁了");
    }
}

// 定义Cat类，继承自Animal类
class Cat extends Animal {

    // 调用父类的构造方法初始化成员变量
    public Cat(String name, int age) {
        super(name, age);
    }

}

// 定义Dog类，继承自Animal类
class Dog extends Animal {

    // 调用父类的构造方法初始化成员变量
    public Dog(String name, int age) {
        super(name, age);
    }

}

public class Test {
    public static void main(String[] args) {
        // 创建一只猫实例
        Cat cat = new Cat("咪咪", 2);
        // 调用sayHello方法输出猫的信息
        cat.sayHello();

        // 创建一只狗实例
        Dog dog = new Dog("旺财", 3);
        // 调用sayHello方法输出狗的信息
        dog.sayHello();
    }
}

输出结果为：

我是一只Cat，我的名字叫咪咪，我今年2岁了
我是一只Dog，我的名字叫旺财，我今年3岁了

Animal类的代码实现如下：

java
public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.println("My name is " + name + ", and I am " + age + " years old.");
    }
}
Cat类和Dog类继承于Animal类，其代码实现如下：

java
public class Cat extends Animal {

    public Cat(String name, int age) {
        super(name, age);
    }
}

public class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }
}

在主函数中，我们便可以创建这两个子类并调用父类的sayHello方法来输出动物信息，如下所示：

java
public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat("Kitty", 3);
        Dog dog = new Dog("Buddy", 5);

        cat.sayHello();
        dog.sayHello();
    }
}

运行上面的代码，输出结果如下：

My name is Kitty, and I am 3 years old.
My name is Buddy, and I am 5 years old.

之前写的：

//定义Animal父类
class Animal {
    private String name;//           定义name的属性
    private int age;//               定义age的属性
    //定义set和get方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }
}
//---------------------定义Dog,Cat类继承Animal类--------------------------
class Dog extends Animal{}//此处写任何代码
class Cat extends Animal{}//此处写任何代码
//定义一个测试类
 class Example01{
    public static void main(String[] args) {
       Dog dog=new Dog();//创建一个Dog类的实例对象
       dog.setName("牧羊犬");//此时访问的方法是父类中的，子类中并没有定义
       dog.setAge(3);
       System.out.println("名称   "+dog.getName()+"，年龄   "+dog.getAge());
        System.out.println("------------------------------------------------");
        Cat cat=new Cat();//创建一个Cat类的实例对象
        dog.setName("咖啡猫");//此时访问的方法是父类中的，子类中并没有定义
        dog.setAge(2);
        System.out.println("名称   "+dog.getName()+"，年龄   "+dog.getAge());
    }
}

这问题真的好吗？初学者更应该要自己做。

1、父类Animal

package 主题六_类和对象的高级应用;
 
//定义一个公共类作为父类
public class Animal
{
    private String name;
    private int month;
    private String species;
    //初始化属性值
    public Animal()
    {
    }
    
    
    
    //定义方法
    public String getName()
    {
        return name;
    }
    public int getMonth()
    {
        return month;
    }
    public String getSpecies()
    {
        return species;
    }
    
    //有参数构造函数方法
    public void setName(String name)
    {
        this.name=name;
    }
    public void setMonth(int month)
    {
        this.month=month;
    }
    public void setSpecies(String species)
    {
        this.species=species;
    }
    
    
    public void eat()
    {
        System.out.println("它在吃东西");
    }
    public void month()
    {
        System.out.println("它"+this.getMonth()+"个月大了");
    }
}
/*
 * 类的继承格式
 * class 父类{}
 * class 子类 extends 父类{}
 * 
 * 
 * super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
 * this关键字：指向自己的引用。
 */

helloworld写过吗

这个比较简单啊，看我下面代码：
1.Animal类

public class Animal {
    // 成员变量
    private String name;
    private int age;

    // 构造方法（初始化成员变量）
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public void sayHello() {
        System.out.println("我是一只动物，我的名字是" + name + ", 我今年" + age + "岁了。");
    }
}

2.Cat类

public class Cat extends Animal {
    // 构造方法（调用父类构造方法初始化成员变量）
    public Cat(String name, int age) {
        super(name, age);
    }

    // 重写父类成员方法
    public void sayHello() {
        System.out.println("我是一只猫咪，我的名字是" + super.getName() + ", 我今年" + super.getAge() + "岁了。");
    }
}

3.Dog类

public class Dog extends Animal {
    // 构造方法（调用父类构造方法初始化成员变量）
    public Dog(String name, int age) {
        super(name, age);
    }

    // 重写父类成员方法
    public void sayHello() {
        System.out.println("我是一只狗狗，我的名字是" + super.getName() + ", 我今年" + super.getAge() + "岁了。");
    }
}

使用这些类的示例代码：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal("动物", 1);
        animal.sayHello();

        Cat cat = new Cat("咪咪", 2);
        cat.sayHello();

        Dog dog = new Dog("旺财", 3);
        dog.sayHello();
    }
}

不得不说，gpt4写得相当标准，用来教学还可以，引用gpt4:

1. 定义变异动物类Animal,定义两个成员变量name和age:

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHollo() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

2. 定义结构方法和初始化成员变量：

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHollo() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

3. 定义成员方法sayHollo()显示动物信息：

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void sayHollo() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

回答部分参考、引用ChatGpt以便为您提供更准确的答案：

1. 变异动物类Animal，定义两个成员变量name和age：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

2. 定义结构方法和初始化成员变量：

结构方法是指类中的构造函数，用于初始化对象的成员变量。

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sayHello(self):
        print("我是动物，我的名字是{}，我今年{}岁。".format(self.name, self.age))

3. 定义成员方法sayHello()显示动物信息：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sayHello(self):
        print("我是动物，我的名字是{}，我今年{}岁。".format(self.name, self.age))

4. 定义Cat和Dog类，继承于Animal类，调用父类结构方法，初始化成员变量：

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)


class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)

5. 分别定义Cat类和Dog类，继承于Animal类，调用父类结构方法初始化成员变量：

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)


class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)