类和对象

一-

类：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也类似