现在我们已经抽象出一个类——汽车类，汽车有不同的牌子，有不同的颜色，不同的形状，我们称每一辆具体的汽车为汽车类的一个实例，从汽车类到具体汽车的过程被称为实例化的过程，又称为类（汽车类）的实例化。在Java中一个类的实例化是通过关键字“new”来进行的。

比如说我们现在声明一个汽车类：

public class Car

{

……

}

进着进行一个类的实例化：

new Car();

一个类的实例是针对一个具体的对象的，它是一些具体属性的集合，

设计自己的类

      下面设计一个自己的类，我们的目的是做一个小型的学生管理系统，既然是学生管理系统，我们必须要拥有学生类，下面我们就开始设计一个学生类。

需求分析：

1、 对于一个学生类（class  Student），作为整个系统最核心的类，我们希望它能包括学生公有的基本信息：学生姓名、学号、性别、出生年月、专业、籍贯等。

2、 做为学生类的实例，我们希望能通过设置或访问来修改这些学生的不同信息。

public class StudentTest

{

       public static void main(String[] args)

       {

              Student tom=new Student("Tom","20020410");

              tom.setStudentSex("man");

              tom.setStudentAddress("America");

              System.out.println(tom.toString());

       }

}

class Student

{

       private String strName=""; //学生姓名

       private String strNumber=""; //学号

       private String strSex=""; //性别

       private String strBirthday=""; //出生年月

       private String strSpeciality=""; //专业

       private String strAddress="";

       public Student(String name,String number)

       {

              strName=name;

              strNumber=number;

       }

       public String getStudentName()

       {

              return strName;

       }

       public String getStudentNumber()

       {

              return strNumber;

       }

       public void setStudentSex(String sex)

       {

              strSex=sex;

       }

       public String getStudentSex()

       {

              return strSex;

       }

       public String getStudentBirthday()

       {

              return strBirthday;

       }

       public void setStudentBirthday(String birthday)

       {

              strBirthday=birthday;

       }

       public String getStudentSpeciality()

       {

              return strSpeciality;

       }

       public void setStudentSpeciality(String speciality)

       {

              strSpeciality=speciality;

       }

       public String getStudentAddress()

       {

              return strAddress;

       }

       public void setStudentAddress(String address)

       {

              strAddress=address;

       }

       public String toString()

       {

              String information="学生姓名="+strName+",学号="+strNumber;

              if(!strSex.equals(""))

                     information+=",性别="+strSex;

              if(!strBirthday.equals(""))

                     information+=",出生年月="+strBirthday;

              if(!strSpeciality.equals(""))

                     information+=",专业="+strSpeciality;

              if(!strAddress.equals(""))

                     information+=",籍贯="+strAddress;

              return information;

       }

}

分析：

     在程序中我们构建了一个学生类的实例：

Student tom=new Student("Tom","20020410");

这样的过程就是类的实例化的过程。tom是Student类实例的句柄，也就是我们所说的对象句柄，在后面对对象所进行的任何操作，都是通过操作对象句柄进行的。我们通过关键字new生成Student类的一个实例，一个实例代表的是一个特定属性的对象，我们生成的特定对象是学生：姓名是tom,学号是20020410的一个学生。

构造器（构造方法）

能过关键字new来生成对象的实例，是通过构造器（constructor）来实现的。简单的说：构造器是同类名相同的特殊方法。

public Student(Student name,String number)

{

 strName=name;

 strNumber=number;

}

当构造一个学生类的实例时，学生类的构造器就被启动，它给实例字段赋值。

构造器与方法的不同之处是：构造器只能与关键字new一起使用，构建新的对象。构造器不能应用于一个已经存在的对象来重新设置实例字段的值。

构造器的特点：

1、 构造器与类名相同（包括大小写）

2、 一个类可有多个构造器。

3、 构造器可以有0个、1个或多个参数。

4、 构造器没的返回值，但不能用void修饰。

对象的三个特征：

        对象的行为：这个对象能做什么，也就是能完成什么样的功能。比如自行车可以载我们想去的地方，节省体力。

        对象的状态：当通过一个操纵对象的方法时，对象所保持的一种包含特定的属性的状态。比如我们可以通过扭转车头，使自行车拐弯；刹车时，可以让自行车减速或停下来。

        对象的标识符：可以通过标识符，区别具有相同行为或类似状态的对象。说到自行车，可以有很多种样子的，很多生产厂家的，都可以说是自行车，可以根据颜色，生产厂家等等与其它的自行车区分。

对象的句柄

         对象的句柄：操纵对象的标识符，它是指向一个对象的句柄。根据前面对变量的定义，变量名是内存地址（栈）的一个别名，对于基本类型来讲，它的值就是存放在这个内存地址的空间内，对于对象类型来讲，它的值是一个指向实际对象的一个地址（堆），而真正的对象是存放于堆中，我们就可以理解为：这就是一个对象的句柄。

例如：String str;

这里只拥有了一个对象句柄，句柄（str）并没有与任何对象内容相关联。操纵句柄str时，并向它发送一条消息，这时系统会提示错误。所以在创建对象句柄时，一定不要忘记将句柄与实际的对象内容相关联（也就是对象变量的初始化）。

对象变量的初始化

对象变量的初始化是通过new关键字来完成对象的创建过程。它是向内存堆中申请一个空间，将这个对象内容放到这里，然后将内容与对象句柄（存在于栈中）关联起来。

例如：String str = new String( “ Hello ” );

语法：

         switch(表达式)

         {

               case常量1:

              语句1

              [break;]

               case常量2:

              语句2

              [break;]

               …

               case常量n:

              语句n

               [break;]

              [default:]

            默认处理语句
       [break;]
      }

注意：

         1）switch(表达式)返回的值必须是1）byte型、2）char型、3）short型、4）int型。

         2）常量的值必须和表达式的值的类型相一致。

         3）常量的值不允许出理重复的。

         4）break作用是结束switch开关语句。

         5）在一些特殊的情况下，可以写成：

         …

          case 常量n:

          case 常量n+1:

               语句

               [break;]

         …

例：命令行传1个参数，要求是0至100之间的数，不是整数的话就退出JVM，传的参数大于等于90时，输出“优秀”，如果小于90大于等于70之间的数，输出“良好”，小于70大于等于60时，输出“及格”，如果小于60输出“不及格，请继续努力”。

      class Switch

      {

             public static void main(String[] args)

             {

                    System.out.println("请输入成绩！");

                    int shu=Integer.parseInt(args[0]);

                    if((args.length!=1)||(shu<0||shu>100))

                    {

                           System.err.println("输入错误，请重新执行！");

                           System.exit(-1);

                    }

                    String chengji;

                    switch(shu/10)

                    {

                           case 10:

                           case 9:

                           chengji="优秀";

                           break;

                           case 8:

                           case 7:

                           chengji="良好";

                           break;

                           case 6:

                           chengji="及格";

                           break;

                           case 5:

                           case 4:

                           case 3:

                           case 2:

                           case 1:

                           case 0:

                           chengji="不及格，请继续努力";

                           break;

                           default:

                           chengji="请输入一个1至100之间的数";

                    }

                 System.out.println("成绩："+chengji);

             }

      }

一、不确定循环

        所谓不确定循环，也就是我们不能确定循环所要执行的次数，执行的次数是根据程序中参数的变化自动控制的。

        它主要有两种表现形式：第一种形式是while形式，第二种形式是do/while形式。

       1） while

       它的英语意思就是“当”，它在循环控制中也可以这样理解，它的语法格式是：

while(条件)

{

 目的一;

 目的二;

……

}

        换成中文的含义就是“当条件为真时，就执行循环体，当条件为假时，就不执行循环体。”

        下面我们编写一个比较有意思的程序来说明这个结构：

        我的同事小李自从参加工作以后，每个月都要交纳一定的住房基金，以准备买房子。现在他每个月工资是2000元，以后每年按10%的比例增加，其中工资的5%是用来交纳住房基金的，他想知道多少年后，他可以有20万元住房基金。

/*while循环控制结构的测试*/

public class BuyHouse

{

 public static void main(String[] args)

 {

   final double HOUSEFUND = 200000;

   double salary = 2000;

   double fund = 0;

   int years = 1;

 while(fund < HOUSEFUND)

     {

      fund += salary * 0.05 * 12;

      years++

      salary = salary * 1.1;

     }

   System.out.println(“the total years is :” + years);

   System.out.println(“the total fund is :” + fund);

 }

}

输出结果：the total years is :32

          The total fund is :218332.10994930082

程序分析：

        在开始的时候，我们并不知道需要多少年，但我们知道它的结束条件，那就是基金需要达到20万元。我们以它作为程序结束的条件，进行循环。通过这个程序我们可以总结出以下几点：

       1、循环开始执行的条件是为真；

       2、必须要有使程序结束的自变量在变化；

       3、循环判断条件为假时，程序中止循环。

2）do/while

我们先把前面的程序做一个改造，来比较一下两个程序的区别：

/*while循环控制结构的测试*/

public class BuyHouse2

{

 public static void main(String[] args)

 {

    final double HOUSEFUND = 200000;

    double salary = 2000;

    double fund = 0;

    int years = 1;

    do

    {

      fund += salary * 0.05 *12;

      years++;

      salary = salary * 1.1;

    }

    while(fund < HOUSEFUND);

    System.out.println(“the total years is :” + years);

    System.out.println(“the total fund is:” + fund);

 }

}

输出结果：the total years is :32

          the total fund is :218332.10994930082

我们再看两个小程序，并对比一下他们的输出：

/*测试不确定循环的两种表现形式的区别*/

public class DifferTest

{

public static void main(String[] args)

{

 int i = 2;

 do

 {

   i++;

   System.out.println(“the value I is:” + i);

 }

while(I < 2);

}

}

输出结果：the value i is:3

/*测试不确定循环的两种表现形式的区别*/

public class DifferTest2

{

public static void main(String[] args)

{

 Int i = 2;

 while (i < 2)

 {

   i++;

   System.out.println(“the value I is:” + i);

 }

}

}

         这个没有任何输出结果，这两种形式是有一定差别的：while语句是先进行条件判断，再进行循环体的处理；do/while语句是先进行循环体的处理再判断条件语句，也就是在执行判断之前已经将循环体内的逻辑处理了一遍。

二、确定循环

         for()循环是最简单的循环语句，它可以通过计数器或在每次循环后修改某个类似于计数器变量的值来控制它。它的格式如下：

for(初始化表达式；判断表达式；递增（或递减）表达式)

{

执行语句；

}

        初始化表达式：它是用来设定循环控制变量的初始值，也就是循环的起点。

       判断表达式：用来判断循环是否结束的表达式，也就是循环的终点。程序循环是否持续进行由判断表达式决定；通常判断表达式是关系表达式，当关系表达式的值为真是，程序继续进行循环，当关系表达式的值为假时，循环结束。

       递增（递减）表达式：是循环控制变量的递增，也可以是递减。它又称为循环控制的步长，也就是每次循环，循环变量增长（或减少）的速度。

        for()语句的最后不能有任何符号，需要特别注意。

例如：我们向控制台输出1到10之间的数字。

/*输出数字到控制台*/

Public class Circle

{

 Public static void main(String[] args)

 {

   For(int I = 1; I < 10; i++)

   {

     System.out.println(“ ” + i);

   }

 }

}

输出结果：1 2 3 4 5 6 7 8 9 10

        针对于for()循环控制结构，有以下问题请读者注意：

        1、如果在初始化表达式定义了一个初始化变量，那么该变量的作用域范围是从循环开始到循环结束；

        2、如果想在循环体外部使用循环计数器的最终结果，应该在循环开始外就声明。

        3、在同级别的不同for()循环中，可以定义相同名字的变量。

        4、在被包含的for()循环块内不可以定义相同名字的变量。

        5、for()循环与while循环是完全等价的。

三、逗号运算符

在Java中逗号运算符的惟一使用场所就是for循环，在初始化循环变量表达式或递增（递减）表达式中，我们用一系列逗号分隔不同的语句，这些语句均参与到循环控制中。

下面用一个程序说明这个问题

/*逗号运算符*/

public class CommaOperator

{

 public static void main(String[] args)

 {

   for(int i = 1, j = i + 10; i < 5; i++, j = i * 3)

   {

    System.out.println(“i =” + i + “; j =” + j);

   }

 }

}

输出结果：

         i = 1; j = 11

         i = 2; j = 6

         i = 3; j = 9

         i = 4; j = 12

        通过这个示例，读者可以发现初始化变量在开始的时候都是按照初始化表达式进行的，在运算的过程中，都按照步长控制表达式进行。

四、无限循环

        提到无限循环，也就是指没有判断表达式的for循环，当程序进入到循环体内的时候，由于没有判断表达式来结束正常的循环，使得程序进入到无限循环中，也就是我们平常说的死循环。

我们通过一个小例子来了解一下无限循环的表现形式：

/*无限循环控制*/

public class Unlimited

{

 public static void main(String[] args)

 {

 for(int i = 1;; i++)

 {

   System.out.println(“i =” + i);

 }

}

}

        如果程序进入到无限循环中，程序就不能正常结束了，我们只有手动结束程序的进程。手动结束进程的快捷键是Ctrl+C。

        下面我们编写一个程序来运行一下，问题是：假如这个月我的工资超过5000元，我就请朋友大餐一次，再去游泳，再打一次电了游戏。

/*条件语句第一种形式的测试*/

public class Suppose
{
   public static void main(String[] args)
   {
   double mySales = 6000;
    if (mySales > 5000)
      {
      System.out.println("请朋友大餐一次");
      System.out.println("再去游泳");
      System.out.println("打电子游戏");
      }
   }
}
输出结果：
                 请朋友大餐一次
                 再去游泳
                 打电子游戏
        有些人可能要问：如果工资超过了5000元，就聚会，游泳，如果没有的话，只能吃方便面。该怎么表达呢，现在我们就讲一下第二种形式。

2）if (…){…}else{…}
        这种表现形式可能是最熟悉，也是最常用的，它所表达的意思就是：如果条件满足，就执行if (…)后面的{…}，如果条件不满足，就执行else后面的{…}内容。例如：假如这个月我的工资超过5000元，我就请朋友大餐一次，再去游泳，再打一次电子游戏。如果不到5000元，我只有吃方便面了。

/*条件语句第二种形式测试*/

public class Suppose2
{
   public static void main(String[] args)
   {
    double mySales = 4000;
    if ( mySales > 5000)
        {
      System.out.println("请朋友大餐一次");
      System.out.println("再去游泳");
      System.out.println("打电子游戏");
         }
     else
        {
     System.out.println("只有吃方便面了");
        }
    }
}
输出结果：只有吃方便面了
        现在我们处理的两种形式都是一个条件，那么能不能处理多个条件呢，下面就开始学习第三种形式。

3）if …else if …   其表达式为：
         if (条件一)
         {
          目的一;
          ……
          }
         else if (条件二)
         {
          目的一;
          ……
         }
         else if (条件三)
         {
          目的一;
          …… 
         }
         ……
         else
         {
          不满足任何条件的结果;
         }
现在我们把上面的表现形式更改一下：
        if (条件一) 
        {
         目的一;
         ……
         }
        else
        {
        if (条件二)
         {
               目的一;
                ……
         }
        else
        {
               if(条件三)
               {
                 目的一;
                  ……
                }
                ……
               else
               {
                 不满足任何条件的结果;
                }
         }
}
         我们可以看出，这两段的逻辑完全是一致的。有的家长为了鼓励孩子学习，特别制定了如下的奖励措施：如果这学期考试每门都100。你想上哪玩都行，另外再奖励500元零用钱；如果能达到90分以上，只奖励500元钱，80分以上，只有300元，低于80分，对不起了，你暑假就老老实实在家学习，哪也不能去。我们用一段程序来实现这个过程吧：
     if (每门成绩 = 100)
     {
       可以上任何地方玩;
       500元奖金;
      }
     else if (成绩 >= 90)
      {
       只奖励500元;
       }