Java对象和类

转自原文：http://www.yiibai.com/java/java_object_classes.html

java是一种面向对象的语言。由于具有面向对象特性的语言，Java支持以下基本概念：

• 多态性
• 继承
• 封装
• 抽象化
• 类
• 对象
• 实例
• 方法
• 消息解析

在本章中，我们将探讨类和对象这些概念。

• 对象 - 对象具有状态和行为。例如：狗有状态 - 颜色，名称，繁殖以及行为，摇头晃脑，吠叫，吃。对象是类的实例。

• 类 - 一个类可以被定义为描述行为的模板/蓝色印花/指出其类型支持的对象。

Java对象：

现在，我们深入研究什么是对象。如果考虑到现实世界中，可以发现身边很多对象，汽车，狗，人等，这些对象都有一个状态和行为。

如果我们考虑一只狗，那么它的状态是 - 名称，品种，颜色和行为 - 吠叫，摇摆，跑等

如果软件对象与现实世界中的对象进行比较，它们具有非常相似的特征。

软件对象也有状态和行为。软件对象的状态存储在字段和行为是通过方法如图所示。

因此，在软件开发中，方法上的一个对象的内部状态和操作的对象对对象的通信是通过方法来完成。

Java中的类：

类是从中创建单个对象的蓝图。

类的样本如下︰

public class Dog{
   String breed;
   int age;
   String color;

   void barking(){
   }
   
   void hungry(){
   }
   
   void sleeping(){
   }
}

一个类可以包含以下任意变量类型。

• 局部变量:  方法里面，构造函数或块中定义的变量称为局部变量。该变量将被声明和初始化的方法中，当该方法完成该变量将被销毁。

• 实例变量: 实例变量都在一个类，但任何方法之外的变量。这些变量在类被加载的实例化。实例变量可以从内部的任何方法，构造函数或特定类别的块访问。

• 类变量: 类变量是在一个类中声明，任何方法之外的变量，用static关键字。

类可以有任意数量的方法来访问各种方法的值。在上面的例子中，barking(), hungry() 和 sleeping()的方法。

以下提到的一些在Java语言中需要寻找到类要讨论的重要议题。

构造函数：

在讨论关于类，其中最重要分课题之一是构造函数。每个类都有一个构造函数。如果我们不明确地写一个构造函数的类，Java编译器生成一个默认构造函数的类。

创建一个新的对象中的每个时间，至少有一个构造函数将被调用。构造函数的主要规则是，他们应该具有相同的名称作为类。一个类可以有多个构造函数。

构造函数的例子如下︰

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // This constructor has one parameter, name.
   }
}

Java还支持单实例类，在这里能够创建的类只有一个实例。

创建对象：

如前面提到的，一个类提供的图纸对象。所以基本上一个对象是从一个类创建的。在Java中，关键字 new 用于创建新的对象。

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

• 声明:  变量声明，一个变量名的对象类型。

• 实例: “new”关键字是用来创建对象。

• 初始化:  关键字 new 后跟调用一个构造函数。这个调用初始化新的对象。

创建对象的实例在下面给出：

public class Puppy{

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name ); 
   }
   public static void main(String []args){
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

如果我们编译并运行上面的程序，那么这将产生以下结果：

Passed Name is :tommy

访问实例变量和方法：

实例变量和方法是通过创建的对象的访问。要访问一个实例变量的完全限定路径应该如下：

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

例子：

这个例子说明了如何访问一个类的实例变量和方法：

public class Puppy{
   
   int puppyAge;

   public Puppy(String name){
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name ); 
   }
   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge ); 
       return puppyAge;
   }
   public static void main(String []args){
      /* Object creation */
      Puppy myPuppy = new Puppy( "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 ); 
   }
}

如果我们编译并运行上面的程序，那么这将产生以下结果：

Passed Name is :tommy
Puppy's age is :2
Variable Value :2

源文件中声明的规则：

正如本节的最后部分现在让我们看看到源文件中声明的规则。声明类，import语句和包声明在源文件时，这些规则是必不可少的。

• 只能有一个有public类在每一个源文件。

• 源文件可以有多个非公共类。

• 公共类名应该是源文件，以及应当由 .java 在末尾附加的名称。例如：类名是 public class Employee{} 将源文件应为 Employee.java。

• 如果类在包中定义，那么 package 语句应该是在源文件中的第一条语句。

• 如果 import 语句都存在，那么它们必须写 package 语句和类声明之间。如果没有包（package）语句，那么import语句应该是源文件中的第一行。

• 导入和包语句将意味着对所有现有的源文件中的类。不可能的声明不同的 import和/或包语句不同类的源文件中。

类有几个访问级别，有不同类型的类，抽象类，final类等将在访问修饰符章解释这些。

除了上述类型的类，Java也有一些特殊的类称为内部类和匿名类。

Java包：

简单地，它是分类的类和接口的方式。在开发Java应用程序中，数以百计的类和接口将会被写入，因此，分类这些类是必须的。

import语句：

在Java中，如果一个完全合格的名称，其中包括包和类名，变量的话，编译器可以很容易地找到源代码或类。 import语句是给予适当的位置，是编译器发现，特定的类的方法。

例如，下面的行会要求编译器来加载所有目录中 java安装/java/io 可用的类：

import java.io.*;

一个简单的案例：

对于研究案例，这里将创建两个类。他们是 Employee 和 EmployeeTest。

首先打开记事本，并添加下面的代码。请记住，这是Employee类和类是一个公共类。现在，保存名称为 Employee.java 这个源文件。

Employee类有四个实例变量的名字，年龄，名称和工资。这个类有一个明确定义的构造函数，它接受一个参数。

import java.io.*;
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
	
   // This is the constructor of the class Employee
   public Employee(String name){
      this.name = name;
   }
   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge){
      age =  empAge;
   }
   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* Print the Employee details */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

正如先前在本教程中所提到的，从处理的 main 方法开始。因此，为了让我们运行这个Employee类中应该有 main 方法，并应创建的对象。我们将创建这些任务一个单独的类。

下面给出的是 EmployeeTest 类，它创建 Employee类的两个实例，并调用方法为每个对象的每个变量赋值。

下面的代码保存在 EmployeeTest.java 文件

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("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();
   }
}

现在，编译这两个类，然后运行EmployeeTest看到的结果如下：

C :> javac Employee.java
C :> vi EmployeeTest.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