java类与对象基本使用

Posted 2020-08-19

public class Dog{
   String breed;
   int age;
   String color;  //成员变量

   void barking(){
   }

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

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

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

• 类变量: 类变量是在一个类中声明，任何方法之外的变量，用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