类和对象的总结（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”,跳出循环；否则战斗将继续进行。