面向对象程序设计概述面向过程：程序=算法+数据结构
面向对象：程序=对象+对象+…
面向对象将问题域划分成一个个对象，并将与特定问题相关的算法与数据结构封装在特定的对象中。
类类是构造对象的模板。
类的三个主要特性：
封装，继承，多态。
对象对象是类的实例。
对象的三个主要特性：
行为，状态，标识。
使用预定义类Java类库中有上千种类，要想使用它们，首先构造对象，指定其初始状态，然后，对对象应用方法。例：
Date birthday = new Date();
String s = new Date().toString();
对象与对象变量对象是堆内存中的实体。
对象变量存在于栈内存，是对对象实体的引用，或者说对象变量的值就是对象实体的内存地址。
更改器方法与访问器方法通常给访问器方法名加前缀get，get方法仅查看并返回对象的状态。
通常给更改器方法名加前缀set，set方法对对象的状态进行修改。

1. import java.text.DateFormatSymbols;
   
2. import java.util.*;
   
3. 
   
4. public class HelloJava
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 GregorianCalendar d = new GregorianCalendar();
   
9.                
   
10.                 int today = d.get(Calendar.DAY_OF_MONTH);
    
11.                 int month = d.get(Calendar.MONTH);
    
12.                
    
13.                 d.set(Calendar.DAY_OF_MONTH, 1);
    
14.                
    
15.                 int weekday = d.get(Calendar.DAY_OF_WEEK);
    
16.                
    
17.                 int firstDayOfWeek = d.getFirstDayOfWeek();
    
18.                
    
19.                 int indent = 0;
    
20.                 while (weekday != firstDayOfWeek)
    
21.                 {
    
22.                         indent++;
    
23.                         d.add(Calendar.DAY_OF_MONTH, -1);
    
24.                         weekday = d.get(Calendar.DAY_OF_WEEK);
    
25.                 }
    
26.                
    
27.                 String[] weekdayNames = new DateFormatSymbols().getShortWeekdays();
    
28.                 do
    
29.                 {
    
30.                         System.out.printf("%4s", weekdayNames[weekday]);
    
31.                         d.add(Calendar.DAY_OF_MONTH, 1);
    
32.                         weekday = d.get(Calendar.DAY_OF_WEEK);
    
33.                 }
    
34.                 while (weekday != firstDayOfWeek);
    
35.                 System.out.println();
    
36.                 for (int i = 1; i <= indent; i++)
    
37.                         System.out.print("    ");
    
38.                
    
39.                 d.set(Calendar.DAY_OF_MONTH, 1);
    
40.                 do
    
41.                 {
    
42.                         int day = d.get(Calendar.DAY_OF_MONTH);
    
43.                         System.out.printf("%3d", day);
    
44.                        
    
45.                         if (day == today)
    
46.                                 System.out.print("*");
    
47.                         else
    
48.                                 System.out.print(" ");
    
49.                        
    
50.                         d.add(Calendar.DAY_OF_MONTH, 1);
    
51.                         weekday = d.get(Calendar.DAY_OF_WEEK);
    
52.                        
    
53.                         if (weekday == firstDayOfWeek)
    
54.                                 System.out.println();
    
55.                 }
    
56.                 while (d.get(Calendar.MONTH) == month);
    
57.                
    
58.                 if (weekday != firstDayOfWeek)
    
59.                         System.out.println();
    
60.         }
    
61. }

复制代码

用户自定义类
class ClassName
{
field1
field2
…
constructor1
constructor2
…
method1
method2
…
}

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.                 staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
   
9.                 staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
   
10.                 staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15);
    
11.                
    
12.                 for (Employee e : staff)
    
13.                         e.raiseSalary(5);
    
14.                
    
15.                 for (Employee e : staff)
    
16.                         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay=" + e.getHireDay());
    
17.         }
    
18. }
    
19. 
    
20. class Employee
    
21. {
    
22.         private String name;
    
23.         private double salary;
    
24.         private Date hireDay;
    
25.        
    
26.         public Employee(String n, double s, int year, int month, int day)
    
27.         {
    
28.                 name = n;
    
29.                 salary = s;
    
30.                 GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
    
31.                 hireDay = calendar.getTime();
    
32.         }
    
33.        
    
34.         public String getName()
    
35.         {
    
36.                 return name;
    
37.         }
    
38.        
    
39.         public double getSalary()
    
40.         {
    
41.                 return salary;
    
42.         }
    
43.        
    
44.         public Date getHireDay()
    
45.         {
    
46.                 return hireDay;
    
47.         }
    
48.        
    
49.         public void raiseSalary(double byPercent)
    
50.         {
    
51.                 double raise = salary * byPercent / 100;
    
52.                 salary += raise;
    
53.         }
    
54. }

复制代码

静态域与静态方法
静态域可以将类中的域分为静态域和实例域。
实例域是指本类所有对象都各自拥有的域。
静态域是指本类所有对象都共享的域。
实例域属于对象，存储在堆中。
静态域属于类，存储在静态存储区中。
只要类已经载入内存，即使还没有创建对象，静态域也已经存在了。
静态方法可以将类中的方法分为实例方法和静态方法。
调用实例方法，须用对象.实例方法的形式，调用时，将在栈内存中开辟空间。
调用静态方法，可用类名.静态方法的形式，静态方法随着类的加载已经存在于静态存储区，不会在调用时开辟内存。
静态方法可以访问本类的静态域，但不能访问本类对象的实力域。
main方法每一个类可以有一个main方法，这个特性常用于对类进行单元测试。

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

复制代码

感觉从地址的角度来理解Java面向对象机制会比较顺利。