类和对象

编程语言的几个发展阶段

（1）面向机器语言
计算机处理信息的早期语言是所谓的机器语言，使用机器语言进行程序设计需要面向机器来编写代码，即需要针对不同的机器编写诸如0101 1100这样的指令序列。
（2）面向过程语言
随着计算机硬件功能的提高,在20世纪60年代出现了面向过程设计语言，如C语言等。用这些语言编程也称为面向过程编程。语言把代码组成叫做过程或函数的块。每个块的目标是完成某个任务。使用这些语言编写代码指令时，不必再去考虑机器指令的细节，只要按着具体语言的语法要求去编写“源文件”。
（3）面向对象语言
基于对象的编程更加符合人的思维模式，使得编程人员更容易编写出易维护、易扩展和易复用的程序代码，更重要的是，面向对象编程鼓励创造性的程序设计。

面向对象编程主要体现下列三个特性：封装性 ；继承；多态

类

Java语言是面向对象语言，它的源程序是由若干个类组成，源文件是扩展名为.java的文本文件。
类是Java语言中最重要的“数据类型”，类声明的变量被称作对象（见后面的4.3节），即类是用来创建对象的模板。
类的实现包括两部分：类声明和类体。基本格式为：

class 类名 {
   类体的内容
}

其中：class是关键字，用来定义类。“class 类名”是类的声明部分，类名必须是合法的Java标识符。两个大括号以及之间的内容是类体。

类的构成

类体的内容由两部分构：一部分是变量的声明，用来刻画属性；另一部分是方法的定义，用来刻画行为功能。 （即成员定义和函数定义）

class Ladder { 
    float above;    //梯形的上底(变量声明)
    float bottom;   //梯形的下底(变量声明)
    float height;    //梯形的高(变量声明)
    float area;     //梯形的面积(变量声明)
    float computerArea() {          //计算面积(方法)
       area = (above+bottom)*height/2.0f;
       return area;
    } 
    void setHeight(float h) {        //修改高(方法)
       height = h;
    }
}

注意：
（1）成员变量的类型可以是Java中的任何一种数据类型，包括基本类型：整型、浮点型、字符型、逻辑类型；引用类型：数组、对象和接口。
（2）成员变量在整个类内的所有方法里都有效，其有效性与它在类体中出现 的位置 无关。 如下例子
（3）声明成员变量时如果没有指定初始值，Java编译器会为其指定默认值。
（4）声明成员变量bottom指定的初始值和above的值有关，那么声明成员变量above的位置要在声明成员变量bottom的前面。

class Lader
{   float above,area;
    float computerArea()
    {  area=(above+bottom)*height/2;//此时bottom和height变量都没有被定义，但编译没问题（C++会出现问题）
       return area;
     }
    float bottom;
    void setHeight(float h)
     {   height=h;          
    }
    float height;
}

方法（函数）的局部变量

1.成员变量有默认值（见4.2.3节），但局部变量没有默认值，因此在使用局部变量之前，必须保证局部变量有具体的值 。例如:下列InitError类无法通过编译。

class InitError {
   int x = 10,y;      //y的默认值是0
    void f() {
       int m;         //m没有默认值，但编译无错误
       x = y+m;    //无法通过编译，因为在使用m之前未指定m的值
    }
} 

2.如果方法和类中成员有变量重名，成员变量会变隐藏（可以使用this关键字使用被隐藏的成员变量）

class Tom {
   int x = 10,y;
   void f() {
         int x = 5;
         y = x+x;  
       //y得到的值是10，不是20。
      //如果方法f 中没有“int x=5;”，y的值将是20
    }
}

3.复合语句中声明的变量，只在复合语句中有效

public class A {
    int m = 10,sum = 0;  //成员变量，在整个类中有效
    void f() {
        if(m>9) {
          int z = 10;  //z仅仅在该复合语句中有效
          z = 2*m+z;    
        } 
        for(int i=0;i<m;i++) {
           sum = sum+i;   //i仅仅在该循环语句中有效
        }
        m = sum;       //合法，因为m和sum有效
        z = i+sum;   //非法，因为i和z已无效
    }
}

4.对成员变量的操作只能放在方法中，方法可以对成员变量和该方法体中声明的局部变量进行操作。在声明成员变量时可以同时赋予初值，但是不可以在类体中有单独的赋值语句，但局部变量必须赋初值。

class  A    {  
      int a=12; //声明成员变量并指定初始值12
      int b; //声明成员变量默认初始值0
      b=12;  //错误，这是语句
}

对象

在声明对象后必须使用new关键字为自己的变量赋值

class XiyoujiRenwu {
    float height,weight;
    String head, ear;
    void speak(String s) {
       head="歪着头";
       System.out.println(s);
    }
}
public class Example4_3 {
    public static void main(String args[]) {
        XiyoujiRenwu  zhubajie,sunwukong;   //声明对象
        zhubajie = new XiyoujiRenwu();      //为对象分配变量
        sunwukong = new XiyoujiRenwu();
        zhubajie.height=1.80f;              //对象给自己的变量赋值
        zhubajie.head="大头"; 
        zhubajie.ear="一双大耳朵"; 
        sunwukong.height=1.62f;            //对象给自己的变量赋值
        sunwukong.weight=1000f;   
        sunwukong.head="绣发飘飘"; 
        System.out.println("zhubajie的身高："+zhubajie.height);
        System.out.println("zhubajie的头:"+zhubajie.head);
        System.out.println("sunwukong的重量:"+sunwukong.weight);
        System.out.println("sunwukong的头:"+sunwukong.head);
        zhubajie.speak("俺老猪我想娶媳妇");      //对象调用方法
        System.out.println("zhubajie现在的头:"+zhubajie.head);
        sunwukong.speak("老孙我重1000斤,我想骗八戒背我"); //对象调用方法
        System.out.println("sunwukong现在的头:"+sunwukong.head);
   }
}

对象和数组类似属于引用的变量

class Point {
    int x,y;
    void setXY(int m,int n){
         x = m;
         y = n;
    }
}
public class Example4_4 {
   public static void main(String args[]) {
      Point p1 = null,p2 = null;                
      p1 = new Point();         
      p2 = new Point();
      System.out.println("p1的引用:"+p1);
      System.out.println("p2的引用:"+p2);
      p1.setXY(1111,2222);
      p2.setXY(-100,-200);
      System.out.println("p1的x,y坐标:"+p1.x+","+p1.y);
      System.out.println("p2的x,y坐标:"+p2.x+","+p2.y);
      p1 = p2;
      System.out.println("将p2的引用赋给p1后：");
      int address  = System.identityHashCode(p1);
      System.out.printf("p1的引用:%x\n",address);
      address  = System.identityHashCode(p2);
      System.out.printf("p2的引用:%x\n",address);
      System.out.println("p1的x,y坐标:"+p1.x+","+p1.y);
      System.out.println("p2的x,y坐标:"+p2.x+","+p2.y);
   }
}

运行结果：

Java的多态

java中存在两种多态：重载（Overload）和重写（Override）
重写是与继承有关的多态，将在第5章讨论。
方法重载是两种多态的一种，例如，你让一个人执行“求面积”操作时，他可能会问你求什么面积？所谓功能多态性，是指可以向功能传递不同的消息，以便让对象根据相应的消息来产生相应的行为。对象的行为通过类中的方法来体现，那么行为的多态性就是方法的重载

public class Student 
{ 
   //这里Student类中有两个同名的方法（函数），但是传入的参数不一样
   //这种方法就叫做重载
   double computerArea(Circle c) {
      double area=c.getArea();
      return area; 
   } 
   double computerArea(Tixing t) {
      double area=t.getArea();
      return area; 
   } 
}

访问权限

当用一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。
所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。
访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。