第十三天（封装构造函数）

最新推荐文章于 2024-12-08 19:40:55 发布

原创最新推荐文章于 2024-12-08 19:40:55 发布 · 2.1k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

第一阶段同时被 2 个专栏收录

15 篇文章

订阅专栏

JAVA学习

14 篇文章

订阅专栏

本文探讨了面向对象编程中的封装概念，并通过创建学生类为例进行说明。介绍了如何通过封装实现学生信息的输出，同时阐述了封装的优点。此外，文章还对比了构造函数与一般函数的区别，并详细讲解了`this`关键字的功能及其在实际应用中的三种场景。

1、chap5中6-14题，15题选做

6>（构造函数）有以下代码 class MyClass{

int value;

}

public class TestMyClass{

public static void main(String args[]){ MyClass mc1 = new MyClass(); MyClass mc2 = new MyClass(10); System.out.println(mc1.value); System.out.println(mc2.value);

}

问：这个程序能否编译通过？如果可以，输出结果是什么？如果不可以，则应该如何修改？

编译不通过，修改方式有两种：

1）不修改主方法：在MyClass类中添加两个构造方法，

一个是无参构造方法：public MyClass(){}

一个是有一个int类型参数的构造方法：public MyClass(int x){}

2）不修改MyClass类：在主方法中删掉

“MyClassmc2 = new MyClass(10);”和“System.out.println(mc2.value);”

7>（面向对象基础）根据注释，把下面代码补充完整

//定义一个Dog 类 class Dog{

//定义一个name 属性，该属性为String 类型

______________________; //定义一个age 属性，该属性为int 类型

______________________; //定义一个sexual 属性，该属性为boolean 类型 //true 表示为公，false 表示为母

______________________; public Dog(){}

public Dog(String name, int age, boolean sexual){

//分别根据参数，设置Dog 类的属性

}

public void play(){ System.out.println(name + “ play”);

}

public void play(int n){

System.out.println(name + “ play ” + n + “ minutes”);

}

public class TestDog{

public static void main(String args[]){ Dog d; //创建一个Dog 对象，利用带参数的构造函数

//名字为joy，年龄为2 岁，性别为母

_________________; //调用Dog 对象无参的play 方法。

_________________; //调用Dog 对象有参的play 方法，参数为30

_________________;

}

class Dog{
        public String name;//定义一个name 属性，该属性为String 类型
        public int age;//定义一个age 属性，该属性为int 类型
        //定义一个sexual 属性，该属性为boolean 类型，true 表示为公，false 表示为母
        public boolean sexual;
        public Dog(){}
        public Dog(String name, int age, boolean sexual){
                this.name = name;
                this.age = age;
                this.sexual = sexual;
        }
        public void play(){ 
                System.out.println(name + "play");
        }
        public void play(int n){
                System.out.println(name + "play" + n + "minutes");
        }
}
 
public class TestDog{
        public static void main(String args[]){
                /**
                 * 创建一个Dog 对象，利用带参数的构造函数
                 * 名字为joy，年龄为2 岁，性别为母
                 */
                Dog d = new Dog("joy",2,false); 
                d.play(); //调用Dog 对象无参的play 方法。
                d.play(10); //调用Dog 对象有参的play 方法，参数为30
        }
}

8>（对象创建过程）有以下代码 class ClassA{

public ClassA(){ System.out.println("ClassA()");

}

class ClassB{ public ClassB(){

System.out.println("ClassB()");

}

class ClassC{

ClassA a = new ClassA(); ClassB b;

public ClassC(){ System.out.println("ClassC()"); b = new ClassB();

}

public class TestConstructor{

public static void main(String args[]){ ClassC cc = new ClassC();

}

请选择正确答案：

A. 编译不通过

B. 输出ClassA() ClassB() ClassC()

C. 输出 ClassA() ClassC() ClassB()

D. 输出 ClassC() ClassB() ClassA()

答案：C

9>（引用，方法参数传递）有以下代码

class ClassA{

int value;

}

public class TestClassA{

public static void main(String args[]){ int value = 10;

changeInt(value);

System.out.println(value); ClassA ca = new ClassA(); ca.value = 10; changeObject(ca); System.out.println(ca.value);

}

public static void changeInt(int value){ value++;

}

public static void changeObject(ClassA ca){ ca.value++;

}

编译运行TestClassA 时，结果是

A. 编译出错

B. 输出 10 10

C. 输出 10 11

D. 输出 11 11

答案：C

10> *（构造函数，this 关键字）程序改错

public class Student{

public void Student(){} void init(){

age = 10; name = "limy";

}

public Student(String name){

this.init();

this.name = name;

}

public Student(String name, int age){ this.init();

this(name); this.age = age;

}

int age; String name;

}

public class Student {
        int age;
        String name;
        public Student() {}//构造函数不能有返回值
 
        void init() {
                age = 10;
                name = "limy";
        }
 
        public Student(String name) {
                this.init();
                this.name = name;
        }
 
        public Student(String name, int age) {
                this(name);//this语句放在第一行
                this.init();
                this.age = age;
        }
}

11>（面向对象基础）写一个Worker 类，并创建多个Worker 对象。

1) 为Worker 类添加三个属性，1）String 类型的name，表示工人的姓名；2）int 类型的age，表示工人的年龄；3）double 类型的salary，表示工人

的工资。

2) 为Worker 类添加两个构造方法，1）公开无参构造方法；2）接受三个参数的构造方法，三个参数分别为字符串、int 和double 类型。

3) 为Worker 类添加两个work 方法，一个无参，另一个带整数参数，表示工人工作的时间（为多少小时）。

public class Worker{
        public String name;//姓名
        public int age;//年龄
        public double salary;//工资
         
        public Worker() {}//无参构造方法
 
        public Worker(String name, int age, double salary) {
                this.name = name;
                this.age = age;
                this.salary = salary;
        }
         
        public void work(){
                System.out.println("我是无参的work方法");
        }
         
        public void work(int time){
                System.out.println("我是带有一个参数的work方法");
        }
         
        public static void main(String[] args) {
                 
        }
}

12>（面向对象基础）创建一个Address 类，描述如下：

1）该类有两个属性，1）String 类型的address，表示地址；2）String 类型的zipCode，表示邮编。

2）该类有两个构造方法，一为无参构造方法，一为带二个参数的方法。类图如下：

public class Address{
        public String address;//地址
        public String zipCode;//邮编
 
        public Address() {}//无参构造方法
 
        public Address(String address, String zipCode) {
                this.address = address;
                this.zipCode = zipCode;
        }
 
        public static void main(String[] args) {
                 
        }
}

13>*（面向对象基础）为第1 题中的Worker 类添加一个属性addr，该属性为Address 类型。

创建一个Worker 对象，其姓名为"zhangsan"，年龄为25，工资为2500，家庭住址为“北京市海淀区清华园1 号”，邮政编码为100084。

public class Worker {
 
        public String name;//姓名
        public int age;//年龄
        public double salary;//工资
        public Address addr;//地址
         
        public Worker() {}//无参构造方法
 
        public Worker(String name, int age, double salary) {
                this.name = name;
                this.age = age;
                this.salary = salary;
        }
         
        public Worker(String name, int age, double salary, Address addr) {
                super();
                this.name = name;
                this.age = age;
                this.salary = salary;
                this.addr = addr;
        }
 
        public void work(){
                System.out.println("我是无参的work方法");
        }
         
        public void work(int time){
                System.out.println("我是带有一个参数的work方法");
        }
 
        @Override
        public String toString() {
                //注意：addr.toString()要用到Address类中的toString()方法
return "Worker [name=" + name + ", age=" + age + ", salary=" + salary + ", " + addr.toString() + "]";
        }
 
        public static void main(String[] args) {
                Worker worker = new Worker("zhangsan",25,2500,
new Address("北京市海淀区清华园1 号", "100084"));
                System.out.println(worker.toString());
        }
}

14>**（引用，方法参数传递）有以下代码

class ClassA{

int value;

}

public class ChangeRef{

public static void main(String args[]){ ClassA ca = new ClassA(); changeValue(ca); System.out.println(ca.value); changeRef(ca); System.out.println(ca.value);

}

public static void changeValue(ClassA ca){

ca.value = 100;

}

public static void changeRef(ClassA ca){

ca = new ClassA();

ca.value = 200;

}

编译运行ChangeRef，结果为

A. 编译不通过

B. 输出100 200

C. 输出100 100

D. 输出0 200

面向对象的理解并举例
eg：创建一个学生类，有学习、跑步相关方法

   姓名、性别、年龄相关属性

要求:

   1、通过封装方式实现学生信息的输出

   2、归纳总结封装的优点

public class Student {
 
    private String name;//姓名
    private String sex;//性別
    private int age;//年齡
     
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
     
    public String study(){
        return "我喜欢Java编程。";
    }
     
    public String play(){
        return "我也喜欢锻炼身体。";
    }
     
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("Jack");
        s.setSex("Man");
        s.setAge(20);
        System.out.println(s.getName()+"\t"+s.getSex()+"\t"+s.getAge()+
"\t"+s.study()+"\t"+s.play());
    }
}
2）封装的优点
   1、将变化隔离
    2、便于使用
    3、提高重用性
4、提高安全性

3、详细写出成员变量和局部变量的区别

成员变量和局部变量的区别：

成员变量：

①成员变量定义在类中，在整个类中都可以被访问。

②成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

③成员变量有默认初始化值。

局部变量：

①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

②局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

③局部变量没有默认初始化值

4、列出构造函数和一般函数的区别

普通函数和构造函数的区别：

1、普通函数主要用来定义功能独立代码段

构造函数主要用来初始化对象

2、普通函数有返回值类型，如果没有用void代替

构造函数没有返回值类型修饰符类名（参数列表）{}

3、普通函数可以进行多次调用

构造函数只在初始化对象的时候调用，调用一次即可

4、普通函数可以实现递归

构造函数不能用在递归

5、普通函数主函数调用，也可以嵌套调用

构造函数有jvm调用

5、this关键字的特点以及三种应用场景，举例说明

public class Demo05 {
 
        private String name;
        private String password;
 
        public Demo05(String name, String password) {
                this();// 2、在本类中，在构造函数调用其他构造函数
                this.name = name;
                this.password = password;
        }
 
        public Demo05(String name) {
                this.name = name;// 1、在构造方法中调用类变量信息
        }
 
        public Demo05() {
 
        }
 
        public void study() {
                System.out.println("study");
        }
 
        public void run() {
                study();// 3、调用同类中其他的函数信息，这时候this可以省略不写
                System.out.println("run");
        }
}

6、(选做)需求：使用java定义一个人类，人具备 id、name 、 age三个属性，

还具备一个比较年龄的方法。

要求：必须要写上构造函数，构造函数也必须要使用上this关键字。

public class Person {
        private int id;
        private int age;
        private String name;
         
        public Person() {}
         
        public Person(int id) {
                this.id = id;
        }
 
        public Person(int id, int age) {
                this(id);
                this.age = age;
        }
 
        public Person(int id, int age, String name) {
                this(id,age);
                this.name = name;
                 
        }
 
        public int getId() {
                return id;
        }
 
        public void setId(int id) {
                this.id = id;
        }
 
        public int getAge() {
                return age;
        }
 
        public void setAge(int age) {
                this.age = age;
        }
 
        public String getName() {
                return name;
        }
 
        public void setName(String name) {
                this.name = name;
        }
 
        public void getAge(Person p1, Person p2){
                if(("".equals(p1.getName().trim()) || p1.getName()==null) || ("".equals(p2.getName().trim()) || p2.getName()==null)){
                        System.out.println("姓名不能為空!");
                }
                else{
                        if(p1.getAge()>p2.getAge()){
                                System.out.println(p1.getName()+"的年齡大一些！");
                        }
                        else if(p1.getAge()==p2.getAge()){
                                System.out.println("年齡相等！");
                        }
                        else{
                                System.out.println(p2.getName()+"的年齡大一些！");
                        }
                }
        }
}