📅  最后修改于: 2020-11-15 04:13:04             🧑  作者: Mango
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还支持Singleton类,您只能在其中创建一个类的实例。
注意-我们有两种不同类型的构造函数。我们将在后续章节中详细讨论构造函数。
如前所述,类提供对象的蓝图。因此,基本上,对象是从类创建的。在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("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 );
}
}
如果我们编译并运行上面的程序,那么它将产生以下结果-
Name chosen is :tommy
Puppy's age is :2
Variable Value :2
作为本节的最后一部分,现在让我们研究源文件声明规则。在源文件中声明类, import语句和package语句时,这些规则至关重要。
每个源文件只能有一个公共类。
一个源文件可以具有多个非公共类。
公共类名称也应该是源文件的名称,并且应在末尾附加.java 。例如:类名是公共类Employee {},则源文件应为Employee.java。
如果类是在包内定义的,则package语句应为源文件中的第一条语句。
如果存在import语句,则必须在package语句和类声明之间编写它们。如果没有包语句,则import语句应该是源文件中的第一行。
导入和打包语句将隐含到源文件中存在的所有类。不可能对源文件中的不同类声明不同的import和/或package语句。
类具有几个访问级别,并且有不同类型的类。抽象类,最终类等。我们将在访问修饰符一章中对所有这些进行解释。
除了上述类型的类之外,Java还具有一些特殊的类,称为内部类和匿名类。
简而言之,它是对类和接口进行分类的一种方式。用Java开发应用程序时,将编写成百上千个类和接口,因此对这些类进行分类是必须的,并且会使生活变得更加轻松。
在Java中,如果给出了包括软件包和类名的完全限定名称,则编译器可以轻松地找到源代码或类。 Import语句是一种为编译器找到特定类提供适当位置的方法。
例如,以下行将要求编译器加载目录java_installation / 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:\> 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
在下一节中,我们将讨论Java中的基本数据类型以及在开发Java应用程序时如何使用它们。