第三次总结（构造方法及方法重载）

第三次总结

概念：

类的组成：

1.属性；

2.方法：1）普通方法2）构造方法

 

构造方法：

public 类名 (数据类型 参数名...) { 代码... }

 

    在没写构造方法的类中，java会默认生成一个无参的构造方法。若自己定义构造方法，则默认的构造方法会被覆盖。

 

方法重载：

同名的方法，根据参数的个数、类型、顺序来加以区分。

 

 

实例化对象：

类名 对象名= new 类名(参数值...);

等号左边的对象名存在内存的栈中，该对象的属性和方法则在堆中开辟空间存储。

 

 

栈 堆

————————————

对象名 属性、方法（首地址123）

123

 

引用传递：

引用传递适用于Java的引用数据类型(对象类型、类类型)。

（引用数据类型包含：数组、类、接口、抽象类。）

    传递方式为传址（所在堆内存的首地址）。

 

 

值传递：

值传递适用于Java的八大基本数据类型和String类型。

传递方法为传值。

 

练习

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

1.找出这个场景中的对象

2.找出每一个对象的特征和行为

3.根据类的格式和对象的特性与行为定义一个class 

4.定义主函数的类，实例化对象和调用方法

 

思路：

根据前一次的练习进行改动。

    首先新建一个Boss类，与Monster类相似。

Ultraman类中有表战斗的fight(int n ,Monster m)方法，涉及到Monster类型的一个参数。若要奥特曼还能够和Boss类型的对象战斗，则须重载该方法。方法名相同，参数类型不同的新方法fight(int n,Boss b)。

在主函数类中分别调用两个fight()方法。

 

※※※※※※※※※Monster类※※※※※※※※※

 

public class Monster {

private int blood ;

public Monster(){blood=1000;}//自定无参的构造方法，覆盖默认的

public void setBlood(int de){//单次掉血

this.blood = this.blood-de;

}

public int getblood(){return blood;}

public void fight(int n,Ultraman u){

switch(n){

case 48:

 

System.out.println("小怪兽Miss..      奥特曼血槽

："+u.getblood());

break;

case 49:

u.setBlood(10);

System.out.println("小怪兽给了奥特曼一击,伤害10

！      奥特曼血槽："+u.getblood());

break;

case 50:

u.setBlood(20);

System.out.println("小怪兽给了奥特曼一！！暴击！

！伤害20！！！      奥特曼血槽："+u.getblood());

break;

}

}

}

 

※※※※※※※※※同理的Boss类※※※※※※※※※

 

public class Boss{

 

private int blood =5000;

public void setBlood(int de){

this.blood = this.blood-de;

}

public int getblood(){return blood;}

public void fight(int n,Ultraman u){

switch(n){

case 48:

 

System.out.println("Boss Miss..      奥特曼血槽："+u.getblood());

break;

case 49:

u.setBlood(200);

System.out.println("Boss给了奥特曼一击,伤害100！      奥特曼血槽："+u.getblood());

break;

case 50:

u.setBlood(400);

System.out.println("Boss给了奥特曼一！！暴击！！伤害200！！！      奥特曼血槽："+u.getblood());

break;

}

}

}

 

 

※※※※※※※※※Ultraman类※※※※※※※※※

public class Ultraman {

public Ultraman(int blood){

this.blood=blood;

System.out.println("这只奥特曼的初始血量为："+this.blood);

}

 

private int blood;

 

public void setBlood(int de){

this.blood = this.blood-de;

}

public int getblood(){return blood;}

 

//定义一个表示攻击动作的方法fight(),由于攻击对象为小怪兽，故一个参数为Monster类型的；另一个参数表示攻击掉血的随机值

 

public void fight(int n,Monster m){

switch(n){

case 48://此处考虑到char类型的0，1，2分别对应int类型的48,49,50

 

System.out.println("奥特曼Miss..      小怪兽血槽："+m.getblood());

break;

case 49:

m.setBlood(100);

System.out.println("奥特曼给了小怪兽一击,伤害100！      小怪兽血槽："+m.getblood());

break;

case 50:

m.setBlood(200);

System.out.println("奥特曼给了小怪兽一！！暴击！！伤害200！！！      小怪兽血槽："+m.getblood());

break;

}

}

 

//重载fight函数，参数为Boss类型

public void fight(int n,Boss b){

switch(n){

case 48:

System.out.println("奥特曼Miss..      Boss血槽："+b.getblood());

break;

case 49:

b.setBlood(50);

System.out.println("奥特曼给了Boss一击,伤害50！      Boss血槽："+b.getblood());

break;

case 50:

b.setBlood(100);

System.out.println("奥特曼给了Boss一！！暴击！！伤害100！！！      Boss血槽："+b.getblood());

break;

}

}

}

 

※※※※※※※※※主函数类※※※※※※※※※

 

public class Game{

public static void main(String [] args){

Ultraman jack=new Ultraman(2000);//定义一个奥特曼类型的对象jack,赋以初始血量

Monster rose=new Monster();//再定义一个怪兽类型的对象rose..

Boss bb=new Boss();//再定义一个怪兽类型的对象bb

 

String s="1012111201112111111111211111";//以一个字符串模拟随机的

格斗状态

for(int i=0;i<s.length();i++){

 

if(jack.getblood() > 0 && rose.getblood() > 0){

if((i % 2 )== 0){

jack.fight((int)s.charAt(i),rose);}

else{

rose.fight((int)s.charAt(i),jack);}

}

}

if(jack.getblood() <= 0){System.out.println("奥特曼挂了，小怪兽

胜利%>_<%");}

if(rose.getblood() <= 0){System.out.println("小怪兽挂了，奥特曼

胜利O(∩_∩)O");}

 

 

for(int i=0;i<s.length();i++){

if(jack.getblood() > 0 && bb.getblood() > 0){

if((i % 2 )== 0){

jack.fight((int)s.charAt(i),bb);}

else{

bb.fight((int)s.charAt(i),jack);}

}

}

if(jack.getblood() <= 0){System.out.println("奥特曼挂了，Boss胜

利%>_<%");}

if(bb.getblood() <= 0){System.out.println("Boss挂了，奥特曼胜利

O(∩_∩)O");}

 

 

}

 

}

 

<!--EndFragment-->