为什么我看很多书上都这么写呢?这是为什么啊?
public class ABCDEF
{
   ABCDEF()
   {
     ……
     主程序;
     ……
   }
   void main()
   {
     new ABCDEF();
    }
}
为什么主程序不写在main方法里,而非要写在构造函数里呢?

解决方案 »

  1.   

    那为什么我看的那本书上很多都是写在构造里呢?是不是有什么好处啊?你们写的时候一般写在哪儿啊?是main还是构造里啊?
      

  2.   

    我是初学者,C语言转java,习惯于C语言模式,给你些例子看一看:public class YangHui {
    public static void main(String[] args) {
    int i,j;
    int[] yanghui = new int[9];
    System.out.println("杨辉三角:");

    yanghui[0] = 1;
    for (i = 0; i < yanghui.length; i++) {
    for (j = i; j > 0; j--) {
    yanghui[j] = yanghui[j] + yanghui[j-1]; }
    for (j = 0; j <yanghui.length - i - 1; j++) {  
    System.out.print("\t");
    }
    for (j = 0; j <= i; j++) {  
    System.out.print(yanghui[j]+"\t\t");
    }
    System.out.println();
    }
    }
    }//勉强写了一个,不知是否是你想要的。图形没有粘贴好,很痛苦。
    public class Test {
    public static int N = 5;

    public static void outPut(char c){

    System.out.println(c+"图:");
    }
    public static void mapA(){
    outPut('A');
    for (int i = 0; i < N; i++) {
    for (int j = 0; j < i + 1; j++) {
    System.out.print('*');
    }
    System.out.println();
    }
    }
    public static void mapB(){
    outPut('B');
    for (int i = 0; i < N; i++) {
    for (int j = 0; j <= i ; j++) {
    if(i==2&&j==1||((j==1||j==2)&&i==3)) 
    System.out.print(" ");
    else 
    System.out.print('*');
    }
    System.out.println();
    }
    }
    public static void mapC(){
    outPut('C');
    for (int i = 0; i < N; i++) {
    for (int j = 0; j < N - i - 1; j++) {
    System.out.print(" ");
    }
    for (int j = 0; j < 2 * i + 1; j++) {
    System.out.print('*');
    }
    System.out.println();
    }
    }
    public static void mapD(){
    outPut('D');
    char[][] arr = new char[N][2*N-1];
    for (int i = 0; i < N; i++) {
    for (int j = 0; j < 2 * N - 1 ; j++) {
    arr[i][j] = ' ';
    if(i==N-1||i+j==4||j-i==4) 
    arr[i][j] = '*';
    }
    }
    for (int i = 0; i < N; i++) {
    for (int j = 0; j < 2 * N - 1; j++) {
    System.out.print(arr[i][j]);
    }
    System.out.println();
    }
    }
    public static void mapE(){
    outPut('E');
    for(int i=0;i<N;i++){
    for(int j=0;j<N-2*Math.abs(N/2-i);j++)
    System.out.print('*');
    System.out.println();
    }
    }
    public static void mapF(){
    outPut('F');
    for (int i = 0; i < N; i++) {
    for (int j = 0; j < N ; j++) {
    if(i == 0 || i == N-1) 
    System.out.print('*');
    else if(j == 0 || j == 2)
    System.out.print('*');
    if(j == 1 && i != 0 && i != N-1) 
    System.out.print(" ");
    }
    System.out.println();
    }
    }
    public static void main(String[] args) {
    mapA();
    mapB();
    mapC();
    mapD();
    mapE();
    mapF();
    }
    }
    public class NumberCount {
    public static int count[] = {0,0,0,0,0,0,0,0,0,0};
    public static void countNumber(int n){
    count[n]++;
    }
    public static void print(){
    System.out.println("\n统计结果如下:");
    for (int i = 0; i < count.length; i++) {
    System.out.println("有"+"'"+i+"':"+count[i]+"个!");
    }
    }
    public static void main(String[] args) {
    int i;
    int[] number = new int[100];
    for (i = 0; i < number.length; i++) {
    number[i] = (int)(Math.random()*10);
    }
    System.out.print("100个随机数如下:");
    for (i = 0; i < number.length; i++) {
    if(i%10 == 0)
    {
    System.out.println("");
    }
    System.out.print(number[i]+" ");
    }
    for (i = 0; i < number.length; i++) {
    countNumber(number[i]);
    }
    print();
    }
    }
      

  3.   

    这个因为构造函数,通常是作为创建类实例时第一时间执行的代码、
    而mian方法 并不是所有的类都有main方法! 当ABCDEF这个类不做为主类时,也就是main方法不会被执行到了! 如果把主程序写在构造函数里,也就是不管是不是主类都会执行到啦。 愚见!
      

  4.   


    看到你把main错写成mian了,我回想起了一些往事我一哥们,写单片机上的C语言程序,出错,让我看
    我一看也看不出什么不对来,现象是,如果只有一个主函数,那么程序是正常的,如果写个延时函数,则程序就不运行了,即使延时函数里什么也不写,主函数也不调用延时函数,也不行。后来发现原来主函数写成mian了,但是只有主函数的时候程序执行正常,我当时就以为mian和main是通用的了,后来想一想,原来:程序没有main函数时,自动招待第一个函数。
      

  5.   

    写哪儿都可以。
    写构建器中好处是每次其他程序中new一个该对象的时候,都可以执行这些代码。
    写main中好处是可以直接被用户执行。
    根据需要做选择好了。
      

  6.   

    我也不太会。。
    但是也得说说我的想法
    写在一个构造函数里,在main里new那个对象的时候就执行了构造函数里的主程序了。。
    跟直接写在main里是一个的。。同时,写在了构造函数里扩展性比较好。。
      

  7.   

    通常我们写函数要完成一些功能,
      然而实际问题中往往需要很多函数去完成很多功能。
      构造函数就像一个箱子封装了很多命令和方法,我们把同一类或者常用的方法封装在构造函数里便于操作和控制,更利于查找错误维护方便,如果都写在main()方法里会导致main()方法里代码过于多与复杂也不利于控制和检查。
      

  8.   

        主函数是程序的入口。   java纯面向对象。  就是你把所有的实现类写好了之后 在mian函数里 用到什么就new什么。   所谓的写在构造方法里。 无非就是设计模式。 lz可以多看一些设计模式的书,如果需要我这里有pdf。 可以发给你。
      

  9.   


    尽量吧方法模块化,使main()变得简单,是程序变得容易读懂。
      

  10.   

    这个等你以后java学久了就会知道为什么要这样做了。
      

  11.   

    构造函数的作用是初始化,作为面向对象的语言一般是不把主要的代码写在main函数里面的,其他的不想多说,学习时间久点的话,就会知道其中的妙用
      

  12.   

    每个方法都是一个功能(最好是一个)的实现
    构造方法是用来实例化对象调用的 同时也可以给成员变量赋值 或者实现其他的功能
    main方法就不用说了 也可以实现其他的功能
    其他的方法就自己定义了 看需要实现什么功能了 功能最好单一 易懂 方便修改等等
      

  13.   

    这个问题从面向对象封装的角度来说,可能要好一些!类有属性和方法,方法又有构造方法和普通方法,构造方法用于完成该类对象的共同的一些初始化的工作,普通方法就是该类对象的一个功能,要把属于类的方法封装在类里面,所以上面的代码那样写了。如果直接放在main方法里面,就破坏了封装性,并且使代码变得难以阅读。
      

  14.   


    请问能发给我一下吗?不胜感激……
    我的联系邮箱是[email protected]
    非常感谢……
      

  15.   

    没必要关注这个吧??看需要来写自己的代码!!就像有的时候还需写在static代码块中呢!!
      

  16.   

    这个得从面向对象的角度去考虑。该类在项目中的使用,肯定需要初始化该类的对象,然后用这个对象去调用他自身的方法。在该类的构造函数中将初始化的操作全部完成,那么初始化该类的一个对象时即可实现类中全部属性的初始化。而一个类中的main()方法都是静态方法,不依赖于类的存在,主要用于测试一个类的功能。
      

  17.   

    这样可以提高代码的复用,想用的时候就new!
      

  18.   

    这就是Java不同于C语言的地方啊!!好好学习,我也是初学的,但这个还是知道的
      

  19.   

    #18楼 得分:0回复于:2010-10-05 23:39:54主函数是程序的入口。 java纯面向对象。 就是你把所有的实现类写好了之后 在mian函数里 用到什么就new什么。 所谓的写在构造方法里。 无非就是设计模式。 lz可以多看一些设计模式的书,如果需要我这里有pdf。 可以发给你。 
    ============
    正解
      

  20.   

    mian()函数是主函数··里面如果装太多代码的话不符合Java的封装原则··封装不仅仅让程序看起来更顺眼··而且更灵活··
      

  21.   

    这是个比较好的代码格式可能比较好理解,是在实例化一个类ABCDEF时调用了构造函数,因为main方法是是一个静态方法不属于ABCEDF类,在main方法中new一个对象的时候表示初始化了一个ABCDEF对象时调用构造方法,如果在main中写代码则表示是在执行main方法而已。
      

  22.   

    main()方法是程序的入口,程序要运行,就要从main()里面运行。。(applet等特殊情况除外。。)写在构造函数里,不一定会运行。。写在main()里,一定会运行。。写在构造函数里比较灵活,随时可以调用。。
      

  23.   

    main()方法是程序的入口,程序要运行,就要从main()里面运行。。(applet等特殊情况除外。。)写在构造函数里,不一定会运行。。写在main()里,一定会运行。。写在构造函数里比较灵活,可以作为一个独立的模块,在程序的各个位置都可随时调用。。而main()里面不行。。
      

  24.   

    写在外面就是面向对象 并不是所有的都有main函数的
      

  25.   

    主方法main()是用来作为客户端的,所以一般尽量少写代码,这样更符合面向对象的思想。
      

  26.   

    main 方法要尽量简洁 运行是从这开始的 程序用到 才调用函数