Java中的类---接上篇_java employee()-CSDN博客

本文链接：https://blog.csdn.net/qq_40938646/article/details/79284351

一、用户自定义类

1、写先出一个简单的Employee类作为例子说明。

代码如下：

import java.time.LocalDate;

/**
 * 自定义方法练习--测试 这个程序中包含了两个类Employee类和带有public修饰的EmployeeTest类
 * 
 * @author:Archer-LCY
 * @date:2018年2月3日下午8:08:51
 */
public class EmployeeTest {
	public static void main(String[] args) {
		// 定义Employee类得数组并赋值
		Employee staff[] = new Employee[3];
		System.out.println("加薪前");
		staff[0] = new Employee("Herry", 70000, 1988, 12, 3);
		staff[1] = new Employee("Marry", 20000, 1990, 1, 31);
		staff[2] = new Employee("Amy", 10000, 1989, 11, 23);

		// 给每个人加薪5%，并打印
		System.out.println("\n加薪后");
		for (Employee em : staff) {
			em.raiseSalary(5);
			System.out.println("姓名：" + em.getname() + "\t薪水：" + em.getSalary() + "\t入职时间：" + em.getHireDay());
		}
	}
}

/**
 * 员工类
 * 
 * @author:Archer-LCY
 * @date:2018年2月3日下午8:28:40
 */
class Employee {
	private String name;
	private double salary;
	private LocalDate hireDay;// LocalDate需要导入包java.time.LocalDate;

	public Employee(String name, double salary, int year, int month, int day) {
		super();
		this.name = name;
		this.salary = salary;
		this.hireDay = LocalDate.of(year, month, day);
		output();
	}

	// 输出
	public void output() {
		System.out.println("姓名：" + name + "\t薪水：" + salary + "\t入职时间：" + hireDay);
	}

	public String getname() {
		return name;
	}

	public double getSalary() {
		return salary;
	}

	public LocalDate getHireDay() {
		return hireDay;
	}

	public void raiseSalary(double byPercent) {
		double raise = this.salary * byPercent / 100;
		salary += raise;
	}
}

注意：

（1）在这个示例中包含两个类，一个是Employee类，一个是带有public访问修饰符的EmployeeTest类。其中EmployeeTest类中包含了main方法。

（2）源文件名是EmployeeTest.java ，这是因为文件名必须与public类的名字相匹配。在一个源文件中，只能有一个共有类，但非共有类的数目可以任意。

（3）当编译这段源代码时，编译器将在目录下创建两个类文件：EmployeeTest.class和Employee.class 。

（4）程序中包含main方法的类名提供字节码解释器，以便启动这个程序：java EmployeeTest ，字节码解释器开始运行EmployeeTest类的main方法的代码。在这段代码中，定义了Employee类的数组，里面有三组，先后构造了三个新的Employee对象，并显示它们的状态。

2、多个文件的使用

在EmployeeTest.java一个源文件中包含了两个类。但一般情况下，我们习惯于每一个类放在一个单独的源文件中。例如，将EmployeeTest类放在EmployeeTest.java中，而将Employee类放在Employee.java中。

如果习惯上述所说的分开组织文件的方法，可以采用下面三种编译源程序的方法：

注：每次在命令提示符窗口使用前记得先用dir，查看当前目录，这样可以避免不必要的尴尬错误。还需要注意的一点是javac和java时必须是在文件所在目录，如下图：

（1）使用通配符调用java编译器：javac EmployeeTest*.java ，此时，所有的与通配符匹配的源文件都将被翻译成类文件。编译成功结果如下：

（2）第二种是使用：javac EmployeeTest.java ，编译成功结果如下：

（3）第三种：如果想独立测试使用：java EmployeeTest 这种方法可以将结果打印在命令提示符窗口，结果如下图：

一个更大应用程序的一部分，可以用）：java Application

3、对Employee类剖析

（1）这个类里面有一个构造器和5方法：

/**构造器*/

public Employee(String name, double salary, int year, int month, int day)

/**5个方法*/

public void output()

public String getname()

public double getSalary()

public LocalDate getHireDay()

public void raiseSalary(double byPercent)

（2）所有方法都被public标记。关键字public意味着任何类的任何方法都可以调用这些方法。

（3）在Employee类中有3个示例域用来存放将要操作的数据：

private String name;

private double salary;

private LocalDate hireDay;

（4）关键字private确保只有Employee类自身才能访问这些实例域，而其他类的方法不可以。

（5）注：可以有public来标记实例域，但是，这是一张极不为提倡的方法。public数据域允许程序中的任何方法都能对其进行读取和修改，这就破坏了封装。任何类任何方法都可以修改public与，这意味着某些代码将可以使用这种存取权限，这是我们不希望看到的。

（6）注：有两个实例域本身就是对象：name域是String类的对象，hireDay域是LocalDate类的对象。其实，这种情形十分常见：类通常包括类型属于某个类类型的实例域。

4、构造函数的使用

A.从Employee类的构造器开始分析

public Employee(String name, double salary, int year, int month, int day) {

super();

this.name = name;

this.salary = salary;

this.hireDay = LocalDate.of(year, month, day);

output();

}

（1）可以看到构造器与类名相同，在构造Employ类的对象时，构造器会运行，以便将实例域初始化为希望的状态。

（2）例如：new Employee("Herry", 70000, 1988, 12, 3); 这条代码在创建Employee类实例时，将会把实例域设置为：name=”Herry”;salary=70000;hireDay=LocalDate.of(1988,12,3);

（3）构造与其他方法不一样的是，构造器总是会伴随着New操作符的执行而被调用，而对一个已存在的对象不能调用构造器来达到从新调用的目的。例如：Herry.Employee("Herry", 70000, 1988, 12, 3); 会产生编译错误。

4、隐式参数与显式参数

隐式参数：出现在方法名之前的。

显式参数：位于方法名后面的括号中的。

方法用于操作对象以及存取它们的实例域。将调用这个方法的对象的salary实例域设置为新值。例如：方法：

public void raiseSalary(double byPercent) {

double raise = salary * byPercent / 100;

salary += raise;

}

在每一个方法中，关键字this表示隐式参数。可以用下面方式编写上面的方法：（这样的优点：这样可以将实例域与局部变量区分开来）

public void raiseSalary(double byPercent) {

double raise = this.salary * byPercent / 100;

salary += raise;

}

注意隐式构造和参数化构造不能共存：尽量把带参构造和默认构造都写出来，当你不把默认构造显示出来时，带参构造会将其覆盖，后面第二次使用时就会出错。

如下图：左边两组是带默认参数，不会报错；右边是不带默认参数，会报错（红色波浪线部分）

在Java中，所有的方法都必须在类的内部定义，但并不是内联（inline）方法。是否将某个变量设置为内联方法是Java虚拟机的任务

5、封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。

优点：（1）一旦在构造器中设定完毕，就没有任何一个办法可以对其修改，这样确保其不会被破坏，安全系数增加。

（2）更改器可以执行错误检查，而直接对域进行赋值就不会有这些处理。

6、静态方法

下面的情况适合使用静态方法：

（1）一个方法不需要访问对象状态，其所需参数都是通过显式参数提供（例如：Math.pow）

（2）一个方法只需要访问类的静态域

Java中的静态域和静态方法在功能上与c++相同，不同的是语法书写上不一样。Java中用 . 如：Math.pow；而c++中是用::操作符访问，如：Math::PI。

关于“static”：起初，C 引入关键字 static 是为了表示退出一个块后依然存在的局部变量在这种情况下，术语“ static” 是有意义的；变量一直存在，当再次进入该块时仍然存在。随后， static 在 C 中有了第二种含义，表示不能被其他文件访问的全局变量和函数。为了避免引入一个新的关键字，关键字 static 被重用了。最后， C++ 第三次重用了这个关键字，与前面赋予的含义完全不一样，这里将其解释为：属于类且不属于类对象的变量和函数。这个含义与 Java 相同。

-------摘自《Java核心技术》

二、对象构造

构造器：

（1）特点：没有返回值（void不是）、方法名和类名一致（方法名一样，参数不一样，参数可以有0个或者1个或者多个构造方法的重载）、每个类可以有一个以上的构造器、构造器总是伴随着new操作一起调用

（2）可以指定参数及实现重载

（3）注：java构造器的工作方式和C++一样。但是，所有java对象都是在堆中构造的，构造器总是伴随着new操作符一起使用。Employee number("Herry", 70000, 1988, 12, 3);//在c++中是正确的

（4）警告！！：不要在构造器中定义和实例域重名的局部变量。例如

public Employee(String n, double s, . . ){

String name = n;

double salary = s;

}//是错误的

在上述错例中，在这个构造器中声明了局部变量name和salary。这些变量只能在构造器内部访问。这些变量屏蔽了同名的实例域。