Java学习第二周总结

• 方法
  程序里面出现了重复或相对独立的功能 ，那么应该将这些功能单独写成一个方法
  重载方法: 在一个类中可以出现同名方法 只要他们的参数列表不同就能够加以区分.
  参数列表不同指的是, 参数的类型不相同或者参数的个数不相同或者二者皆不同

• 数组 - 用一个变量保存多个同类型的值

• for-each只读循环，不能改变数组的元素
  （在for循环里面用x代表数组里的所有的值）

面向对象

• 对象是能够接收消息的实体
  特征:1.一切都是对象

2. 对象都有属性和行为
3. 每一个对象都是第一无二的
4. 对象都属于某个类

• 类:
  类是对象的蓝图和模板
  对象和对象之间可以互相发送消息就能构造出复杂的系统

• 面向对象编程的第1步 - 定义类
  数据抽象 - 属性 - 找名词
  构造器
  行为抽象 - 方法 - 找动词

• 面向对象编程第2步 - 创建对象
  new 构造器();

• 面向对象编程第3步 - 给对象发消息

• 奥特曼打小怪兽
  奥特曼类

package com.baidu;

public class Ultraman {
    private String name;
    private int hp;         //Health Point
    private int mp;
    
    public Ultraman(String name, int hp, int mp) {
        this.name = name;
        this.hp = hp;
        this.mp = mp;
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp < 0 ? 0 : hp;
    }

    public int getMp() {
        return mp;
    }

    public void setMp(int mp) {
        this.mp = mp;
    }
    public void resumeMp(){
        mp += 4;
    }

    public String info(){
        return String.format("%s奥特曼 - 生命值 : %d, 魔法值 : %d", 
                name,hp,mp);
    }
    public void attack(Monster m){
        int injury = (int) (Math.random()  * 11  + 10);
        m.setHp(m.getHp() - injury);
    }
    
    public void hugeAttack(Monster m){
        if(mp >= 40){
            int injury = m.getHp() /4 * 3 > 50 ? m.getHp() / 4 * 3 : 50;
            m.setHp(m.getHp() - injury);
            mp -= 40;
        }
        
    }
    public void magicalAttack(Monster[] mArray){
        if(mp >= 15){
            for (Monster m: mArray) {
                if(m.getHp() > 0){
                int injury = (int) (Math.random() * 5  + 15);
                m.setHp(m.getHp() - injury);
                }
            }
                mp -= 15;
        }
    }
}

怪兽类

package com.baidu;

public class Monster {
    private String name;
    private int hp;
    
    public Monster(String name, int hp) {
        this.name = name;
        this.setHp(hp);
    }
    
    public String info(){
        return String.format("%s怪兽 - 生命值 : %d ", name,getHp());
    }
    public void attack(Ultraman u){
        int injury = (int) (Math.random() * 5 + 10);
        u.setHp(u.getHp() - injury);
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp < 0 ? 0 : hp;
    }
}

测试类调用两个类实现对象

package com.baidu;

public class Test03 {
    
    public static Monster selectOne(Monster[] mArray){
        Monster temp = null;
        do {
            int randomIndex = (int) (Math.random() * mArray.length);
            temp = mArray[randomIndex];
        } while (temp.getHp() == 0);
        return temp;
    }
    
    public static void showMonstersInfo(Monster[] mArray){
        for(Monster monster : mArray){
            System.out.println(monster.info());
        }
    }
    
    public static boolean isAllDead(Monster[] mArray){
        for(Monster monster : mArray){
            if(monster.getHp() > 0){
                return false;
            }
        }
        return true;
    }
    
    public static void main(String[] args){
        Ultraman u = new Ultraman("迪迦", 1250, 50);
        System.out.println(u.info());
        Monster m1 = new Monster("白玉龙1号", 100);
        Monster m2 = new Monster("白玉龙2号", 100);
        Monster m3 = new Monster("白玉龙3号", 100);
        Monster m4 = new Monster("白玉龙4号", 100);
        Monster[] mArray = {m1,m2,m3,m4};
        showMonstersInfo(mArray);
        int round = 1;
        do{
            System.out.println("=======第" + round + "回合=======");
            int random = (int) (Math.random() * 10 + 1);
            Monster m = selectOne(mArray);
            if(random <= 7){
                usNormalAttack(u, m);
            }
            else if(random <= 9){
                if (u.getMp() >= 15) {
                    System.out.println("奥特曼使用了魔法攻击");
                    u.magicalAttack(mArray);
                    for (Monster monster : mArray) {
                        if (monster.getHp() > 0) {
                            monster.attack(u);
                        }
                    } 
                }
                else{
                    usNormalAttack(u, m);
                }
            }
            else {
                if(u.getMp() >= 40){
                System.out.println("奥特曼使用了终极攻击");
                u.hugeAttack(m);
                if(m.getHp() > 0){
                    m.attack(u);
                }
                }
                else{
                    usNormalAttack(u, m);               
                }
            }
            if(u.getHp() > 0){
                u.resumeMp();
            }
            round += 1;
            System.out.println(u.info());
            showMonstersInfo(mArray);
        }while(u.getHp() > 0 && !isAllDead(mArray));
        if(u.getHp() > 0){
            System.out.println("奥特曼胜利！！！");
        }
        else{
            System.out.println("小怪兽胜利！！！");
        }
    }

    public static void usNormalAttack(Ultraman u, Monster m) {
        System.out.println("奥特曼使用了普通攻击");
        u.attack(m);
        if(m.getHp() > 0){
            m.attack(u);
        }
    }
}