java编程 定义一个Person类,

Posted 2023-05-15

定义一个Person类,该类具有身高/体重/年龄等属性.能够对上述相关信息进行输出display()和打招呼say().由Person类派生出Usa类,增加爱好属性,覆盖父类方法.
由Person类派生出China类,增加国籍属性,覆盖父类方法.
由China类派生出Guangxi类,增加语言属性,覆盖父类方法.

下面是一个Java代码示例，实现了以上要求：

```java
// 定义Person类，具有身高/体重/年龄等属性
class Person
int height;
int weight;
int age;

// 构造函数
public Person(int height, int weight, int age)
this.height = height;
this.weight = weight;
this.age = age;


// 输出身高、体重、年龄信息的方法
public void display()
System.out.println("身高：" + height + "cm");
System.out.println("体重：" + weight + "kg");
System.out.println("年龄：" + age + "岁");


// 打招呼的方法
public void say()
System.out.println("大家好，我是一名普通人。");



// 由Person类派生出Usa类，增加爱好属性，覆盖父类方法
class Usa extends Person
String hobby;

// 构造函数
public Usa(int height, int weight, int age, String hobby)
// 调用父类的构造函数
super(height, weight, age);
this.hobby = hobby;


// 覆盖父类的display方法，增加输出爱好信息
public void display()
super.display();
System.out.println("爱好：" + hobby);


// 覆盖父类的say方法，输出美式打招呼的信息
public void say()
System.out.println("Hi, everyone! I am an American. Nice to meet you all!");



// 由Person类派生出China类，增加国籍属性，覆盖父类方法
class China extends Person
String nationality;

// 构造函数
public China(int height, int weight, int age, String nationality)
// 调用父类的构造函数
super(height, weight, age);
this.nationality = nationality;


// 覆盖父类的display方法，增加输出国籍信息
public void display()
super.display();
System.out.println("国籍：" + nationality);


// 覆盖父类的say方法，输出中式打招呼的信息
public void say()
System.out.println("大家好，我是一名中国人。很高兴认识大家!");



// 由China类派生出Guangxi类，增加语言属性，覆盖父类方法
class Guangxi extends China
String dialect;

// 构造函数
public Guangxi(int height, int weight, int age, String nationality, String dialect)
// 调用父类的构造函数
super(height, weight, age, nationality);
this.dialect = dialect;


// 覆盖父类的display方法，增加输出方言信息
public void display()
super.display();
System.out.println("方言：" + dialect);


// 覆盖父类的say方法，输出关西方言打招呼的信息
public void say()
System.out.println("嗨，同志们好啊! 我系一个桂平铁花郎，兴县塘豆腐买八两!");// 这里是广西壮话



public class Main
public static void main(String[] args)
// 创建一个Person对象
Person person = new Person(180, 75, 25);
System.out.print("Person的信息：");
person.display();
System.out.print("Person的招呼：");
person.say();

// 创建一个Usa对象
Usa usa = new Usa(175, 70, 30, "Basketball");
System.out.print("Usa的信息：");
usa.display();
System.out.print("Usa的招呼：");
usa.say();

// 创建一个China对象
China china = new China(170, 65, 28, "Chinese");
System.out.print("China的信息：");
china.display();
System.out.print("China的招呼：");
china.say();

// 创建一个Guangxi对象
Guangxi guangxi = new Guangxi(165, 60, 26, "Chinese", "桂林话");
System.out.print("Guangxi的信息：");
guangxi.display();
System.out.print("Guangxi的招呼：");
guangxi.say();


```

在上面的代码中，我们定义了一个`Person`类，它具有身高/体重/年龄三个属性，并实现了对这些属性进行输出和打招呼的方法。然后，我们创建了基于`Person`类的`Usa`类和`China`类，它们分别增加了爱好和国籍两个属性，并覆盖了父类的输出和打招呼方法。最后，我们还创建了基于`China`类的`Guangxi`类，它增加了方言属性，并覆盖了父类的输出和打招呼方法。在主函数中，我们创建了不同类的对象，并输出了它们的信息和打招呼语句。 参考技术A public class Person
private int age;

private double hight;

private double weight;

public String display()

return "Person [age=" + age + ", hight=" + hight + ", weight=" + weight
+ "]";


public String say()

return "";

public int getAge()
return age;

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

public double getHight()
return hight;

public void setHight(double hight)
this.hight = hight;

public double getWeight()
return weight;

public void setWeight(double weight)
this.weight = weight;



class Usa extends Person

private String hobby;

public String display()

return "Usa [hobby=" + hobby + "]";


public String say()

return "";

public String getHobby()
return hobby;

public void setHobby(String hobby)
this.hobby = hobby;



class China extends Person

private String nationality;

public String display()

return "China [nationality=" + nationality + "]";


public String say()

return "";

public String getNationality()
return nationality;

public void setNationality(String nationality)
this.nationality = nationality;


class Guangxi extends Person
private String language;

public String display()

return "Guangxi [language=" + language + "]";


public String say()

return "";

public String getLanguage()
return language;

public void setLanguage(String language)
this.language = language;





相关方法中的逻辑可以自己补充下本回答被提问者和网友采纳 参考技术B 楼上正解0.0

07-Python之面向对象编程（类的基本操作）

# 1.实例化一个类：

- 基本格式：变量 = 类名() # 实列化一个对象

　　* 案例1

# 定义了一个Person类
class Person:   
    count = 1
    age = 18
    
# 实例化对象    
# 执行class时就会得到类对象，并将其赋值给变量名（Person)
p = Person()    # p是一个变量，指向了Person类产生的对象
print(Person)  # Person是一个类
print(p)       # p就成了Person类产生的对象 
"""
# 结果
<class ‘__main__.Person‘>
<__main__.Person object at 0x0000022294ED7F98>
"""

# 2.查看类的信息

- 2.1.可以通过默认内置变量来检查类和对象的所有成员
　　- 对象所有成员检查：obj.__dict__
　　- 类所有成员检查：class_name.__dict__
- 2.2.使用help()函数
- 2.3.使用dir()函数
- 2.4.使用type()查看实例的类型归属
- 2.5.使用内置方法isinstance(实例， ClassName)来测试一个对象是否为某各类的实例

　　* 案例2

# 定义了一个Person类
class Person:   
    name = "China"
    age = 18
    
# 实例化对象     
p = Person()    

# 1.查看成员
    # 1.1查看对象的成员
print(p.__dict__)        # 空字典
    # 1.2查看类的成员
print(Person.__dict__)

# 2.使用help()函数查看
print(help(p))     
# print(help(Person))  # 两个会是一样的结果，指向关系

# 3.使用dir()可以查看对象的属性和方法
print(dir(Person))   # print(dir(p))效果一样

# 4.查看归属
print(type(p), type(Person)) # <class ‘__main__.Person‘> <class ‘type‘>

# 5.判断关系
print(isinstance(p,Person))
    # 如果是该类的实例返回True,否则返回False
    # 注意要判断的p和类Person一定要存在，不然会报错。

# 3.对类的属性进行操作

- 3.0.属性和变量区别：
　　- 变量：根据不同的位置，有不同的访问权限
　　- 属性：只能通过变量名来引用。

- 3.1.访问对象成员
　　- 使用点操作符
　　- obj.成员属性名称
　　- obj.成员方法

- 3.2.增加属性
　　- 动态增加增加
　　　　变量.属性名 = 值
　　- 实例对象可以通过字典__dict__进行增加和修改
　　- 通过类的初始化方法（构造方法）
　　　　__init__ 方法

- 3.3.删除属性
　　- 一般情况下，属性存储在__dict__的字典当中
　　　　- 有些内置对象没有这个__dict__ 属性
　　- 一般对象可以直接修改__dict__属性
　　- 但类对象的__dict__为只读模式
　　　　- 默认无法修改
　　　　- 可以通过setarr方法修改

　　* 案例3

class Person:   
    age = 18
    
p = Person()    # 实例化对象  

# 1.进行访问  
    # 1.1通过类名进行访问
print(Person.age)  # 18
    # 1.2通过实例化对象进行访问   
print(p.age)       # 18            
"""-----------------------------------------------------------"""
# 2.增加操作
    # 注意：如果要增加的变量已存在，则修改
    # 2.1动态增加
        # 2.1.1直接通过类名进行属性增加
Person.name = ‘abc‘   
print("Person:", Person.__dict__)   
print("p:", p.__dict__)   # 空字典
        # 2.1.2通过实例进行增加
p.zeng = 100    # 只在p里面增加，不影响Person
print("Person:", Person.__dict__)
print("p:", p.__dict__)    # ‘zeng‘: 100
    # 2.2使用构造方法(属于方法的操作)
"""-----------------------------------------------------------"""
# 3.删除操作
    # 注意：
        # del p.age  #会报错，p内不存在age
        # 可以进行del p.zeng,因为前面增加了zeng属性
    # 3.1实例删除
del p.zeng
    # 3.2直接通过类
del Person.age
print("Person:", Person.__dict__)    # 缺少了age属性
print("p:", p.__dict__)   # 空字典

# 4.类的属性的存储问题

- 4.1一般情况下，属性存储在__dict__的字典当中。
　　- 实例对象一般可以直接修改__dict__属性
　　- 类对象的__dict__为只读
- 4.2实例对象和类对象是存储在不同一块空间。
- 4.3访问时：
　　- 通过类对象：直接在类对象中查找
　　- 通过实例对象：优先在实例对象内部查找，没有找到需要的，就到指向的类对象中查找。
- 4.4修改时的区别：
　　- 通过实例对象进行增加、删除或者修改属性的值，都是在实例对象内部进行，对类对象没有影响
　　- 通过类对象进行增加、删除属性时:
　　　　- 对实例化对象内部没有的属性产生影响。
　　　　- 对实例化对象内部已拥有相同的属性不产生影响。

　　* 案例4.1

# 1.一般情况下，属性存储在__dict__的字典当中
class Person():
    age = 18
    
p = Person()
print(p.__dict__)  # 空字典
print(p.age)# 18 
            # 虽然是空字典但是能访问Person的属性，指向的关系
"""-----------------------------------------------------------"""    
# 1.1可以通过字典__dict__修改实例对象的属性
p.__dict__ = "count":2,"sex":"男"
"""-----------------------------------------------------------"""
# 1.2类对象的__dict__为只读
#Person.__dict__ = "count":3,"age":15
#Person.__dict__ = "sex":"男"  #会报错，
"""-----------------------------------------------------------"""
print(Person.__dict__)   
print(p.__dict__)   # ‘count‘: 2, ‘sex‘: ‘男‘

　　* 案例4.2

# 2.实例对象和类对象是存储在不同一块空间。
class Person():
    age = 19
    pass
"""-----------------------------------------------------------"""
# 2.1内存上开辟了新空间，两者的地址不一样
p = Person()  
print(id(p), id(Person))
"""-----------------------------------------------------------"""
# 2.2修改和新增类的地址都不变
p.age = 18  
Person.name = "aaaa"
print(id(p), id(Person))
"""-----------------------------------------------------------"""
# 2.3属性修改后的地址变化和列表的修改变化一样
p.pets = ["car","dog"]
print(p.pets,id(p.pets)) 

p.pets = ["car", "dog", "fish"]  # 直接修改   
print(p.pets,id(p.pets))
p.pets.append("iiiii")    # 进行追加操作
print(p.pets,id(p.pets))
"""-----------------------------------------------------------"""
print(p.__dict__)  #‘age‘: 18, ‘pets‘: [‘car‘, ‘dog‘, ‘fish‘, ‘iiiii‘]
print(Person.__dict__)  # Person 中z属性没发生改变

　　* 案例4.3

# 3.访问时：
class Person():
    age = 19
    pass
p = Person()  
p.age = 18
print(p.age)    # 18  # 优先访问自己的内部属性
print(Person.age) # 19 # Person.age没有被修改，
                    # 通过类访问，直接指向类对象的age

　　* 案例4.4

# 4.修改时：
class Person():
    age = 18
    pass
p = Person()  
# 4.1未修改前类对象和实例对象指向同一个属性。
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age))
print("---"*10)

# 4.2通过实例对象进行修改，没有对类对象产生影响
p.age = 28
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age))   
print("---"*10)

# 4.3通过类对象进行修改
Person.age = 38
    # 4.3.1实例对象p内部有age属性，无法造成影响
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age)) 
print("---"*10)

    # 4.3.2实例对象p内部没有age属性，无法造成影响
del p.age   # 删除p中的age
print("p     :", p.age, id(p.age))   # 此时访问p.age则指向Person.age
Person.age = 48    # 通过类对象修改age
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age)) 

# 5.对类的方法进行操作

- 5.1方法的存储：方法存储在类里面,不管是哪一种类型的方法，都是存储在类当中，没有在实例当中

　　* 案例5.1

class Person():
    
    # 1.实例方法：默认第一个参数需要接受到一个实例
    def eat(self):    # 必须要有参数，默认是self
        print("这是一个实例方法",self)
    
    # 2.类方法：默认第一个参数需要接受到一个实例
    @classmethod
    def leifangfa(cls):
        print("这是一个类方法",cls)

    # 33.静态方法：第一个参数啥也不默认接受
    @staticmethod
    def jingtaifangfa():
        print("这是一个静态方法")
        
p = Person()
# 查看参数
print(p)
p.eat()   # self和p的地址一样
Person.leifangfa()   # <__main__.Person object at 0x0000022294ECFE48>
Person.jingtaifangfa()  # <class ‘__main__.Person‘>
# 查看方法存储
print(p.__dict__)   # 空字典
print(Person.__dict__)  

-  5.2实例方法调用方式：本质就是找到函数本身调用
　　- 标准调用（推荐使用）：使用实例调用
　　- 类调用: 使用类名进行调用，没有意义
　　- 间接调用

　　* 案例5.2

class Person:
    def eat(self,food):
        print("我在吃饭",self, food)
        
# 1.标准调用
p = Person()
print(p) # p就时self，系统自动传入
print(p.eat("rich"))  # 这是实例化 可以只写一个参数，self是默认参数，可以不用写
                        # 标准调用，实例化调用 不用写第一个参数self        
    
# 2.类调用   
print(Person.eat)   # Person.eat 是一个函数
print(Person.eat(555,"FISH"))# 必须要有两个参数，不然会报错
                                # self = 555, food = FISH
# 3.间接调用
func = Person.eat  # Person.eat 是一个函数,func指向Person.eat
print(func(123,"DDD"))     # self = 123, food = DDD

- 5.3类方法

　　* 案例5.3

class Person():
    @classmethod    # 通过这个装饰器
    def leifangfa(cls, a):
        print("这是一个类方法",cls, a)

# 1.类调用
print(Person.leifangfa(123))

# 2.间接调用
func = Person.leifangfa
print(func(456))

# 3.实例化，标准调用
p = Person()
print(p.leifangfa(789))

- 5.4静态方法

　　* 案例5.4

class Person():
    @staticmethod
    def leifangfa(self):    # 参数没有默认接受
        print("这是一个静态方法",self)

# 1.类调用
print(Person.leifangfa(1))

# 2.间接调用
func = Person.leifangfa
print(func(2))

# 3.实例化，标准调用
p = Person()
print(p.leifangfa(3))

- 5.4不同方法的调用

　　* 案例5.5

class Person():
    age = 18  # 能通过实例和类访问
    def shilifangfa(self):   
        print(self)
        print(self.age)
        print(self.num)
        
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
       #  print(Person.num)  无法访问

    @staticmethod
    def jingtaifangfa():
        print("jingtai")
p = Person()
p.num = 10  # 只能通过实例访问，无法通过类访问: Person.num
# 调用类属性
print(Person.age)  # 18
print(p.age)  # 18
# 调用实例属性
print(p.num) # 19
print(‘--‘*20)
print(p.shilifangfa())
print(‘--‘*20)
print(p.leifangfa())
print(‘--‘*20)
print(p.jingtaifangfa())
"""
# 结果
18
18
10
----------------------------------------
<__main__.Person object at 0x000001AA7705B668>
18
10
None
----------------------------------------
<class ‘__main__.Person‘>
18
None
----------------------------------------
jingtai
None
"""