day08作业--------------Java面向对象JavaObject01

作业：

1.定义一个Student类：
　　a. 要求包含4个成员变量 String name, int age, boolean isMale, int sno
　　b. 分别定义5个构造方法
　　　　分别为无参构造
　　　　初始化name成员变量值的1参构造方法
　　　　初始化name 和 sno两个成员变量值的2参构造方法
　　　　初始化name，age，isFimale三个成员变量值的3参构造方法
　　　　初始化name，age， isMale，sno这4个成员变量值的4参构造方法
　　c. 再定义一个成员方法
　　　　public void print() {
　　　　　　System.out.println(name + "---" + age + "---" + (isMale ? "男" : "女") + "---" + sno);｝

2. 在第一题的基础上，创建两个Student对象分别为stu1和stu2
　　要求stu1对象的四个成员变量name, age, isMale, sno的值分别为“张三”,18,true, 1
　　要求stu2对象的四个成员变量name, age, isMale, sno的值分别为“李四”,25,false, 2
　　然后在两个对象上调用print()方法即
　　stu1.print(), stu2.print(),两次调用方法输出的结果相同吗？
　　为什么？(提示：在方法体中访问name成员变量，直接用成员变量名name，是this.name的简写形式)

3. 在定义类MyStudent(类中定义的成员变量和成员方法同Student，同时在MyStudent类中定义和Student相似的5个构造方法)的基础上，根据需要修改MyStudent相应构造方法的方法体，要求实现
　　MyStudent st = new MyStudent();
　　st.print();
这两句代码打印出的结果是 麻花疼---100---男---1000

4. 如下代码所示，分别将一个double类型的数据和一个引用类型的数据传入某个方法，在方法内分别对对应的数据进行一些运算 ，经过运算之后，double类型的数据和引用类型的数据分别是什么? 并解释下，为什么

 1 public class Demo4 {
 2     public static void main(String[] args) {
 3         Person p = new Person();
 4         p.name = "我是马化腾";
 5         p.age = 50;
 6         PersonTest(p);
 7         double money = 100;
 8         doubleTest(money);
 9         System.out.println("方法执行后的money："+money);
10         System.out.println("方法执行后的name:"+p.name);
11     }
12     private static void doubleTest(double money) {
13         money = 200;
14     }
15     public static void PersonTest(Person person) {
16         System.out.println("传入的person的name："+person.name);
17         person.name = "我是马云";
18         System.out.println("方法内重新赋值后的name:"+person.name);
19     }
20 }
21 class Person{
22     String name;
23     int age;
24 }

 

答案;

1.

 1 package com.day008;
 2 /*
 3  * 1.定义一个Student类：
 4    a. 要求包含4个成员变量 String name, int age, boolean isMale, int sno
 5    b. 分别定义5个构造方法 
 6       分别为无参构造
 7  初始化name成员变量值的1参构造方法
 8  初始化name 和 sno两个成员变量值的2参构造方法
 9  初始化name，age，isFimale三个成员变量值的3参构造方法
10  初始化name，age， isMale，sno这4个成员变量值的4参构造方法
11    c. 在定义一个成员方法
12       public void print() {
13    System.out.println(name + "---" + age + "---" + (isMale ? "男" : "女") + "---" + sno);
14  */
15 public class Demo1 {
16     public static void main(String[] args) {
17         //0.使用无参的构造方法
18         Student stu0 = new Student();
19         System.out.println(stu0.name+"--"+stu0.age+"--"+stu0.isMale+"--"+stu0.sno);
20         //1.使用1参的构造方法
21         Student stu1 = new Student("张三");
22         System.out.println(stu1.name+"--"+stu1.age+"--"+stu1.isMale+"--"+stu1.sno);
23         //2.使用2参的构造方法
24         Student stu2 = new Student("李四",04);
25         System.out.println(stu2.name+"--"+stu2.age+"--"+stu2.isMale+"--"+stu2.sno);
26         //3.使用3参的构造方法
27         Student stu3 = new Student("王五",25,true);
28         System.out.println(stu3.name+"--"+stu3.age+"--"+stu3.isMale+"--"+stu3.sno);
29         //4.使用4参的构造方法
30         Student stu4 = new Student("赵六",26,true,06);
31         System.out.println(stu4.name+"--"+stu4.age+"--"+stu4.isMale+"--"+stu4.sno);
32         //调用成员方法
33         stu4.print();
34     }
35 }
36 //定义学生类
37 class Student{
38     //a.定义4个成员变量
39     String name;
40     int age;
41     boolean isMale;
42     int sno;
43     
44     //分别定义5个构造方法 
45     //0.定义无参构造
46     public Student() {
47         name = "不知名字";
48         age = -1;
49         isMale = true;
50         sno = -1;
51         System.out.println("0.使用了无参的构造方法Student() ");
52     }
53     
54     
55     //1.初始化name成员变量值的1参构造方法
56     public Student(String name) {
57         this.name = name;
58         System.out.println("1.使用了1参的构造方法Student(String name) ");
59     }
60     //2.初始化name 和 sno两个成员变量值的2参构造方法
61     public Student(String name, int sno) {
62         this.name = name;
63         this.sno = sno;
64         System.out.println("2.使用了2参的构造方法Student(String name, int sno) ");
65     }
66     //3.初始化name，age，isFimale三个成员变量值的3参构造方法
67     public Student(String name, int age, boolean isMale) {
68         this.name = name;
69         this.age = age;
70         this.isMale = isMale;
71         System.out.println("3.使用了3参的构造方法Student(String name, int age, boolean isMale) ");
72     }
73     //4.初始化name，age， isMale，sno这4个成员变量值的4参构造方法
74     public Student(String name, int age, boolean isMale, int sno) {
75         this.name = name;
76         this.age = age;
77         this.isMale = isMale;
78         this.sno = sno;
79         System.out.println("4.使用了4参的构造方法Student(String name, int age, boolean isMale, int sno )");
80     }
81     
82     
83     //c.定义成员方法
84     public void print() {
85         System.out.println(this.name+"调用print()成员方法");
86         System.out.println(name +" "+age+" "+(isMale ? "男" : "女")+" "+sno);
87     }
88     
89     
90 }

运行结果：

 

 2.

 1 package com.day008;
 2 /*
 3  * 2. 在第一题的基础上，创建两个Student对象分别为stu1和stu2
 4    要求stu1对象的四个成员变量name, age, isMale, sno的值分别为“张三”,18,true, 1
 5    要求stu2对象的四个成员变量name, age, isMale, sno的值分别为“李四”,25,false, 2
 6    然后在两个对象上调用print()方法即 
 7    stu1.print(), stu2.print(),两次调用方法输出的结果相同吗？
 8    为什么？(提示：在方法体中访问name成员变量，直接用成员变量名name，是this.name的简写形式)
 9  */
10 public class Demo2 {
11     public static void main(String[] args) {
12         Student stu1 = new Student("张三",18,true,1);
13         Student stu2 = new Student("李四",25,false,2);
14         stu1.print();
15         stu2.print();
16     }
17     
18 }

运行结果：

 

 原因：

a.在不同对象上调用print方法打印出的结果不同。

b.在stu1对象上调用print()方法，打印的结果是stu1对象的成员变量的值

   在stu2对象上调用print()方法，打印的结果是stu2对象的成员变量的值

c.之所以出现这样的结果，是因为在代码中输出name等成员变量的值，其实相当于，访问的是this.name, this.age, this.isMale, this.sno

   又因为，this代表的是当前对象，即在哪个对象上访问成员方法print(),  print()方法中的this就代表哪个对象，因此，在两个不同对象上调用print（）方法，访问到达分别是两个不同对象的成员变量的值。

3.

 1 public class MyStudent {
 2 
 3     String name;
 4     int age;
 5     boolean isFemale;
 6     int sno;
 7 
 8     /*
 9      * 无参构造方法
10      */
11     public MyStudent() {
12         // 这里两种实现方式
13         // 第一种，最简单的方式，即直接在无参构造方法中调用4参构造方法给对象的成员变量
14         // 赋予自己规定的初值
15         // this("麻花疼", 100, true, 1000);
16 
17         // 第二种方式，这几个构造方法的层层调用
18         // 无参调用——>1参构造——》2参构造——》3参构造 -》4参构造
19         this("麻花疼");
20 
21     }
22 
23     /*
24      * 一参构造方法用来初始化name成员变量的值
25      */
26     public MyStudent(String name) {
27         this(name, 1000);
28     }
29 
30     /*
31      * 两参构造方法用来初始化name和sno成员变量的值
32      */
33     public MyStudent(String name, int sno) {
34         this(name, 100, sno);
35     }
36 
37     /*
38      * 三参构造方法用来初始化name，age和isFemale成员变量的值
39      */
40     public MyStudent(String name, int age, int sno) {
41         this(name, age, true, sno);
42     }
43 
44     /*
45      * 四参构造方法用来初始化name，age和isFemale和sno成员变量的值
46      */
47     public MyStudent(String name, int age, boolean isFemale, int sno) {
48         this.name = name;
49         this.age = age;
50         this.isFemale = isFemale;
51         this.sno = sno;
52     }
53 
54     public void print() {
55         System.out.println(name + "---" + age + "---" + (isFemale ? "男" : "女") + "---" + sno);
56     }
57 
58 }

 

笨办法：

 1 package com.day008;
 2 /*
 3  * 3. 在定义类MyStudent(类中定义的成员变量和成员方法同Student，
 4    同时在MyStudent类中定义和Student相似的5个构造方法)的基础上，
 5    根据需要修改MyStudent相应构造方法的方法体，要求实现
 6       MyStudent st = new MyStudent();
 7       st.print();
 8 这两句代码打印出的结果是 麻花疼---100---男---1000
 9 
10  */
11 public class Demo3 {
12     public static void main(String[] args) {
13         MyStudent st = new MyStudent();
14         st.print();
15     }
16 }
17 class MyStudent{
18     //a.定义4个成员变量
19     String name;
20     int age;
21     boolean isMale;
22     int sno;
23     
24     //分别定义5个构造方法 
25     //0.定义无参构造
26     public MyStudent() {
27         this("马化腾",100,true,1000);
28         //System.out.println("0.使用了无参的构造方法Student() ");
29     }
30     
31     
32     //1.初始化name成员变量值的1参构造方法
33     public MyStudent(String name) {
34         this.name = name;
35         //System.out.println("1.使用了1参的构造方法Student(String name) ");
36     }
37     //2.初始化name 和 sno两个成员变量值的2参构造方法
38     public MyStudent(String name, int sno) {
39         this.name = name;
40         this.sno = sno;
41         System.out.println("2.使用了2参的构造方法Student(String name, int sno) ");
42     }
43     //3.初始化name，age，isFimale三个成员变量值的3参构造方法
44     public MyStudent(String name, int age, boolean isMale) {
45         this.name = name;
46         this.age = age;
47         this.isMale = isMale;
48         System.out.println("3.使用了3参的构造方法Student(String name, int age, boolean isMale) ");
49     }
50     //4.初始化name，age， isMale，sno这4个成员变量值的4参构造方法
51     public MyStudent(String name, int age, boolean isMale, int sno) {
52         this.name = name;
53         this.age = age;
54         this.isMale = isMale;
55         this.sno = sno;
56         //System.out.println("4.使用了4参的构造方法Student(String name, int age, boolean isMale, int sno )");
57     }
58     
59     
60     //c.定义成员方法
61     public void print() {
62         //System.out.println(this.name+"调用print()成员方法");
63         System.out.println(name +"--"+age+"--"+(isMale ? "男" : "女")+"--"+sno);
64     }
65     
66     
67 }

运行结果：

 

 

 4.

 1 package com.day008;
 2 /*
 3  * 如图所示，分别将一个double类型的数据和一个引用类型的数据传入某个方法，
 4  * 在方法内分别对对应的数据进行一些运算 ，经过运算之后，
 5  * double类型的数据和引用类型的数据分别是什么? 并解释下，为什么
 6  */
 7 public class Demo4 {
 8     public static void main(String[] args) {
 9         Person p = new Person();
10         p.name = "我是马化腾";
11         p.age = 50;
12         PersonTest(p);
13         double money = 100;
14         doubleTest(money);
15         System.out.println("方法执行后的money："+money);
16         System.out.println("方法执行后的name:"+p.name);
17     }
18     private static void doubleTest(double money) {
19         money = 200;
20     }
21     public static void PersonTest(Person person) {
22         System.out.println("传入的person的name："+person.name);
23         person.name = "我是马云";
24         System.out.println("方法内重新赋值后的name:"+person.name);
25     }
26 }
27 class Person{
28     String name;
29     int age;
30 }

 

运行结果：

          

 

 原因：

　　a. PersonTest(Person person)方法接受的是引用数据类型的参数，该引用类型的参数值，在调用方法和被调用方法中各有一份，但是两个参数对应的数据只有一份，即两个引用变量的值指向的是同一个对象，而方法体中，修改的同一个对象的成员变量值，所有在方法执行完之后，通过实际参数的引用值，访问同一个对象，所有访问到的是对象成员变量被修改后的值

　　b.  对于doubleTest(double money)方法而言，接收的是基本数据类型的参数，参数值在调用方法（main方法）和被调用方法（doubleTest方法）中各有一份，所以，在被调用方法体中，修改的其实只是被调用方法中那一份形式参数的值，所以在方法执行完之后，实际参数的值并未被修改。

posted @ 2020-04-19 12:40  dust--  阅读(369)  评论(0)  编辑  收藏  举报