第十三天（封装 构造函数）
1、chap5中6-14题，15题选做
C
3、详细写出成员变量和局部变量的区别
6、(选做)需求： 使用java定义一个人类，人具备 id、name 、 age三个属性，
还具备一个比较年龄的方法。
要求： 必须 要 写上构造函数，构造函数也必须要使用上this关键字。
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()+"的年齡大一些！");
}
}
}
}