Java - 对象和类(Object & Classes)
Java是面向对象的语言。 作为具有面向对象功能的语言,Java支持以下基本概念 -
- Polymorphism
- Inheritance
- Encapsulation
- Abstraction
- Classes
- Objects
- Instance
- Method
- 消息解析
在本章中,我们将研究概念 - 类和对象。
Object - 对象具有状态和行为。 例如:一只狗的状态 - 颜色,名称,品种以及行为 - 摇尾巴,吠叫,吃东西。 对象是类的实例。
Class - 可以将类定义为描述其类型对象支持的行为/状态的模板/蓝图。
Java中的对象
现在让我们深入了解什么是对象。 如果我们考虑现实世界,我们可以在我们周围找到许多物体,汽车,狗,人等等。所有这些物体都有状态和行为。
如果我们考虑一只狗,那么它的状态是 - 名字,品种,颜色,而且行为是 - 吠叫,摇尾巴,跑步。
如果将软件对象与实际对象进行比较,则它们具有非常相似的特征。
软件对象也具有状态和行为。 软件对象的状态存储在字段中,行为通过方法显示。
因此,在软件开发中,方法对对象的内部状态进行操作,并且对象到对象的通信是通过方法完成的。
Java中的类
类是创建单个对象的蓝图。
以下是一个class的样本。
例子 (Example)
public class Dog {
String breed;
int age;
String color;
void barking() {
}
void hungry() {
}
void sleeping() {
}
}
类可以包含以下任何变量类型。
Local variables - 在方法,构造函数或块中定义的变量称为局部变量。 变量将在方法中声明和初始化,并且在方法完成时将销毁变量。
Instance variables - 实例变量是类中的变量,但在任何方法之外。 在实例化类时初始化这些变量。 可以从该特定类的任何方法,构造函数或块内部访问实例变量。
Class variables - 类变量是使用static关键字在任何方法之外的类中声明的变量。
一个类可以有多种方法来访问各种方法的值。 在上面的例子中,barking(),hungry()和sleeping()是方法。
以下是在查看Java语言类时需要讨论的一些重要主题。
构造函数 (Constructors)
在讨论类时,最重要的子主题之一是构造函数。 每个类都有一个构造函数。 如果我们没有为类显式编写构造函数,Java编译器会为该类构建一个默认构造函数。
每次创建新对象时,都将调用至少一个构造函数。 构造函数的主要规则是它们应该与类具有相同的名称。 一个类可以有多个构造函数。
以下是构造函数的示例 -
例子 (Example)
public class Puppy {
public Puppy() {
}
public Puppy(String name) {
// This constructor has one parameter, <i>name</i>.
}
}
Java还支持Singleton Classes ,您只能创建一个类的实例。
Note - 我们有两种不同类型的构造函数。 我们将在后续章节中详细讨论构造函数。
创建一个对象
如前所述,类提供了对象的蓝图。 所以基本上,一个对象是从一个类创建的。 在Java中,new关键字用于创建新对象。
从类创建对象时有三个步骤 -
Declaration - 具有变量名称和对象类型的变量声明。
Instantiation - 'new'关键字用于创建对象。
Initialization - 'new'关键字后跟对构造函数的调用。 此调用初始化新对象。
以下是创建对象的示例 -
例子 (Example)
public class Puppy {
public Puppy(String name) {
// This constructor has one parameter, <i>name</i>.
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" );
}
}
如果我们编译并运行上面的程序,那么它将产生以下结果 -
输出 (Output)
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();
例子 (Example)
此示例说明如何访问类的实例变量和方法。
public class Puppy {
int puppyAge;
public Puppy(String name) {
// This constructor has one parameter, <i>name</i>.
System.out.println("Name chosen 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 );
}
}
如果我们编译并运行上面的程序,那么它将产生以下结果 -
输出 (Output)
Name chosen is :tommy
Puppy's age is :2
Variable Value :2
源文件声明规则
作为本节的最后一部分,我们现在来看一下源文件声明规则。 在源文件中声明类, import语句和package语句时,这些规则是必不可少的。
每个源文件只能有一个公共类。
源文件可以有多个非公共类。
公共类名称也应该是源文件的名称,最后应该用.java附加。 例如:类名是public class Employee{}那么源文件应该是Employee.java。
如果在包内定义了类,则package语句应该是源文件中的第一个语句。
如果存在import语句,则必须在package语句和类声明之间写入它们。 如果没有package语句,则import语句应该是源文件中的第一行。
import和package语句将暗示源文件中存在的所有类。 无法将不同的import和/或package语句声明为源文件中的不同类。
类具有多个访问级别,并且有不同类型的类; 抽象类,最终类等。我们将在访问修饰符章节中解释所有这些。
除了上面提到的类之外,Java还有一些叫做Inner类和Anonymous类的特殊类。
Java包
简单来说,它是一种对类和接口进行分类的方法。 在用Java开发应用程序时,将编写数百个类和接口,因此必须对这些类进行分类,以使生活变得更加容易。
导入语句
在Java中,如果给出了包含包和类名的完全限定名称,则编译器可以轻松找到源代码或类。 Import语句是一种为编译器提供正确位置以查找特定类的方法。
例如,以下行将要求编译器加载目录java_installation/java/io中可用的所有类 -
import java.io.*;
一个简单的案例研究
对于我们的案例研究,我们将创建两个类。 它们是Employee和EmployeeTest。
首先打开记事本并添加以下代码。 请记住,这是Employee类,类是公共类。 现在,使用名称Employee.java保存此源文件。
Employee类有四个实例变量 - 名称,年龄,名称和工资。 该类有一个显式定义的构造函数,它接受一个参数。
例子 (Example)
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类,它创建EmployeeTest类的两个实例,并为每个对象调用方法以为每个变量赋值。
将以下代码保存在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以查看结果如下 -
输出 (Output)
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
接下来是什么 (What is Next?)
在下一个会话中,我们将讨论Java中的基本数据类型以及在开发Java应用程序时如何使用它们。