类和对象

一-

类：class 

比如Hero是一个类

对象：new Hero（）即创建了一个新对象，指向同一个类Hero

Hero h = new Hero();也就是将h指向这个新创建的对象

//创建一个对象

        new Hero();

         

        //使用一个引用来指向这个对象

        Hero h = new Hero();

操作过程是这样的，先创建对象，然后再指向于h

不同时间点写new Hero（），指向的对象并不相同

那么同一时间点的创建的那个对象是固定的，这样我创建一个后，拿无数个去指向都是一样的

比如

Hero h1 = new Hero();

        Hero h2 = h1;  //h2指向h1所指向的对象

        Hero h3 = h1;

        Hero h4 = h1;

        Hero h5 = h4;

         

        //h1,h2,h3,h4,h5 五个引用，都指向同一个对象

         

Hero garen =  new Hero();

           garen =  new Hero();

但这样，garen指向的对象就从对象一变成了对象二

Hero h1 =  new Hero();

           Hero h2 =  new Hero();

           Hero h3;

           Hero h4;

           h3 = h1;

           h4 = h3;

上列h1，3，4是一样的，都指向对象一

二-

继承

一个class的类会具有多种属性，比如Hero有护甲，生命等

当我们要创建一个野怪时也会有这些属性，还会额外多加一个属性（虽然貌似没有）

这时就可以使用继承extends

public class Weapon extends Item{

    int damage; //攻击力//通过继承也有name于price

     

    public static void main(String[] args) {

        Weapon infinityEdge = new Weapon();

        infinityEdge.damage = 65; //damage属性在类Weapon中新设计的

         

        infinityEdge.name = "无尽之刃";//name属性，是从Item中继承来的，就不需要重复设计了

        infinityEdge.price = 3600;

         

    }

     

}

三-方法重载

一个方法（函数）可以有多个参数，但方法名相同

当调用方法时自动根据提供的实际参数选择对应的方法

public class While阶乘 extends Hero {
public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    public void attack(Hero h1) {
        System.out.println(name + "对" + h1.name + "进行了一次攻击 ");
    }
 
    public void attack(Hero h1, Hero h2) {
        System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");
    }
 
    public static void main(String[] args) {
        While阶乘 bh = new While阶乘();
        bh.name = "赏金猎人";
 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";
 
        bh.attack(h1);
        bh.attack(h1, h2);
    }

}

但当我们这样一次增加一个太麻烦了，遵循规律可这样写一个统一性的

public class While阶乘 extends Hero {

public void attack() {

        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");

    }

 

    public void attack(Hero... heros) {

    System.out.print(name+"攻击了");

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

            System.out.print(heros[i].name);

 

        }

        System.out.println("\n");

    }

 

    public static void main(String[] args) {

        While阶乘 bh = new While阶乘();

        bh.name = "赏金猎人";

 

        Hero h1 = new Hero();

        h1.name = "盖伦";

        Hero h2 = new Hero(),h3 = new Hero();

        h2.name = "提莫";

        h3.name = "石头";

 

        bh.attack(h1);

        bh.attack(h1, h2,h3);

    }

}

Hero...heros 

heros表示这样一个名字的数组存储Hero这个类的对象

注意上述代码中print的使用，这样就不会换行

四-

构造方法

构造方法在创建类时给出

比如一个Hero有了生命攻击等各种属性

数值为多少呢？除了在main中用Hero.hp = 100得到可不可以在创建new Hero（）时直接得到呢？

这时就可以构造方法

前面的都是默认使用的无参系统自带，代码中可以略过

构造方法是用于创建时初始化对象属性，与名字和类名字一样

public class Hero {

       

    String name; //姓名

       

    float hp; //血量

       

    float armor; //护甲

       

    int moveSpeed; //移动速度

       

    //带一个参数的构造方法

    public Hero(String heroname){ 

        name = heroname;

    }

     

    //带两个参数的构造方法

    public Hero(String heroname,float herohp){ 

        name = heroname;

        hp = herohp;

    }

       

    public static void main(String[] args) {

        Hero garen =  new Hero("盖伦"); 

        Hero teemo =  new Hero("提莫",383);

    }

     

}

当然也可以使用方法的重载

四-

方法中的参数可以是一个变量也可以是一个类

public void attack(Hero hero, int damage) {

        hero.hp = hero.hp - damage;

    }

 

    public static void main(String[] args) {

        Hero teemo = new Hero("提莫", 383);

        Hero garen = new Hero("盖伦", 616);

        garen.attack(teemo, 100);

阴影两行，通过garen调用方法传递teemo作为实参

另外，方法中的形参改变不会传递出去

因为他是作为局部临时变量的存在

public class Hero {

        

    String name; //姓名

        

    float hp; //血量

        

    float armor; //护甲

        

    int moveSpeed; //移动速度

     

    public Hero(){

         

    }

     

    public Hero(String name,float hp){

        this.name = name;

        this.hp = hp;

    }

 

    //复活

    public void revive(Hero h){

        h = new Hero("提莫",383);

    }

 

    public static void main(String[] args) {

        Hero teemo =  new Hero("提莫",383);

         

        //受到400伤害，挂了

        teemo.hp = teemo.hp - 400;

         

        teemo.revive(teemo);

         

        //问题： System.out.println(teemo.hp); 输出多少？ 怎么理解？

         

    }

      

}

比如这里，仍然为-17，teemo调用revive函数，将teemo作为实参传递进去作为形参 Hero h类的引用

在方法里使实参teemo指向一个新的对象，在这个方法里拥有了新的生命与名字，即使名字是相同的

但是对于外部变量（对象）Teemo，他的属性并没有因此而改变

在C语言中，要想使传递的参数改变，要么使用指针，要么使用return，不能直接改变，java也类似