一、用户自定义类
1、写先出一个简单的Employee类作为例子说明。
代码如下：
1 import java.time.LocalDate; 2 3 /** 4 * 自定义方法练习--测试 这个程序中包含了两个类Employee类和带有public修饰的EmployeeTest类 5 * 6 * @author:Archer-LCY 7 * @date:2018年2月3日下午8:08:51 8 */ 9 public class EmployeeTest { 10 public static void main(String[] args) { 11 // 定义Employee类得数组并赋值 12 Employee staff[] = new Employee[3]; 13 System.out.println("加薪前"); 14 staff[0] = new Employee("Herry", 70000, 1988, 12, 3); 15 staff[1] = new Employee("Marry", 20000, 1990, 1, 31); 16 staff[2] = new Employee("Amy", 10000, 1989, 11, 23); 17 18 // 给每个人加薪5%，并打印 19 System.out.println(" 加薪后"); 20 for (Employee em : staff) { 21 em.raiseSalary(5); 22 System.out.println("姓名：" + em.getname() + " 薪水：" + em.getSalary() + " 入职时间：" + em.getHireDay()); 23 } 24 } 25 } 26 27 /** 28 * 员工类 29 * 30 * @author:Archer-LCY 31 * @date:2018年2月3日下午8:28:40 32 */ 33 class Employee { 34 private String name; 35 private double salary; 36 private LocalDate hireDay;// LocalDate需要导入包java.time.LocalDate; 37 38 public Employee(String name, double salary, int year, int month, int day) { 39 super(); 40 this.name = name; 41 this.salary = salary; 42 this.hireDay = LocalDate.of(year, month, day); 43 output(); 44 } 45 46 // 输出 47 public void output() { 48 System.out.println("姓名：" + name + " 薪水：" + salary + " 入职时间：" + hireDay); 49 } 50 51 public String getname() { 52 return name; 53 } 54 55 public double getSalary() { 56 return salary; 57 } 58 59 public LocalDate getHireDay() { 60 return hireDay; 61 } 62 63 public void raiseSalary(double byPercent) { 64 double raise = this.salary * byPercent / 100; 65 salary += raise; 66 } 67 }
注意：
（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。这些变量只能在构造器内部访问。这些变量屏蔽了同名的实例域。
在构造器内调用同一个类的构造器，可以用到this关键字，this(...)，如：
构造器小结注意事项：
（1）一个类中可以有多个构造器，这些构造与类名相同，当存在多个构造方法时，这些方法传递的参数不一样。
（2）如果一个类中没有构造器也没有main方法，这时候会默认一个无参构造；这个构造器会将所有实例域设置为默认值，即实例域里，数值型为0，布尔型为false，对象变量为null。
（3）如果类中至少有一个构造器，并且这个构造器不带有参数，这时，如果在构造对象时没有提供参数就会视为不合法的。
（4）如果构造器中没有显示地给实例域赋值，这时会自动地赋为默认值：数值为0，布尔值为false，对象引用为null。这样，会影响代码的可读性。
（5）注：在c++中，不能直接初始化类的实例域，所有的域都必须在构造器里面设置。
三、包
使用包的主要原因是保证类名的唯一性，当两个程序员各自建立了两个类名相同的类时，只要将类放在不同的包中，就不会产生冲突。
为保证包的绝对唯一性，sun公司建议将公司的因特网域名（这是独一无二的）以逆序形式作为包名。例如：banana.com，逆序变为com.banana。
从编译器角度来看，嵌套的包之间没有任何联系。
一个类可以使用包中的所有类，以及其他包中的公有类（public class）。访问另一个包中的公有类的两种方法：
（1）每个类名之前添加完整的包名（繁琐），例如：java.time.LocalDate today =java.time.LocalDate.now();
（2）我们常用的方法是使用import导入包，import语句应位于源文件的顶部（位于package语句后面），这样就无需在前面加前缀了。例如：import java.time.LocalDate;这时候就可以使用：LocalDatetoday=LocalDate.now();
当两个包中含有相同的类名时，在使用时，编译器无法识别要使用哪个类，这时候我们可以在使用的语句加前缀。例如，两个不同的类中都含有Date类时，可以这样表示：
注：在 C-H■ 中， 与 包 机 制 类 似 的 是 命 名 空 间（namespace)。 在Java 中，package 与import 语句类似于C+H■ 中的namespace 和using 指令。
静态导入：如：import static java.lang.System.*;这时候就可以这样写了out.println();但是，这样降低了程序的可读性。
四、类设计的技巧
1、保证数据的私有。
2、数据一定要初始化。
3、不要在类中使用过多的私有类型。
4、一个类的职责不应该太多或者太少。
5、类名和方法名尽可能体现其职责。
6、优先使用不可变的类。