类与对象

基础知识摘要java是面向对象编程：模拟现实生活。
所有的概念，都是源自于生活中。

1.找对象
    对象：只要是生活中具体的某一个物体或者具体的某一个事物就是一个对象。
2.找对象的特性和行为        
eg：
   某一个学生
特征：姓名，性别，学分，年龄，学校，....
行为：考试，说话，睡觉，吃饭，学习，打游戏，看电视,...
  眼睛里看到的任何一个物体就是一个对象。
2.类的组成
生活中的分类，是根据对象相似的特征和相似的行为进行归类的。

程序中类，是按照固定的格式，对对象的特征和行为进行的定义，定义成一个相应的模板。

程序中类由2个部分组成：1.属性(对象的特征)  2.方法（对象的行为）

3.类的基本格式
public  class 类名 {

//定义属性的格式
private 数据类型  属性名;

//方法的格式
public 返回值数据类型 方法名(数据类型 形参名，...){

}
          }

4.实例化对象和调用方法的格式
实例化对象的关键字是：new
格式：
类名 对象名 = new 类名();
Student stu = new Student();//默认的构造方法
调用方法的格式
对象名.方法名(实参或者参数值,...);
stu.setName("张三");
int s = stu.getScore();//赋值
s-=1;
stu.setScore(s);
stu.study();
stu.play();

5.对象是否可以作为参数？
1.定义的类是否可以作为数据类型？
              可以的（eg：String是一个类，也是数据类型）
2.你用类实例化对象的是可以作为参数的。
             eg： public void fight(hero b)（当一个对象作用于另一个对象时）

类是由属性和方法组成。
方法：1.普通方法(对象的行为)
              2.构造方法(实例化对象的方法)

1.构造方法
   语法格式：
       构造方法：     public 类名(数据类型 形参名,...){
//方法体
}
      普通方法：     public 返回值数据类型 方法名(数据类型 形参名,...){
//方法体
}
（在习题中举例）
   区别：
1.返回值的不同
2.方法名的不同

   实例化对象的格式：类名 对象名 = new 类名();

   用途：
           1.实例化对象。
2.给属性设置初始值。
  java会给类提供一个默认的构造方法；如果类中定义了构造方法，则默认的会被覆盖
无法再继续使用默认的构造方法。

2.方法（构造方法和普通方法）重载
实现方法重载的条件
1.方法名字必须要完全相同
2.方法所带的参数个数、参数类型、参数顺序，这三项中最少要有一个是不同的。
      根据参数调用重载后的方法

      什么情况要使用到方法重载
当一个方法中有多个功能，需要根据不同的对象调用不同的功能的方法时，用方法重载。
eg:  public void combat(Monster mon1){
         int HP1=mon1.getHP();
HP1-=68;
mon1.setHP(HP1);
System.out.println(name+"用激光射中"+mon1.getName());
System.out.println(mon1.getName()+"的生命值是"+mon1.getHP());
}
     -----------------------------------------------------------
      public void combat(hero b){
    int HP=b.getHP();
HP-=3;
b.setHP(HP);
System.out.println(name+"击中"+b.getName());
System.out.println(b.getName()+"生命值是"+b.getHP());
      }
    以上虽然方法名一样，当时其中的内容不一样，且数据类型也不一样（定义的类可以作为数据类型）。

3.this关键字（表示当前对象）
   1.当形参与名与实参名一致时，要用this关键字，否则不能被区分（就近原则）
Public Class Student { 
  String name; //定义一个成员变量
  name private void SetName(String name){//定义一个参数(局部变量)name    this.name=name; //将局部变量的值传递给成员变量
}
}   
  如上面这段代码中，有一个成员变量name，同时在方法中有一个形式参数，名字也是name，然后在方法中将形式参数name的值传递给成员变量name，虽然我们可以看明白这个代码的含义，但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来将成员变量name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。this这个关键字其代表的就是对象中的成员变量或者方法。也就是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成员方法的形式参数或者局部变量。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又叫做对象的属性，而后面的name则是方法的形式参数，代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。   
   2.在一个构造方法中，通过this关键字调用所在类中的另一个构造方法。
eg:public class Student { //定义一个类，类的名字为student。 
         public Student() { //定义一个方法，名字与类相同故为构造方法 
           this(“Hello!”); }
public Student(String name) { //定义一个带形式参数的构造方法
}
}
    this关键字除了可以调用成员变量之外，还可以调用构造方法。在一个Java类中，其方法可以分为成员方法和构造方法两种。构造方法是一个与类同名的方法，在Java类中必须存在一个构造方法。如果在代码中没有显示的体现构造方法的话，那么编译器在编译的时候会自动添加一个没有形式参数的构造方法。这个构造方法跟普通的成员方法还是有很多不同的地方。如构造方法一律是没有返回值的，而且也不用void关键字来说明这个构造方法没有返回值。而普通的方法可以有返回值、也可以没有返回值，程序员可以根据自己的需要来定义。不过如果普通的方法没有返回值的话，那么一定要在方法定义的时候采用void关键字来进行说明。其次构造方法的名字有严格的要求，即必须与类的名字相同。也就是说，Java编译器发现有个方法与类的名字相同才把其当作构造方法来对待。而对于普通方法的话，则要求不能够与类的名字相同，而且多个成员方法不能够采用相同的名字。在一个类中可以存在多个构造方法，这些构造方法都采用相同的名字，只是形式参数不同。Java语言就凭形式参数不同来判断调用那个构造方法。
    在上面这段代码中，定义了两个构造方法，一个带参数，另一个没有带参数。构造方法都不会有返回值，不过由于构造方法的特殊性，为此不必要在构造方法定义时带上void关键字来说明这个问题。在第一个没有带参数的构造方法中，使用了this(“Hello!”)这句代码，这句代码表示什么含义呢?在构造方法中使this关键字表示调用类中的构造方法。如果一个类中有多个构造方法，因为其名字都相同，跟类名一致，那么这个this到底是调用哪个构造方法呢?其实，这跟采用其他方法引用构造方法一样，都是通过形式参数来调用构造方法的。如上例中，this关键字后面加上了一个参数，那么就表示其引用的是带参数的构造方法。如果现在有三个构造方法，分别为不带参数、带一个参数、带两个参数。那么Java编译器会根据所传递的参数数量的不同，来判断该调用哪个构造方法。从上面示例中可以看出，this关键字不仅可以用来引用成员变量，而且还可以用来引用构造方法。
    不过如果要使用这种方式来调用构造方法的话，有一个语法上的限制。一般来说，利用this关键字来调用构造方法，只有在无参数构造方法中第一句使用this调用有参数的构造方法。否则的话，翻译的时候，就会有错误信息。这跟引用成员变量不同。如果引用成员变量的话，this关键字是没有位置上的限制的。如果不熟悉这个限制的话，那么还是老老实实的采用传统的构造方法调用方式为好。虽然比较麻烦，但是至少不会出错。
    3.返回对象的值
  this关键字除了可以引用变量或者成员方法之外，还有一个重大的作用就是返回类的引用。如在代码中，可以使用return this，来返回某个类的引用。此时这个this关键字就代表类的名称。如代码在上面student类中，那么代码代表的含义就是return student。可见，这个this关键字除了可以引用变量或者成员方法之外，还可以作为类的返回值，这才是this关键字最引人注意的地方。

4.值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参 数的值。
值传递适用于java的基本数据类型+String
         值传递的方法（实参，形参）

5.引用传递 ：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。
           引用传递适用于Java的引用类型(对象类型)[类，抽象类，接口，数组 ]
         将一个对象的值赋给另一个（通过首地址的传递）
eg:  public void combat(Monster mon1){
int HP1=mon1.getHP();
HP1-=68;
mon1.setHP(HP1);
System.out.println(name+"用激光射中"+mon1.getName());
System.out.println(mon1.getName()+"的生命值是"+mon1.getHP());
}
在一个类中设置了一个这样的方法，但在主函数中可以这样调用：
                                b.combat(mon1);
                            b.combat(mon2);
                                 b.combat(mon3);
还有一些简单的引用传递，eg:    stu 1=stu 2;
                            stu 2=stu 3;
                            stu 3=stu 1;

课后练习
回合制游戏：

基本思路：游戏中是多个对象进行战斗，根据不同的对象需要设置不同的类，根据不同的战斗方式，要设置不同的方法，或是进行方法重载。当所有的前提条件都具备后，最后写一个主函数开始游戏过程。

操作中遇到的问题及解答：
   1.本来以为虽然是多个对象进行战斗，但同是战斗，只是方式不同而已，可以只创建一个类，再实例化多个对象，可是最后发现如果要使用相同的方法，那么只能实现被动化，既使用了方法的对象只能作用于自己（主动发起进攻后反而自己降低生命值），那么就只好创建多个类，用类实例化对象作为参数，就可以实现一个对象作用于另一个对象。
   2.即主函数中用while循环时，判断条件接收值的问题。如果单使用形参（eg：HP）是接收不到值得，要用到 实例化对象名.方法(eg:a.getHP()>0&&b.getHP()>0)。

我的代码：
package game;
//定义一个boss类
public class boss {


//定义一个姓名属性
private String name;
private int HP;
//定义一个设置姓名属性值的方法
public void setName(String n){
name=n;
}
//定义一个获取姓名属性值的方法
public String getName(){
return name;
}
//定义一个设置生命力属性值的方法
public void setHP(int k){
HP=k;
}
//定义一个获取生命力属性值的方法
public int getHP(){
return HP;
}
/**
* 定义一个战斗的方法
*/
public void fight(hero b){
int HP=b.getHP();
HP-=8;
b.setHP(HP);
System.out.println(name+"用激光射中"+b.getName());
System.out.println(b.getName()+"生命值是"+b.getHP());
}
/**
  * 定义一个增加血量的方法
  */
public void recharge(){
HP+=5;
System.out.println(name+"增加血量中，生命值是"+HP);
}
/**
  * 定义一个胜利的方法
  */
public void win(hero b){
System.out.println(b.getName()+"血量不足，"+name+"胜利...");
}

}
*********************************************************************************************
package game;
//定义一个hero类
public class hero {



//定义一个姓名属性
private String name;
private int HP;
//定义一个设置姓名属性值的方法
public void setName(String n){
name=n;
}
//定义一个获取姓名属性值的方法
public String getName(){
return name;
}
//定义一个设置生命力属性值的方法
public void setHP(int k){
HP=k;
}
//定义一个获取生命力属性值的方法
public int getHP(){
return HP;
}
/**
* 定义两个战斗的方法
*/
public void fight(boss a){
int HP=a.getHP();
HP-=13;
a.setHP(HP);
System.out.println(name+"用激光射中"+a.getName());
System.out.println(a.getName()+"的生命值是"+a.getHP());
}
public void combat(Monster mon1){
int HP1=mon1.getHP();
HP1-=68;
mon1.setHP(HP1);
System.out.println(name+"用激光射中"+mon1.getName());
System.out.println(mon1.getName()+"的生命值是"+mon1.getHP());

}
/**
  * 定义一个增加血量的方法
  */
public void recharge(){

HP+=9;
System.out.println(name+"增加血量中，生命值是"+HP);
}
/**
  * 定义一个胜利的方法
  */
public void win(boss a){
System.out.println(a.getName()+"血量不足,"+name+"胜利！！！");
}

}
*********************************************************************************************
package game;
//定义一个monster类
public class Monster {
private String name;
private int HP;
//定义构造方法
public Monster(String name,int HP){
this.name=name;
this.HP=HP;
}
public String getName(){
return name;
}
public void setHP(int HP){
this.HP=HP;
}
      public int getHP(){
      return HP;
      }
      //定义一个战斗方法
      public void combat(hero b){
      int HP=b.getHP();
HP-=3;
b.setHP(HP);
System.out.println(name+"击中"+b.getName());
System.out.println(b.getName()+"生命值是"+b.getHP());
      }
}
*********************************************************************************************
package game;
//主函数
public class Manage {

/**
* @param args
*/
public static void main(String[] args) {
//实例化5个战斗的对象
boss a=new boss();
a.setName("大怪");
a.setHP(100);
hero b=new hero();
b.setName("奥特曼");
b.setHP(100);
Monster mon1=new Monster("小怪一号",100);
Monster mon2=new Monster("小怪二号",100);
Monster mon3=new Monster("小怪三号",100);
                     mon3=mon2;//引用传递
//奥特曼与小怪的战斗
do {
b.combat(mon1);
                           b.combat(mon2);//引用传递
                                b.combat(mon3);//引用传递
mon1.combat(b);
mon3.combat(b);
}
while(mon1.getHP()<0&&mon2.getHP()<0&&mon3.getHP()<0);
System.out.println("小怪们牺牲，大怪出场。。。");
//奥特曼与大怪的战斗
while(a.getHP()>0&&b.getHP()>0){
//调用方法

b.recharge();
a.recharge();
a.fight(b);
b.fight(a);
}
System.out.println("\n");
if(b.getHP()<=0)
a.win(b);
else
b.win(a);
}

}