类和对象的总结（2）

类和对象的总结（2）
类的组成部分：属性、方法。
其中，方法包括：1.普通方法
2.构造方法

一、构造方法
1.构造方法的格式：

public 类名（数据类型 参数名，…）{
//代码
}

2.实例化对象的格式：

类名 对象=new 类名（）；//实例化不带参数的构造方法
类名 对象=new 类名（参数值，…）；//实例化带参数的构造方法

3.用途： a.实例化对象
b．为对象赋初始值

N.B：Java会给每一个类提供一个默认的构造方法。但如果你在类中定义了构造方法，则只能使用你自己定义的构造方法。


二、方法重载
1.条件：a..方法名必须要相同
b．方法所带的参数类型、参数个数、参数顺序至少有一个不同。

2.调用：传入的参数和哪个方法定义时的参数相配，则调用对应的方法。
exp: //定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了，血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了，血量仅剩"+blood+"滴");
}
}


三、this关键字

1.this表示当前调用方法的对象

2.this可以调用当前对象的属性值,exp:
public Student(String name){
this.name=name;
}
//这里的name值为”属性name”的值，这里是将name值赋给”this.name”,而这里的name值可以来自主函数的实例化对象，exp: Student stu=new Student(“becky”);

也可以调用另一个构造器.exp:
public Student(){
this(“未知名字”，”Java”,0);
}
//补充：当实例化对象无参数时，构造方法中的参数的值将不会成为实例化对象的初始值。//exp:Student stu=new Student();//此时无参数调入其中。//

public Student(String name,String km,int scro){
this.name=name;//这里的name=”未知名字”
this.km=km;//这里的km=”Java”
this.scro=scro;//这里的scro=0
}
N.B：在构造器中，可以调用构造器，也可以调用方法；但在一般方法中，不能调用构造器。


四、值传递

1.值传递：Java八大基本类型和String类型遵循“值传递”规则。

2.关于地址存储地：
1） exp: //主函数中
int i=100;
…….

stu.score(i);
//这里的i的地址存储在内存的栈中，在主函数结束后才会自行销毁，释放内存空间。//主函数中的i值不会受到类中s值变化的影响

2） exp: //类中
public void score(int s){
…..
s++;
…….
}//这里的s的地址存储在内存的栈中，用完后便会自动销毁，释放内存空间


五、引用传递

1.引用传递适用于Java的引用数据类型(对象类型、类类型)。
其中，引用数据类型包含：数组、类、接口、抽象类。

2.引用传递的方式：a.对象所带有的值存在堆里，对象的地址存在栈里，对象的地址指向对象值的首地址，从而把对象值找出来。
b.如果要将对象2的值赋给对象1，则应使对象1指向对象2的首地址，使“对象1=对象2”，最后在函数结束后，释放对象1在堆中的存储空间。

exp1: //入口函数中
Student st1 = new Student();...
st1=st2;
st2=st3;
st3=st1;

最后得到st3 = st2;

分析：
1.st1=st2 时，st1指向st2的首地址，st1的值变成st2的值。
2.st3=st1时，st3指向st1的首地址，st3 的值变成st1的值。

/*****************************************************************************/

课后练习：
回合制游戏：奥特曼和小怪兽要战斗，奥特曼还可以和Boss进行战斗，直到一方的血量为0的时候结束战斗，输出谁胜利了！

1.思路：先将游戏中的所有对象找全，再分别列出它们的特征和行为。然后为各个对象创建一个类。最后在主函数中模拟战斗场景，输出最终结果。

2.分析：
对象 特征 行为
奥特曼 姓名、血量 战斗
小怪兽 姓名、血量 战斗
Boss 姓名、血量 战斗

3.具体代码如下：
1）//定义一个超人类
public class Superman{

//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;

//定义一个带姓名参数的构造方法
public Superman(String name){
this.name="无名";
}
//重载一个不带参数的构造方法
public Superman(){
this.blood=10;
this.name="无名";

}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与怪物战斗的方法
public void fighting(Monster mon){
blood--;//血量减1
System.out.println(name+"被"+mon.getName()+"攻击了，血量仅剩"+blood+"滴");
}
//重载一个与Boss战斗的方法
public void fighting(Boss boss){
blood--;//血量减1
System.out.println(name+"被"+boss.getName()+"攻击了，血量仅剩"+blood+"滴");
}
}
2）//定义一个Monster类
public class Monster{

//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;

//定义一个带姓名参数的构造方法
public Monster(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Monster(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给属性name
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了，血量仅剩"+blood+"滴");
}
}


3）//定义一个Boss类
public class Boss{

//定义一个姓名属性
private String name;
//定义一个血量属性
private int blood;

//定义一个带姓名参数的构造方法
public Boss(String name){
this.name="无名";
}
//重载一个带血量参数的构造方法
public Boss(int blood){
this.blood=10;
}
//设置姓名属性值的方法
public void setName(String n){
name=n;//将参数n的值赋给姓名属性name
}
//获取姓名属性值的方法
public String getName(){
return name;
}
//设置血量属性值的方法
public void setBlood(int m){
blood=m;//将参数m的值赋给血量属性blood
}
//获取血量属性值的方法
public int getBlood(){
return blood;
}
//定义一个与Superman战斗的方法
public void fighting(Superman sup){
blood--;//血量减1
System.out.println(name+"被"+sup.getName()+"攻击了，血量仅剩"+blood+"滴");
}
}
4）//定义一个Fighting类
public class Fighting{

//定义程序的入口主函数
public static void main(String [] args){

//实例化一个Superman类的对象
Superman sup = new Superman();
//调用设置姓名的方法
sup.setName("奥特曼");
//调用设置血量的方法
sup.setBlood(20);

//实例化一个Monster类的对象
Monster mon = new Monster("zzz");
//调用设置姓名的方法
mon.setName("小怪兽");
//调用设置血量的方法
mon.setBlood(10);

//实例化一个Boss类的对象
Boss bo = new Boss("zzz");
//调用设置姓名的方法
bo.setName("boss");
//调用设置血量的方法
bo.setBlood(10);

//定义回合数
int i=20;
//开始进行20回合的较量，每回合奥特曼有2次攻击机会，小怪兽和boss各有一次攻击机会
while(i>0){
//调用战斗方法
sup.fighting(mon);
//调用战斗方法
sup.fighting(bo);
//调用战斗方法
mon.fighting(sup);
//调用战斗方法
bo.fighting(sup);

i--;

//将奥特曼目前的血量值赋给sblood
int sblood =sup.getBlood();
//将小怪兽目前的血量值赋给mblood
int mblood=mon.getBlood();
//将boss目前的血量值赋给bblood
int bblood=bo.getBlood();

//如果奥特曼的血量先为0，输出最终结果
if(sblood==0){
System.out.println("奥特曼战败！小怪兽和boss战胜！");
break;//跳出循环
}
//如果小怪兽的血量先为0，输出最终结果
else if(mblood==0){
System.out.println("奥特曼战胜！小怪兽和boss战败！");

break;//跳出循环
}
//如果boss的血量先为0，输出最终结果
else if(bblood==0){
System.out.println("奥特曼战胜!小怪兽和boss战败！");
break;//跳出循环
}
}
}
}

4.编码过程中应注意的一些问题：
a．在这个游戏中，构造方法可用可不用。
b．若是选择使用构造方法，则要注意：自己在主函数中实例化的对象的构造方法是否带有参数，如果带参数，那么在实例化这个构造方法的时候我们也要带上参数，
exp: 在对象的类中有： public Boss(String name){
this.name="无名";
}
则在主函数中实例化为：Monster mon = new Monster("zzz");

反之，如果不带参数，那么在实例化这个构造方法的时候我们也不必带上参数。
exp: 在对象的类中有： public Superman(){
this.blood=10;
this.name="无名";
}
则在主函数中实例化为：Superman sup = new Superman();
c．在一方血量为0时，输出结果后记得要加上“break”,跳出循环；否则战斗将继续进行。