JAVA中main()方法可以继承吗？

JAVA中main()方法可以被继承吗？


--------------------------------------------------------------------
以下内容为自动编辑的内容，并非楼主的发贴内容,此仅用于显示而已，并无任何其他特殊作用
楼主【shenfang1234】截止到2008-08-05 11:14:06的历史汇总数据(不包括此帖)：
发帖的总数量:0                        发帖的总分数:0                        每贴平均分数:0                        
回帖的总数量:2                        得分贴总数量:1                        回帖的得分率:50%                      
结贴的总数量:0                        结贴的总分数:0                        
无满意结贴数:0                        无满意结贴分:0                        
未结的帖子数:0                        未结的总分数:0                        
结贴的百分比:---------------------结分的百分比:---------------------
无满意结贴率:---------------------无满意结分率:---------------------
如何结贴请参考这里：http://topic.csdn.net/u/20080501/09/ef7ba1b3-6466-49f6-9d92-36fe6d471dd1.html
取消马甲机器人，请点这里： http://www.java2000.net/mycsdn/robotStop.jsp?usern=shenfang1234

75 个解决方案

#1

main是个可以看成静态方法，可以通过调用静态方法调用，不能继承

#2

请先使用脚趾头想一下再提问

#3

What's your purpose?

#4

呵呵 有趣的问题...

#5

static方法能不能继承，还有待商讨。看怎么理解了


子类可以直接调用父类的static方法。


可以通过类名直接来调用，也可以通过对象来调用。

#6

public class TestFather {
    public static String s(String str){
    	return str;
    }
}



public class TestSun extends TestFather{

  public static void main(String[] args){
	System.out.println(TestFather.s("abc"));
        System.out.println(new TestFather().s("abc"));
	System.out.println(TestSun.s("abc"));
        System.out.println(new TestSun().s("abc"));
	  
  }

}

#7

//第一个类
public class Test
{
	public static void main(String args[])
	{
		System.out.println("a main method is running now");
	}
}
//第二个类
public class Test2 extends Test
{

}
/*
  编译并运行第二个类,打印出
a main method is running now
由此证明,main方法一样被继承了
没实验的人别乱吹
*/

#8

我可以负责的告诉你 不能！

#9

引用 7 楼 rypgood 的回复:

Java code
//第一个类
public class Test
{
    public static void main(String args[])
    {
        System.out.println("a main method is running now");
    }
}
//第二个类
public class Test2 extends Test
{
    
}
/*
  编译并运行第二个类,打印出
a main method is running now
由此证明,main方法一样被继承了
没实验的人别乱吹
*/

汗！你真試驗了？

#10

引用 7 楼 rypgood 的回复:

Java code
//第一个类
public class Test
{
    public static void main(String args[])
    {
        System.out.println("a main method is running now");
    }
}
//第二个类
public class Test2 extends Test
{
    
}
/*
  编译并运行第二个类,打印出
a main method is running now
由此证明,main方法一样被继承了
没实验的人别乱吹
*/

汗，我可以非常肯定的告诉你----绝对不可能！！！ 告诉我们你咋试的？？？

#11

别告诉我你两个类写在一个java文件里运行的？
真是那样的话你运行的也是Test类，和Test2一点儿关系都没有。。。

#12

呵呵~~~~~~
有趣 ~~~

#13

引用 5 楼 jishu_vip 的回复:

static方法能不能继承，还有待商讨。看怎么理解了 


子类可以直接调用父类的static方法。 


可以通过类名直接来调用，也可以通过对象来调用。 

你这样说不通。
static定义的域或方法是属于类的，不属于对象。所谓的可以通过对象来调用，让人匪夷所思！
至于阻止被继承，应该是 final！

#14

还有static方法是可以被重载的，典型的例子就是你使用的构造方法！
至于构造方法也属于特殊情况。

static方法可以被继承吗？

在SuperClass中定义一个staticMethod
然后使用SunClass.staticMethod。

你试试看不就知道了！呵呵，答案是可以的。

#15

引用 14 楼 qfs_v 的回复:

还有static方法是可以被重载的，典型的例子就是你使用的构造方法！ 
至于构造方法也属于特殊情况。 

static方法可以被继承吗？ 

在SuperClass中定义一个staticMethod 
然后使用SunClass.staticMethod。 

你试试看不就知道了！呵呵，答案是可以的。

还有static方法是可以被重载的，典型的例子就是你使用的构造方法！

试问：构造方法有static的吗？

#16

方法 当然可以继承，  不管是不是静态的！~

java的理念：  子承父类，   所有的属性和方法全部继承

main()同样也为方法， 为何不能继承这么简单的一个逻辑功能呢？

属性和构造方法 不能被重写，  因为它们都是数据结构--  一个是标志位的  一个是描述位的；

#17

引用 15 楼 jishu_vip 的回复:

引用 14 楼 qfs_v 的回复:
还有static方法是可以被重载的，典型的例子就是你使用的构造方法！ 
至于构造方法也属于特殊情况。 

static方法可以被继承吗？ 

在SuperClass中定义一个staticMethod 
然后使用SunClass.staticMethod。 

你试试看不就知道了！呵呵，答案是可以的。 
 

还有static方法是可以被重载的，典型的例子就是你使用的构造方法！ 

试问：构造方法有static的吗？

是的，隐式声明为static的。这就要说到多态性的静态绑定了。

#18

你这样想，要是构造方法不为static，那在没有类没有实例之前怎么调用一个非static的方法来提供实例化类的服务呢？

#19

引用 18 楼 qfs_v 的回复:

你这样想，要是构造方法不为static，那在没有类没有实例之前怎么调用一个非static的方法来提供实例化类的服务呢？

你在哪里看到的构造方法隐式为static的？

#20

问下  qfs_v 
如果构造方法隐式为static,那还真奇怪了，怎么产生不同的对象？

#21

我不负责的告诉你----不能。
我负责的告诉你---能。

#22

引用 6 楼 jishu_vip 的回复:

Java code
public class TestFather {
    public static String s(String str){
        return str;
    }
}



public class TestSun extends TestFather{

  public static void main(String[] args){
    System.out.println(TestFather.s("abc"));
        System.out.println(new TestFather().s("abc"));
    System.out.println(TestSun.s("abc"));
        System.out.println(new TestSun().s("abc"))…

经过试验，你的代码里TestSun.s和new TestSun().s两个方法都不行

#23

引用 16 楼 bxdg42578670 的回复:

方法 当然可以继承，  不管是不是静态的！~ 

java的理念：  子承父类，  所有的属性和方法全部继承 // 这句话显然不对

main()同样也为方法， 为何不能继承这么简单的一个逻辑功能呢？ 

属性和构造方法 不能被重写，  因为它们都是数据结构--  一个是标志位的  一个是描述位的； 

#24

引用 22 楼 fbchen 的回复:

经过试验，你的代码里TestSun.s和new TestSun().s两个方法都不行

绝对可以

#25

引用 10 楼 KAKUKYOWU 的回复:

引用 7 楼 rypgood 的回复:
Java code 
//第一个类 
public class Test 
{ 
    public static void main(String args[]) 
    { 
        System.out.println("a main method is running now"); 
    } 
} 
//第二个类 
public class Test2 extends Test 
{ 
    
} 
/* 
  编译并运行第二个类,打印出 
a main method is running now 
由此证明,main方法一样被继承了 
没实验的人别乱吹 
*/ 
 

汗，我可…

可是我试过了,是可以的。
而且子类是可以使用父类的静态方法的。

#26

引用 25 楼 axiuluo 的回复:

可是我试过了,是可以的。 
而且子类是可以使用父类的静态方法的。

这个肯定是可以的。

但是这个能不能叫继承了静态方法还有待商量

#27

从理论上讲 貌似应该是能的吧~
不过main()一般都是测试用的~ 继承了也没什么意义额吧..

#28

Thinking in java中说过,构造方法其实是static的.
The Java Programming Language上说过,所有static的方法和属性都是不能覆盖的,只是hidden.

#29

不用争了，可以继承。鉴定完毕。

#30

引用 14 楼 qfs_v 的回复:

还有static方法是可以被重载的，典型的例子就是你使用的构造方法！
至于构造方法也属于特殊情况。

这位好像分不清什么是overriding和overloading
构造方法无法覆盖.
子类只能通过super来直接调用父类的构造方法.

#31

引用 28 楼 ZangXT 的回复:

Thinking in java中说过,构造方法其实是static的. 
The Java Programming Language上说过,所有static的方法和属性都是不能覆盖的,只是hidden.

1.构造方法其实是static， //这个我确实没有看到过，看来要回去好好看看thin in java了


2.所有static的方法和属性都是不能覆盖的 //能不能继承？或则说是不是应该叫继承。我觉得还有待商量

#32

引用 19 楼 jishu_vip 的回复:

引用 18 楼 qfs_v 的回复:
你这样想，要是构造方法不为static，那在没有类没有实例之前怎么调用一个非static的方法来提供实例化类的服务呢？ 
 
你在哪里看到的构造方法隐式为static的？

我还可以明确的告诉你在子类中重写父类的static，final，private方法，实质上是创建了一个新的方法。但你不要问我在哪里看到的，因为事实就是这样。

#33

引用 31 楼 jishu_vip 的回复:

2.所有static的方法和属性都是不能覆盖的//能不能继承？或则说是不是应该叫继承。我觉得还有待商量

的确,按照面向对象方法学的理解,子类继承父类的一切.
但感觉static的东西类似面向过程里的函数,不像对象本质的东西.

#34

引用 32 楼 qfs_v 的回复:

我还可以明确的告诉你在子类中重写父类的static，final，private方法，实质上是创建了一个新的方法。但你不要问我在哪里看到的，因为事实就是这样。

final的是怎么写的?

#35

引用 20 楼 jishu_vip 的回复:

问下 qfs_v 
如果构造方法隐式为static,那还真奇怪了，怎么产生不同的对象？

反射等技术，鉴于你对好好想下 “要是构造方法不为static，那在没有类没有实例之前怎么调用一个非static的方法来提供实例化类的服务呢？” 这句话。

#36

参数不同而已.

#37

引用 32 楼 qfs_v 的回复:

引用 19 楼 jishu_vip 的回复:
引用 18 楼 qfs_v 的回复: 
你这样想，要是构造方法不为static，那在没有类没有实例之前怎么调用一个非static的方法来提供实例化类的服务呢？ 

你在哪里看到的构造方法隐式为static的？ 
 
我还可以明确的告诉你在子类中重写父类的static，final，private方法，实质上是创建了一个新的方法。但你不要问我在哪里看到的，因为事实就是这样。 

不能重写是事实，确实是创建了一个新的方法，这个我同意。

现在讨论的是能不能继承，或则是该不该叫不叫继承。

#38

final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。

#39

引用 38 楼 qfs_v 的回复:

final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。

给我写个例子好吗?

#40

引用 38 楼 qfs_v 的回复:

final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。

重写了父类的方法怎么能叫继承?
继承就是我不定义,就能拿来用。

影响继承的只是private,protectd,public等修饰符。
main()是public的 子类就可以继承

#41

多态就是通过重写(override)实现的.

#42

引用 41 楼 ZangXT 的回复:

多态就是通过重写(override)实现的.

是重载！老大。

#43

引用 42 楼 qfs_v 的回复:

引用 41 楼 ZangXT 的回复:
多态就是通过重写(override)实现的. 
 
是重载！老大。

说错了，对不起

#44

引用 40 楼 axiuluo 的回复:

引用 38 楼 qfs_v 的回复:
final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。 
 
重写了父类的方法怎么能叫继承? 
继承就是我不定义,就能拿来用。 

影响继承的只是private,protectd,public等修饰符。 
main()是public的 子类就可以继承

你要是能够把父类的一个final方法继承了，我就服你了。

#45

我认同这样的说法:
overloading 重载(跟面向对象无关,方法的一种特性,签名不同)
overriding覆盖或者重写(多态的关键,父类和子类的相同签名方法之间的关系)

#46

你要是能够把父类的一个final方法继承了，我就服你了。 


子类继承了父类的final方法，只是不能overriding罢了

#47

现在是用事实说话的时候了

public class SuperClass {

	public SuperClass() {

	}

	public final void test(){
		System.out.println("SuperClass test");
	}
}

public class SunClass extends SuperClass {

	public SunClass() {

	}

	public void test(){

	}
}

编译器会提示你错误！
axiuluo 你可以更加还怀疑这样的说法： final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。 因为编译器会提示你错误为你再次提供了怀疑的理由，但这是编译器行为，而不是java语言的本质。

#48

继承: 父类有,子类没有
覆盖(overrite, hide): 父类有,子类重新定义,但是参数不同 或者返回值不同
重载(overload)：父类有,子类重新定义,方法签名一致---> 多态的基础

这种情况应该算是继承，因为子类没有定义main

#49

引用 46 楼 tyut8518 的回复:

你要是能够把父类的一个final方法继承了，我就服你了。 


子类继承了父类的final方法，只是不能overriding罢了 

那你说 
影响继承的只是private,protectd,public等修饰符。 
main()是public的 子类就可以继承
不是自相矛盾？

#50

引用 47 楼 qfs_v 的回复:

现在是用事实说话的时候了
Java codepublicclassSuperClass {publicSuperClass() {
        
    }publicfinalvoidtest(){
        System.out.println("SuperClass test");
    }
}publicclassSunClassextendsSuperClass {publicSunClass() {

    }publicvoidtest(){
        
    }
}
编译器会提示你错误！
axiuluo 你可以更加还怀疑这样的说法： final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新…

这个例子终于把你的说法否定了:
引用 38 楼 qfs_v 的回复:
final表示阻止继承，也就要是说你重写了父类的方法其实就是在重新定义一个新的方法。