方法参数
一个方法不能修改一个基本数据类型的参数。
一个方法可以改变一个对象参数的状态。
一个方法不能让对象参数引用一个新的对象。
总之，调用方法时，参数的传递方式是值传递。
当参数是引用数据类型时，实际传递的是所引用内存实体的地址值。

1. public class HelloJava
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 System.out.println("Testing tripleValue:");
   
6.                 double percent = 10;
   
7.                 System.out.println("Before: percent=" + percent);
   
8.                 tripleValue(percent);
   
9.                 System.out.println("After: percent=" + percent);
   
10.                
    
11.                 System.out.println("\nTesting tripleSalary:");
    
12.                 Employee harry = new Employee("Harry", 50000);
    
13.                 System.out.println("Before: salary=" + harry.getSalary());
    
14.                 tripleSalary(harry);
    
15.                 System.out.println("After: salary=" + harry.getSalary());
    
16.                
    
17.                 System.out.println("\nTesting swap:");
    
18.                 Employee a = new Employee("Alice", 70000);
    
19.                 Employee b = new Employee("Bob", 60000);
    
20.                 System.out.println("Before: a=" + a.getName());
    
21.                 System.out.println("Before: b=" + b.getName());
    
22.                 swap(a, b);
    
23.                 System.out.println("After: a=" + a.getName());
    
24.                 System.out.println("After: b=" + b.getName());
    
25.         }
    
26.        
    
27.         public static void tripleValue(double x)
    
28.         {
    
29.                 x = 3 * x;
    
30.                 System.out.println("End of method: x=" + x);
    
31.         }
    
32.        
    
33.         public static void tripleSalary(Employee x)
    
34.         {
    
35.                 x.raiseSalary(200);
    
36.                 System.out.println("End of method: salary=" + x.getSalary());
    
37.         }
    
38.        
    
39.         public static void swap(Employee x, Employee y)
    
40.         {
    
41.                 Employee temp = x;
    
42.                 x = y;
    
43.                 y = temp;
    
44.                 System.out.println("End of method: x=" + x.getName());
    
45.                 System.out.println("End of method: y=" + y.getName());
    
46.         }
    
47. }
    
48. 
    
49. class Employee
    
50. {
    
51.         private String name;
    
52.         private double salary;
    
53. 
    
54.         public Employee(String n, double s)
    
55.         {
    
56.                 name = n;
    
57.                 salary = s;
    
58.         }
    
59.        
    
60.         public String getName()
    
61.         {
    
62.                 return name;
    
63.         }
    
64.        
    
65.         public double getSalary()
    
66.         {
    
67.                 return salary;
    
68.         }
    
69.        
    
70.         public void raiseSalary(double byPercent)
    
71.         {
    
72.                 double raise = salary * byPercent / 100;
    
73.                 salary += raise;
    
74.         }
    
75. }

复制代码

对象构造
如果多个方法有相同的名字，不同的参数，便产生了重载。
如果在构造器中没有显示地给域赋予初值，那么就会被自动地赋为默认值：数值为0，布尔值为false，对象引用为null。
如果类中没有构造器，系统会提供一个无参数的构造器，这个构造器将所有实力域设置为默认值。如果类中有构造器，系统不会提供构造器。
如果构造器的参数名与实例域名相同，可以采用this指针完成初始化，例如：
public Employee(String name, double salary)
{
this.name = name;
this.salary = salary;
}
如果构造器的第一个语句形如this(…)，这个构造器将调用同一个类的另一个构造器。这种处理方式使得对公共构造器代码部分只编写一次即可。
还可以使用初始化块初始化域，初始化块先于构造器执行。

1. import java.util.*;
   
2. 
   
3. public class HelloJava
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Employee[] staff = new Employee[3];
   
8.                
   
9.                 staff[0] = new Employee("Harry", 40000);
   
10.                 staff[1] = new Employee(60000);
    
11.                 staff[2] = new Employee();
    
12.                
    
13.                 for (Employee e : staff)
    
14.                         System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary=" + e.getSalary());
    
15.         }
    
16. }
    
17. 
    
18. class Employee
    
19. {
    
20.         private static int nextId;
    
21.        
    
22.         private int id;
    
23.         private String name = "";
    
24.         private double salary;
    
25.        
    
26.         static
    
27.         {
    
28.                 Random generator = new Random();
    
29.                 nextId = generator.nextInt(10000);
    
30.         }
    
31.        
    
32.         {
    
33.                 id = nextId;
    
34.                 nextId++;
    
35.         }
    
36. 
    
37.         public Employee(String n, double s)
    
38.         {
    
39.                 name = n;
    
40.                 salary = s;
    
41.         }
    
42.        
    
43.         public Employee(double s)
    
44.         {
    
45.                 this("Employee #" + nextId, s);
    
46.         }
    
47.        
    
48.         public Employee()
    
49.         {
    
50.                
    
51.         }
    
52.        
    
53.         public String getName()
    
54.         {
    
55.                 return name;
    
56.         }
    
57.        
    
58.         public double getSalary()
    
59.         {
    
60.                 return salary;
    
61.         }
    
62.        
    
63.         public int getId()
    
64.         {
    
65.                 return id;
    
66.         }
    
67. }

复制代码

包
标准Java包处于java和javax包层次中。使用包的主要原因是确保类名的唯一性。从编译器的角度看，嵌套的包之间没有任何关系。
使用import语句导入特定类或整个包，使用import static …导入静态方法和静态域。
使用package语句将类放入包中。

1. import com.horstmann.corejava.*;
   
2. 
   
3. import static java.lang.System.*;
   
4. 
   
5. public class HelloJava
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 Employee harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);
   
10.                
    
11.                 harry.raiseSalary(5);
    
12.                
    
13.                 out.println("name=" + harry.getName() + ",salary=" + harry.getSalary());
    
14.         }
    
15. }

复制代码

1. package com.horstmann.corejava;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class Employee
   
6. {
   
7.         private String name;
   
8.         private double salary;
   
9.         private Date hireDay;
   
10.        
    
11.         public Employee(String n, double s,int year, int month, int day)
    
12.         {
    
13.                 name = n;
    
14.                 salary = s;
    
15.                 GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
    
16.                 hireDay = calendar.getTime();
    
17.         }
    
18.        
    
19.         public String getName()
    
20.         {
    
21.                 return name;
    
22.         }
    
23.        
    
24.         public double getSalary()
    
25.         {
    
26.                 return salary;
    
27.         }
    
28.        
    
29.         public Date getHireDay()
    
30.         {
    
31.                 return hireDay;
    
32.         }
    
33.        
    
34.         public void raiseSalary(double byPercent)
    
35.         {
    
36.                 double raise = salary * byPercent / 100;
    
37.                 salary += raise;
    
38.         }
    
39. }

复制代码

没有指定public或private的类，方法，域可以被同一个包中的所有方法访问。

帖子的默认排序是按最后回复排序，建议新人发完帖后自行回复一次。