过来领题，水平有限，慢慢搞。。。。

今天才看到，不想放弃得分的机会，希望不晚。

练习练习

新手尝试答题

新人，领题。

上一次阳哥提到的，创建小红需要父母作为参数传进去，这次可以了，可以给满分了吧:lol,PS:多谢论坛的同学帮忙

真的有分啊:lol

先写一个“人”这个类；
然后再写“男人”“女人”两个类，继承人这个类，Override“人”类的方法；
最后写爸爸爷爷两个类继承“男人”， 妈妈奶奶和小红继承“女人”；
这就是我的想法，接触面向对象没多久，别笑话。。

只能这么简陋了

是这样吗？

求题目求题目求题目求题目

我要领题，请出示

老师辛苦了

不错不错

好像拿但是还没有学到，争取下次

新人，，先看看:)

今天刚看到，临时抱佛脚:D

a1301155262 发表于 2015-3-15 16:33
管理员权限怎么设置？？找不到，我选了个最高权限。

继续努力，加油。

和谐木马 发表于 2015-3-15 15:33
老师，现在算结束了么？上课时间不多……
把代码和截图一起压缩上传
PS：JAVA新手，想法或过程有什么不对求 ...

写的不错，大家可以参考：

1. /*
   
2.         题目：请用java中面向对象的思想用代码描述如下内容：小红（女）有爸爸和妈妈，爸爸和妈妈分别有自己的爸爸和妈妈。。。，小红的爸爸会做工作A和B，
   
3.         小红的妈妈会做工作C和D。
   
4.         要求：将上面的情景用Java类来描述，要求自己抽象出接口和对象。
   
5. */
   
6. 
   
7. class PersonTest
   
8. {
   
9.         public static void main(String[] args)
   
10.         {
    
11.                 Person p=new Person("小红",'女');
    
12.                 System.out.println("小红她爸");
    
13.                 p.father.setWork(new Work_A());           //person对象的爸爸调用含工作接口的工作A
    
14.                 p.father.setWork(new Work_B());
    
15.                 System.out.println("小红她妈");
    
16.                 p.mother.setWork(new Work_C());           //person对象的妈妈调用含工作接口的工作C
    
17.                 p.mother.setWork(new Work_D());
    
18.                 p.father.father.name="小红她爸的爸";      //给person对象的爸爸的爸爸的名字赋值
    
19.                 p.mother.mother.name="小红她妈的妈";      //给person对象的妈妈的妈妈的名字赋值
    
20.                 System.out.println("我是"+p.father.father.name);
    
21.                 System.out.println("我是"+p.mother.mother.name);
    
22.         }
    
23. }
    
24. 
    
25. class Person
    
26. {
    
27.         String name;
    
28.         char sex;
    
29.         Father father;
    
30.         Mother mother;
    
31.         //空参的构造函数
    
32.         public Person(){
    
33.         }
    
34.         //带姓名和性别的Person类的构造函数
    
35.         public Person(String name,char sex){
    
36.                 this.name=name;
    
37.                 this.sex=sex;
    
38.                 /*
    
39.                         构造Father，Mother类时，参数列表里的1只是一个无意义实数，是为了了无参的构造函数区分开来，
    
40.                         表示此处调用的是个有参的构造函数
    
41.                 */
    
42.                 this.father=new Father(1);     //在构造一个Person类的时候也赋值它的一个"爸爸类"的属性
    
43.                 this.mother=new Mother(1);     //在构造一个Person类的时候也赋值它的一个"妈妈类"的属性
    
44.         }
    
45. }
    
46. 
    
47. //定义一个工作接口
    
48. interface Work
    
49. {
    
50.         public abstract void working();
    
51. }
    
52. 
    
53. //定义一个工作A类实现工作接口
    
54. class Work_A implements Work
    
55. {
    
56.         public void working()
    
57.         {
    
58.                 System.out.println("会干A工作");
    
59.         }
    
60. }
    
61. //定义一个工作B类实现工作接口
    
62. class Work_B implements Work
    
63. {
    
64.         public void working()
    
65.         {
    
66.                 System.out.println("会干B工作");
    
67.         }
    
68. }
    
69. //定义一个工作C类实现工作接口
    
70. class Work_C implements Work
    
71. {
    
72.         public void working()
    
73.         {
    
74.                 System.out.println("会干C工作");
    
75.         }
    
76. }
    
77. //定义一个工作D类实现工作接口
    
78. class Work_D implements Work
    
79. {
    
80.         public void working()
    
81.         {
    
82.                 System.out.println("会干D工作");
    
83.         }
    
84. }
    
85. 
    
86. /*
    
87.         因为爸爸还有爸爸和妈妈，所以在实例化一个爸爸类时还应该递归调用一个创建爸爸类的构造函数，但为了避免无限循环，
    
88.         可以调用不同参数列表的构造函数，因此构造了一个有临时变量temp参数的构造函数，和最后调用的无参的构造函数。
    
89.         妈妈类同理！
    
90. */
    
91. class Father extends Person        //定义一个爸爸类，它继承于Person类
    
92. {
    
93.         public Father(){
    
94.         }
    
95.         public Father(int temp){
    
96.                 father=new Father();
    
97.                 mother=new Mother();
    
98.         }
    
99.         public void setWork(Work work)
    
100.         {
     
101.                 if(work!=null)
     
102.                         work.working();         //爸爸类调用带工作接口的类的工作函数
     
103.         }
     
104. }
     
105. 
     
106. 
     
107. class Mother extends Person          //定义一个妈妈类，它继承于Person类
     
108. {
     
109.         //无参的构造函数
     
110.         public Mother(){
     
111.         }
     
112.         //有一个临时变量temp的构造函数，这个temp只是为了区分无参的构造函数
     
113.         public Mother(int temp){
     
114.                 father=new Father();       //最里层调用无参的构造函数
     
115.                 mother=new Mother();
     
116.         }
     
117.         public void setWork(Work work)
     
118.         {
     
119.                 if(work!=null)
     
120.                         work.working();        //妈妈类调用带工作接口的类的工作函数
     
121.         }
     
122. }
     

复制代码

shewim 发表于 2015-3-15 12:35
提交答案，麻烦老师帮忙看看！谢谢了...

写的不错，可以作为大家的参考：

1. class ClassTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 String[] fWork = {"A","B"};
   
6.                 String[] mWork = {"C","D"};
   
7.                 Person f = new Person("红爸",new Person("红爷爷"),new Person("红奶奶"),fWork);
   
8.                 Person m = new Person("红妈",new Person("红姥姥"),new Person("红姥爷"),mWork);
   
9.                 Person d = new Person("小红",f,m);
   
10. 
    
11.                 d.showPerson();
    
12. //                System.out.println("Hello World!");
    
13.         }
    
14. }
    
15. class Person
    
16. {
    
17.         private String name;
    
18.         private Person father = null;
    
19.         private Person mother = null;
    
20.         private String[] work = null;
    
21. 
    
22.         Person()
    
23.         {
    
24.         }
    
25.         Person(String name)
    
26.         {
    
27.                 this.name = name;
    
28.         }
    
29.         Person(String name,String[] work)
    
30.         {
    
31.                 this.name = name;
    
32.                 this.work = work;
    
33.         }
    
34.         Person(String name,Person father,Person mother)
    
35.         {
    
36.                 this.name = name;
    
37.                 this.father = father;
    
38.                 this.mother = mother;
    
39.         }
    
40.         Person(String name,Person father,Person mother,String[] work)
    
41.         {
    
42.                 this.name = name;
    
43.                 this.father = father;
    
44.                 this.mother = mother;
    
45.                 this.work = work;
    
46.         }
    
47. 
    
48.         public void showPerson()
    
49.         {
    
50.                
    
51.                 System.out.print("我是"+name);
    
52. 
    
53.                 if (null != work)
    
54.                 {
    
55.                         System.out.print("，我会工作");
    
56.                         for (int i = 0;i < work.length  ;i++ )
    
57.                         {
    
58.                                 System.out.print(work[i]);
    
59.                                 if (work.length - 1 != i)
    
60.                                 {
    
61.                                         System.out.print("、");
    
62.                                 }
    
63.                         }
    
64.                 }
    
65.                 System.out.println();
    
66.                 System.out.println();
    
67. 
    
68.                 if (null != father)
    
69.                 {
    
70.                         System.out.println(name + "的爸爸：");
    
71.                         father.showPerson();
    
72.                 }
    
73.                 if (null != mother)
    
74.                 {
    
75.                         System.out.println(name + "的妈妈：");
    
76.                         mother.showPerson();
    
77.                 }
    
78. 
    
79.                
    
80.         }
    
81. 
    
82.         public void setName(String name)
    
83.         {
    
84.                 this.name = name;
    
85.         }
    
86.         public String getName()
    
87.         {
    
88.                 return this.name;
    
89.         }
    
90. 
    
91.         public void setFather(Person father)
    
92.         {
    
93.                 this.father = father;
    
94.         }
    
95.         public Person getFather()
    
96.         {
    
97.                 return father;
    
98.         }
    
99. 
    
100.         public void setMother(Person mother)
     
101.         {
     
102.                 this.mother = mother;
     
103.         }
     
104.         public Person getMother()
     
105.         {
     
106.                 return mother;
     
107.         }
     
108. }
     

复制代码