1. public class WeekDay1 {
   
2.         
   
3.                 private WeekDay1(){}//这里为什么要建一个构造方法，作用是什么？
   
4.                
   
5.                 public final  static WeekDay1 SUN=new WeekDay1();
   
6.                 public final  static WeekDay1 MON=new WeekDay1();
   
7.                
   
8.                 public  WeekDay1 nextDay(){
   
9.                         if(this==SUN)
   
10.                                 return MON;
    
11.                         else return SUN;
    
12.                 }
    
13.                 public String toString(){
    
14.                         return this==SUN?"SUN":"MON";
    
15.                 }
    
16.         }
    

复制代码

问题如代码：为什么要建一个构造方法，作用是什么？

如果你不写构造方法的话，系统会给你创建一个默认的构造方法。
构造方法是类中一种特殊的方法，它一般由系统在创建对象（即类实例化）时自动调用。构造方法是对象中第一个被执行的方法，主要用于申请内存、对类的成员变量进行初始化等操作。构造方法虽然也位于类里面，但在很多情况下与普通成员方法表现不同，所以也有人认为它不是成员方法，而且将其称为“构造器”。

将一个类的访问权限设置为private，是将这个类私有化，这个类将隐藏其内部的所有数据，以免用户直接访问它，不让该类被其他程序建立对象。保证了其内部数据的安全性
例如：

1. public class ArrayTool
   
2. {
   
3.     //空参数构造函数。
   
4.     private ArrayTool(){}
   
5.     //获取一个整形数组中的最大值。
   
6.     public static int getMax(int[] arr)
   
7.      {
   
8.          int max = 0;
   
9.          for(int x=1; x<arr.length; x++)
   
10.               {
    
11.                    if(arr[x]>arr[max])
    
12.                    max = x;
    
13.               }
    
14.           return arr[max];
    
15.        }
    
16. 
    
17.              //获取一个整形数组中的最小值。
    
18.          public static int getMin(int[] arr)
    
19.          {
    
20.             int min = 0;
    
21.            for(int x=1; x<arr.length; x++)
    
22.                {
    
23.                     if(arr[x]<arr[min])
    
24.                     min = x;
    
25.                 }
    
26.              return arr[min];
    
27.            }
    
28.            //给int数组进行选择排序。
    
29.            public static void selectSort(int[] arr)
    
30.             {
    
31.                     for (int x=0; x<arr.length-1 ; x++ )
    
32.                     {
    
33.                           for(int y=x+1; y<arr.length; y++)
    
34.                            {
    
35.                                  if(arr[x]>arr[y])
    
36.                                     {
    
37.                                         swap(arr,x,y);
    
38.                                     }
    
39.                            }
    
40.                      }
    
41.               }
    
42.              //给int数组进行冒泡排序。
    
43.             public static void bubbleSort(int[] arr)
    
44.              {
    
45.                   for (int x=0; x<arr.length-1 ; x++ )
    
46.                    {
    
47.                          for(int y=0; y<arr.length-x-1; y++)
    
48.                          {
    
49.                                if(arr[y]>arr[y+1])
    
50.                                 {
    
51.                                    swap(arr,y,y+1);
    
52.                                 }
    
53.                          }
    
54.                    }
    
55.            }
    
56. //给数组中元素进行位置的置换。
    
57.        private static void swap(int[] arr,int a,int b)
    
58.          {
    
59.               int temp = arr[a];
    
60.              arr[a] = arr[b];
    
61.               arr[b] = temp;
    
62.          }
    
63. //用于打印数组中的元素。打印形式是：[elemet1, element2, ...]
    
64.         public static void printArray(int[] arr)
    
65.           {
    
66.                System.out.print("[");
    
67.                for(int x=0; x<arr.length; x++)
    
68.                 {
    
69.                   if(x!=arr.length-1)
    
70.                    System.out.print(arr[x]+", ");
    
71.                       else
    
72.                    System.out.println(arr[x]+"]");
    
73.                 }
    
74.          }
    
75. }
    
76. 
    

复制代码

public class WeekDay1 {
        
                private WeekDay1(){}//这里为什么要建一个构造方法，作用是什么？  //这里的构造函数被private修饰，可以防止外界创建对象。 使程序更安全。
                                                                                                             //当然去掉这个构造函数也可以运行。虚拟机会默认有一个无参构造。只不过外界就可以                                              / /随意来创建对象。这就好像一件东西是属于我们自己的。我们不希别人随意来用。就用到private 封装起来，你想用的话，由我来提供一种方式。               
                public final  static WeekDay1 SUN=new WeekDay1();
                public final  static WeekDay1 MON=new WeekDay1();
               
                public  WeekDay1 nextDay(){
                        if(this==SUN)
                                return MON;
                        else return SUN;
                }
                public String toString(){
                        return this==SUN?"SUN":"MON";
                }
        }

将构造方法私有，不让创建新对象，只能获取你定义好的对象。
枚举的概念不就是某一类型只能使用你自己定义好的对象，不能创建新对象么

这个主要是private的构造方法。别的类用不了。

自动的做一些初始操作，让你的对象真正成为可用的有意义的对象，把对象的基本初始操作封装起来，这也是OO的基本特征。

private WeekDay1(){}//构造方法是用于对类的初始化，同样这里的构造方法是初始化WeekDay1这个类的，只不过这是一个空的构造方法，没有内容。
而且它被private修饰，只能被本来对象调用。
public final static WeekDay1 SUN=new WeekDay1();//创建对象SUN用final修饰，不能被修改，而且是静态的，是随类的加载而加载。这样创建的几个对象，枚举也是这种原理。

嗯，当然可以运行了，因为每个类都有一个无参的构造方法，只要不是抽象类，基本上就不用写

wanggang 发表于 2013-3-13 14:16
构造方法就是用来初始化的，因为带有final标记的都是常量是不能更改的，但常量也得有值，他用构造方法就是 ...

我把构造方法删除程序也可以运行呀

构造方法就是用来初始化的，因为带有final标记的都是常量是不能更改的，但常量也得有值，他用构造方法就是让常量SUN可以变成MON,只是举个例子

貌似用它来对对象进行构造，进行初始化 我也不太懂