Java对象和类

Java对象和类

Java是一个面向对象语言。作为具有面向对象的特征的语言，java支持以下的概念：

l       多态性

l       继承

l       封装

l       抽象

l       类

l       对象

l       实例

l       方法

l       消息解析

 

先介绍一下对象和类的概念。

l       对象：对象具有状态和行为。例如，一个狗的状态有，颜色、名字、品种，行为有摇尾巴、叫、吃。对象是一个类的实例。（类就像一个模板，对象就是实实在在按照魔板生产出来的东西）

l       类：一个类可以定义为一个模板，他描述了对象所有的状态和行为。

 

Java中的对象

       让我们看一下现实世界，我们周围有很多对象，有人、车、够、等等，所有这些对象都有状态和行为。

       对于狗来说，它的状态有名字、尾巴、颜色，它的行为有狗叫、摇尾巴、跑。

       对比现实世界的对象与软件的对象，他们有非常相似的特征。

       软件对象也有状态和行为。

       软件的状态是存储在一个字段（fields）中，状态是通过方法（methods）来表现。

       所以在软件中，对象的方法操作内部的状态（state），对象和对象之间通过方法通信。

 

Java中的类

       类是创建单个对象的蓝图（blueprint）。

例如：

publicclassDog{

   String breed;

   int ageC

   String color;

   void barking(){

   }

   void hungry(){

   }

   void sleeping(){

   }

}

 

一个类可以包含以下任何类型：

l       局部变量：变量定义在方法、构造函数、块中被称为局部变量。它在方法内声明和初始化，并且在方法结束的时候被销毁。

l       实例变量：实例变量是在类里面函数外面定义的变量。当类被实例化的时候变量被初始化。实例变量可以被内部的方法，构造函数、特点的类块所访问。

l       类变量：类变量是声明在类内部的变量，不在方法之内，用static关键字声明。

 

一个类可以有很多方法去访问各种方法变量的值。例如上面例子中的，barking(),hungry() 和 sleeping() 方法。

 

构造函数

当谈到类，其中有一个很重要的子话题就是构造函数。每个类都有构造函数。如果我们没有明确的写出类的构造函数，java在编译的时候会构造一个默认构造函数。

      

       每当一个新的对象被创建的时候，至少有一个构造函数将被调用。构造函数的主要规则是构造函数的名字需要和类名相同。一个类可以有多个构造函数。

例如：

publicclassPuppy{

   publicPuppy(){

   }

   publicPuppy(String name){

      // This constructor has one parameter, name.

   }

}

       Java支持单实例类，你可以创建一个只有一个实例的类。

注：有两种不同类型的构造函数，我们在后面的章节讨论。

 

创建对象

       就像前面说的，类就是对象的蓝图。所以对象是从类创建的。在Java中关键词new用来创建新的对象。

 

当从类创建对象的时候有三个步骤：

l       声明：对象类型与对象变量名。

l       实例化：使用关键字new创建对象。

l       初始化：new创建对象之后，调用构造函数初始化。

例如：

publicclassPuppy{

   publicPuppy(String name){

      // This constructor has one parameter, name.

      System.out.println("Passed Name is :"+ name );

   }

   publicstaticvoid main(String[]args){

      // Following statement would create an object myPuppy

      Puppy myPuppy =newPuppy("tommy");

   }

}

输出：

Passed Name is :tommy

 

访问实例变量和方法

通过创建对象可以访问实例变量和方法。下面是访问实例变量和方法的方法：

/* 首先创建对象 */

ObjectReference = new Constructor();

/* 访问变量 */

ObjectReference.variableName;

/* 访问函数 */

ObjectReference.MethodName();

 

 

 

例如，一下是如何访问类的实例化变量和方法：

publicclassPuppy{

   int puppyAge;

   publicPuppy(String name){

      // This constructor has one parameter, name.

      System.out.println("Name chosen is :"+ name );

   }

   publicvoid setAge(int age ){

      puppyAge = age;

   }

   publicint getAge(){

      System.out.println("Puppy's age is :"+ puppyAge );

      return puppyAge;

   }

   publicstaticvoid main(String[]args){

      /* Object creation */

      Puppy myPuppy =newPuppy("tommy");

      /* Call class method to set puppy's age */

      myPuppy.setAge(2);

      /* Call another class method to get puppy's age */

      myPuppy.getAge();

      /* You can access instance variable as follows as well */

      System.out.println("Variable Value :"+ myPuppy.puppyAge );

   }

}

输出：

Name chosen is :tommy

Puppy's age is :2

Variable Value :2

 

源文件声明规则

 

       现在看一下源文件的声明规则。在源文件中声明类，import语句和package语句的时候，这些规则是必不可少的：

l       每个源文件中值可以有一个public类。

l       一个源文件可以有很多的非public类。

l       Public类名必须要和源文件名相同，例如，public类名为Employee()那么源文件名则必须为Employee.java

l       如果一个类定义在一个包（package）内部，那么package语句必须在源文件的第一行。

l       如果import语句存在，那么它必须在package语句和类声明之间。如果没有package语句，那么import语句必须在第一行。

l       Import和package语句将会对源文件中的所有类有效。

 

类还有不同的访问权限，将在后面讨论。

 

除了这些类型，还有特殊的类称之为内部类和匿名类。

 

Java包

简单来说，它是类和接口的分类方式。在Java开发中，数以百计的类和接口将被写入，因此分类这些类是必须的，这将使生活变得更加容易。

 

Import语句

在java中，如果全名（其中包括包和类名）给出，那么编译器就可以很容易地找到源代码或类。Import语句给编译器提供找到类的正确的位置。

 

例如，下面这段代码，将会告诉编译器在java_installation/java/io的目录下找到所需要的类：

import java.io.*;

 

 

 

一个简单的例子

       这个例子，我们将会创建两个类，Employee 和 EmployeeTest.

 

        import java.io.*;

publicclassEmployee{

   String name;

   int age;

   String designation;

   double salary;

   // This is the constructor of the class Employee

   publicEmployee(String name){

      this.name = name;

   }

   // Assign the age of the Employee  to the variable age.

   publicvoid setEmpAge(int empAge){

      age = empAge;

   }

   /* Assign the designation to the variable designation.*/

   publicvoid setEmpDesignation(String empDesig){

      designation = empDesig;

   }

   /* Assign the salary to the variable     salary.*/

   publicvoid setEmpSalary(double empSalary){

      salary = empSalary;

   }

   /* Print the Employee details */

   publicvoid printEmployee(){

      System.out.println("Name:"+ name );

      System.out.println("Age:"+ age );

      System.out.println("Designation:"+ designation );

      System.out.println("Salary:"+ salary);

   }

}

因为一个java源文件的文件名必须要和public类的类名一样所以，此源文件的文件名为Employee.java. 因为运行程序要从main函数开始，所以我们还需要一个类包含main方法来创建对象文件名为EmployeeTest.java。

import java.io.*;

publicclassEmployeeTest{

   publicstaticvoid main(String args[]){

      /* Create two objects using constructor */

      Employee empOne =newEmployee("James Smith");

      Employee empTwo =newEmployee("Mary Anne");

      // Invoking methods for each object created

      empOne.empAge(26);

      empOne.empDesignation("Senior Software Engineer");

      empOne.empSalary(1000);

      empOne.printEmployee();

      empTwo.empAge(21);

      empTwo.empDesignation("Software Engineer");

      empTwo.empSalary(500);

      empTwo.printEmployee();

   }

}

输出：

C:\> javac Employee.java

C:\> javac EmployeeTest.java

C:\> java EmployeeTest

Name:James Smith

Age:26

Designation:Senior Software Engineer

Salary:1000.0

Name:Mary Anne

Age:21

Designation:Software Engineer

Salary:500.0