2018.04.3 Java学习小记

1.理解程序

 import java.time.*;
 
 public class EmployeeTest
   {
   	public static void main(String[]args)
   	{
   		Employee[]staff = new Employee[3];
   		
   		staff[0]=new Employee("Tian Yu",75000,1984,12,15);
   		staff[1]=new Employee("Guang Jie",50000,1989,10,1);
   		staff[2]=new Employee("Jing Tian",40000,1990,3,15);
   		
   		for(Employee e:staff)
   		e.raiseSalary(5);
   		
   		for(Employee e:staff)
   		  System.out.println("name="+e.getName()+",salary="+e.getSalary()+",hireDay="+e.getHireDay());
   	}
   }
   
   class Employee
   {
   	private String name;
   	private double salary;
   	private LocalDate hireDay;
   	
   	public Employee(String n,double s,int year,int month,int day)
  {
  	name=n;
  	salary=s;
  	hireDay=LocalDate.of(year,month,day);
  }
  public String getName()
  {
  	return name;
  }
  public double getSalary(){
    return salary;
}
public LocalDate getHireDay(){
	  return hireDay;
}
  public void raiseSalary(double byPercent)
{
	double raise=salary*byPercent/100;
	salary+=raise;
}
   }

2.

不能在构造器中定义与实例域重名的局部变量，例如：

pubic Emlployee(String n,double s,int year,int month,int day)
｛
name=n,
salary=s;
LocalDate hireDay=LocalDate.of(year,month,day):
}

以上代码是正确的，但是不能写成

public Employee(String n,double s,int year,int month,int day)
{
String name = n,
double salary = s;
...
}

以上写法是错误的

3.

pubic Emlployee(String n,double s,int year,int month,int day)
｛
name=n,
salary=s;
LocalDate hireDay=LocalDate.of(year,month,day):
}

是Employee类的构造器，在构造Employee类的对象时，构造器会运行，以便将实例域初始化为所希望的状态。

例如，当使用下面这条代码创建Employee实例时；

new Employee("James Bond",10000,1950,1,1)

将会把实例域设置为：

name = “James Bond";

salary= 100000;

hireDay = LocalDate.of(1950,1,1);

有关构造器需要记住：

① 构造器与类同名；

② 每个类可以有一个以上的构造器；

③ 构造器可以有0个、1个或多个参数；

④ 构造器没有返回值；

⑤ 构造器总是伴随着new操作一起调用；

4.

方法用于操作对象以及存取它们的实例域。例如，方法：

public void raiseSalary(double byPercent)

{

double raise =  salary * byPercent / 100;

salary += raise;

}

将调用这个方法的对象salary实例域设置为新值。看看下面这个调用：

number007.raiseSalary(5);

它具体执行的命令为：

double raise = number007.salary * 5 /100

number007.salary+=raise;

关键字this表示隐式参数，需要的话，可以这样编写raiseSalary方法：

public void raiseSalary(double byPercent)

{

  double raise = this.salary*byPercent/100;

  this.salary += raise;

}

5.

getName方法，getSalary方法和getHireDay方法：

public String getName()
{
  return name;
}
public double getSalary()
{
  return salary;
}
pubic LocalDate getHireDay()
{ 
  return hireDay;
}

如果将name、salary、和hireDay标记为public用来取代独立的访问器方法，会导致name域容易受到外界的破坏，有些时候，需要获得或设置实例域的值。因此，应该提供下面三项类容：

① 一个私有的数据域；

② 一个公有的域访问其方法；

③ 一个公有的域更改器方法。

注意：不要编写返回引用可变对象的访问器方法，例如Date类，这样会破坏封装性！如果需要返回一个可变对象的引用，应该首先对它进行克隆(clone)

6. 

一个方法可以访问所属类的所有对象的私有数据

例如用来比较两个雇员的equals方法

class Employee
{
...
   public boolean equals(Employee other)
   {
      return name.equals(other.name);
}
}

典型的调用方式是

if(harry.equals(boss))

这个方法可以访问harry和boss的私有域，这是合法的，原因是boss是Employee类对象，而Employee类的方法可以访问Employee类的任何一个对象的私有域

7.

对于private方法，当难以实现或者不再需要时，只要方法是私有的，类的设计者就可以确信：它不会被外部的其它类操作调用，可以将其删去。如果方法是共有的，就不能将其删去，因为其他的代码很可能依赖它。

8.

可以将实例域定义为final，这样可以确保，在每一个构造器执行之后，这个域的值被设置，并且在后面的操作中，不能够再对它进行修改，例如，可以将Employee类中的name域声明为final：

class Employee
{
  private final String name;
}

final修饰符大都应用于基本（primitive）类型域，或不可变（immutable）类的域（如果类中的每个方法都不会改变其对象，这种类就是不可变的类。例如，String类就是一个不可变的类

9.

如果将域定义为static，每个类中只有一个这样的域。而每一个对象对于所有的实例域却都有自己的一分拷贝，例如，给Employee类添加一个实例域id和一个静态域nextId：

class Employee
｛
   private static int nextId = 1;
   private int id;
   ...
}

现在，每个雇员对象都有一个自己的id域，但是这个类的所有实例将共享一个nextId域。下面实现一个简单的方法：

public void setId()
{
 id=nextId;
 nextId++;
}

假定为harry设定雇员标识码：

harry.setId();

harry的id域被设置为静态域nextId当前的值，并且静态域nextId的值加1：

harry.id=Employee。nextId;
Employee.nextId++;

10.

静态变量使用得比较少，静态常量却使用得比较多，例如，在Math类中定义了一个静态常量：

public class Math
{
  ...
  pubic static final double PI=3.14159265358979323846;
  ...
}

在程序中，可以采用Math.PI的形式获得这个常量

另一个多次使用的静态常量是System.out，它在System类中声明：

public class System
{
  ...
  public static final PrintStream out = ...;
  ...
}

因为公有常量（即final域）中，out被声明为final，所以，不允许再将其他打印流赋给它

11.

静态方法是一种不能向对象实施操作的方法，例如，Math.pow(x,a)计算幂X^a，在运算时，不使用任何Math对象，换句话说，没有隐式的参数，可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数表示这个方法的隐式参数）