零基础学JAVA DAY8

 今天周一，昨天周日啥也没干睡了一天的觉，嘿嘿，就不写了。今天没什么特别的，学习了一下JAVA的基础知识，也快学完了呢。哎，还是烦，到底啥时候能帮上忙呢，菜的抠脚啊，坐着干着急可不行。在公司里坐着总想摸鱼，也是因为太闲了？哈哈哈，给点事情做就好了。就这样，准备睡觉了，困死。对了，那个谁还说单位给介绍对象，有点酸啊，危机感来了。好好学然后跳回家吧，不然啥也捞不着了

类的多态条件
要实现类的多态，需要如下条件
父类（接口）引用指向子类
对象调用的方法有重写

package charactor;

import Interface.Mortal;

/**
 * 1. 设计一个接口
 * 接口叫做Mortal,其中有一个方法叫做die
 * 2. 实现接口
 * 分别让ADHero,APHero,ADAPHero这三个类，实现Mortal接口，不同的类实现die方法的时候，都打印出不一样的字符串
 * 3. 为Hero类，添加一个方法,在这个方法中调用 m的die方法。
 *
 * public void kill(Mortal m)
 *
 *
 * 4. 在主方法中
 * 首先实例化出一个Hero对象:盖伦
 * 然后实例化出3个对象，分别是ADHero,APHero,ADAPHero的实例
 * 然后让盖伦 kill 这3个对象
 */
public class Hero{
    public static void main(String[] args) {
        Hero garen = new Hero();
        Mortal hero1 = new ADHero();
        garen.kill(hero1);
        Mortal hero2 = new APHero();
        garen.kill(hero2);
        Mortal hero3 = new ADAPHero();
        garen.kill(hero3);

    }
    public void kill(Mortal m){
        m.die();
    }
}

Hero h =new ADHero();

h.battleWin(); //battleWin是一个类方法
h是父类类型的引用
但是指向一个子类对象
h.battleWin(); 会调用父类的方法？还是子类的方法？
调用父类的方法

super关键字的应用

Hero.java
package charactor;

import property.Item;

public class Hero{
    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public void useItem(Item i){
        System.out.println("hero use item");
        i.effect();
    }

    public Hero(){
        System.out.println("Hero的无参的构造方法 ");
    }

    public Hero(String name){
        System.out.println("Hero的有一个参数的构造方法 ");
        this.name = name;
    }

    public static void main(String[] args) {
        new Hero();
    }
}

ADHero.java
package charactor;

import Interface.AD;
import Interface.Mortal;

public class ADHero extends Hero implements AD , Mortal {

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    @Override
    public void die() {
        System.out.println("ADHero died");
    }

    public ADHero(String name) {
        //super显式调用父类带参的构造方法，将Hero中的name调用了
        //创建子类对象时，默认会先调用父类无参的构造方法
        //可以通过super关键字指定调用父类的构造方法
        super(name);
        System.out.println("AD Hero的构造方法");
    }
    public static void main(String[] args) {
        new ADHero("tan jin ji");
    }

}

/**
 * 测试this关键字的作用，当我们new一个动物cat时，让cat去调用eat方法，结果显示的却是老鼠在吃；
 * 也就是说当存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量，
 * 那是因为Java采取的是就近原则访问的，要解决这个问题就需要使用this关键字；
 */
public class JudgeIsLeapYear {
    public static void main(String[] args) {
        //此时在内存中存在两份name数据
        Animal dog = new Animal("狗","白色");
        Animal cat = new Animal("猫","黑色");
        cat.eat();

    }

}
class Animal {
    String name;
    String color;

    public Animal(String n, String c) {
        name = n;
        color = c;
    }

    public void eat() {
        String name = "老鼠";
        //this关键字代表了所属函数的调用者对象
        System.out.println(this.name + "在吃……");
    }
}

package charactor;

import Interface.AD;

/**
 * 通过super调用父类的moveSpeed属性
 * ADHero也提供了属性moveSpeed
 */
public class ADHero extends Hero implements AD {

    int moveSpeed=400; //移动速度

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    public int getMoveSpeed(){
        return this.moveSpeed;
    }

    public int getMoveSpeed2(){
        return super.moveSpeed;
    }

    public static void main(String[] args) {
        ADHero h = new ADHero();

        System.out.println(h.getMoveSpeed());
        System.out.println(h.getMoveSpeed2());

    }
}

    public boolean equals(Object o){
        //instanceof关键字表示判断o是不是Hero类型
        if(o instanceof Hero){
            //对象转型，将Object类型的引用o转型为Hero类型，h也指向了o所指向的对象
            Hero h = (Hero) o;
            //this关键字指向当前对象，判断当前对象o的hp是否和h的hp相等
            return this.hp == h.hp;
        }
        return false;
    }

抽象类和接口的区别
区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public 静态 final的
即便没有显式的声明

抽象类和接口都可以有实体方法。接口中的实体方法，叫做默认方法

非静态内部类 BattleScore “战斗成绩”
非静态内部类可以直接在一个类里面定义
战斗成绩只有在一个英雄对象存在的时候才有意义
所以实例化BattleScore 的时候，必须建立在一个存在的英雄的基础上
语法: new 外部类().new 内部类()
作为Hero的非静态内部类，是可以直接访问外部类的private实例属性name的

package charactor;

public class Hero {
    private String name; // 姓名

    float hp; // 血量

    float armor; // 护甲

    int moveSpeed; // 移动速度

    // 非静态内部类，只有一个外部类对象存在的时候，才有意义
    // 战斗成绩只有在一个英雄对象存在的时候才有意义
    class BattleScore {
        int kill;
        int die;
        int assit;

        public void legendary() {
            if (kill >= 8)
                System.out.println(name + "超神！");
            else
                System.out.println(name + "尚未超神！");
        }
    }

    public static void main(String[] args) {
        Hero garen = new Hero();
        garen.name = "盖伦";
        // 实例化内部类
        // BattleScore对象只有在一个英雄对象存在的时候才有意义
        // 所以其实例化必须建立在一个外部类对象的基础之上
        BattleScore score = garen.new BattleScore();
        score.kill = 9;
        score.legendary();
    }
}

package charactor;

public abstract class Hero {
    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public abstract void attack();

    public static void main(String[] args) {

        ADHero adh=new ADHero();
        //通过打印adh，可以看到adh这个对象属于ADHero类
        adh.attack();
        System.out.println(adh);
        //匿名类，实例化一个抽象类
        Hero h = new Hero() {
            //当场实现抽象方法
            @Override
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };
        h.attack();
        //通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名

        System.out.println(h);
    }
}