比如final函数在子类中是不可以被覆盖的,
但如果你在父类中如此定义
private final void method(){
...
.
.
.
}
在子类中你就可以覆盖掉
void method(){
...
.
.
.
}
但如果你在父类中如此定义
private final void method(){
...
.
.
.
}
在子类中你就可以覆盖掉
void method(){
...
.
.
.
}
呵呵，private final void method()
我最近举了一个东方不败的例子，final方法太好啦，但因为它的第一招太损，所以要用private 修饰。
这种情况是假的override方法。
对于方法：对于public就不用说了，private只是不能访问而已，但是你父类的public方法可能调用
了private方法，所以子类当然也相当于间接调用了父类的private方法，不知道这个算不算
继承。不过如果父类有一个从来没有用到的private方法，此时子类仍然有继承，虽然子类
根本无法间接的调用它，但是父类其实也无法间接的调用它。
对于构造器：我们可以通过super调用父类的构造器，其实和方法是一样的，不过我觉得构造器只不过
不会默认的呈现可访问形式,这个和方法不一样。如果没有继承，怎么可以访问到呢？
对于静态函数：不过属于类而已，同样子类也可以访问呀，如果子类没有继承的话，怎么可以用的。至于覆盖我觉得已经不是继承的概念了，应该是实现多态了。
不过方法和成员变量应该是一个区别的，成员变量肯定是每个实现由一个拷贝,对于静态的话就是一个类型有用一个拷贝了，对于方法的话，继承并不会多一份方法拷贝，因为根本就没有必要！这个是我个人的看法，我的结论是父类的所有东西都被子类继承，否则就不叫继承了
尽管有的没有表现出来(构造函数),有的甚至隐藏了(private)，但是他们却是被继承了！
对于构造器：我们可以通过super调用父类的构造器，其实和方法是一样的，不过我觉得构造器只不过不会默认的呈现可访问形式,这个和方法不一样。如果没有继承，怎么可以访问到呢
有理!
java实现一般使用下边不同内存区域存储
其中两个区域存放方法（方法不区分是否为静态还是动态，因为没有这个必要，方法的拷贝只需要一个）的代码和类（静态）数据，这部分内存只在程序或者首次装入时候分配一次
参数数据和对象数据分别通过栈和堆来分配，其中有一点当保存对象的内存被分配时候，他是包含了存放所有对象属性所需的空间，而且还包括了对类定义的方法的引用（这个才是我们所谓的多态的根本）。看上去是子类把父类的方法给覆盖了，实质上应该方法都存在，都可以用，只不过虚拟机通过对类定义的方法引用就知道具体需要使用的方法了。
好不容易得到的结论A1——构造器问题，好像treeroot、wadsunglow、wangsheng1028朋友都有不同看法。
谢谢大家的意见和帮助。对于这个问题，我知道不一定有一个所谓的标准答案。但通过讨论，可以使我们对Java的继承有更深入的理解。
我可没有躺在等某位大侠给我一个答案哦。测试问题，我想大家都做了很多，例如private final void method()的改写（override）例子等等，一般的测试程序就不需要了。
本问题简单的答案，比如我说：***子类继承父类的所有成员，而父类的所有非成员不被继承***对我而言，意义不大。给我一个理由，please。To universe01(未知软体) ：
有趣的说。
"至于覆盖我觉得已经不是继承的概念了，应该是实现多态了。"
No.
先看这段罗罗索索 的话，其中我加了【】：
“A class type may contain a declaration for a method with the same name and the same signature as a method that would 【otherwise be inherited】 from a superclass or superinterface. In this case, the method of the superclass or superinterface is 【not inherited】. If the method 【not inherited】 is abstract, the new declaration is said to implement the method; if it is not abstract, the new declaration is said to override it.”（from《The Java Virtual Machine Specification》）事实上，多态是“无法独立使用”的特性。讨论继承时，要考虑改写（override）机制。
现在的很多Java书籍，基本上不谈多态性，谈改写，谈多态变量和对象替换。
不过JVMS中的术语said to “implement” the method，很多余，个人观点（也许大家也这么认为吧）。
"继承只是个OOP中的重要概念而已！而计算机中的具体实现是把这个概念计算机化！"有意思啊。好哦。子类应该继承父类的什么，是OOP的逻辑体系的一部分；Java如何做具体的安排，是Java语言的语法和JVM的事情。问“子类到底继承什么？”应该从继承的本质——或OOP的逻辑体系考虑？
？？
thinking……
{
public fun1()
{ System.out.println("base.fun1()"); }
}
class derive implements base
{
public fun1()
{ System.out.println("derive.fun1()"); }
}
这是覆盖吗？
我认为不是，下面的才是覆盖：class base
{
public abstract fun1()
{ System.out.println("base.fun1()"); }
}
class derive implements base
{
public fun1()
{ System.out.println("derive.fun1()"); }
}
你太马虎了。
{
public abstract fun1()
{ System.out.println("base.fun1()"); }
}
不能有函数体
class Base{
public void method(){
//do something
}
}
class Child extends Base{
public void method(){
//这里显然是覆盖，可以实现多态，可以调用父类的方法，因为继承了
super.method(); //这个方法很显然被继承了，虽然外部被覆盖了，表现不出来
//do others
}
}
因为我觉得和访问权限没有多大关系，所以其他的都是类型！
如果它是对的（我认同这种说法），父类方法是否被继承要看子类的脸色。
所以，override就与继承很有关系了。“//这里显然是覆盖，可以实现多态，可以调用父类的方法，因为继承了”
不太懂你的意思——因果关系。
因为override，所以在对象替换时，就实现了多态。ok。
因为JVM的类载入过程中，载入了父类，所以使用super可以调用父类的所有可访问的方法，也可以访问其他类（只要该类被载入）的所有可访问的方法。
（构造器我们暂时搁置起来）。
“因为继承了”？？“这个方法很显然被继承了”？？
我有些迷糊。
class other{ void foo(){} }
class Base{
public void method(){
System.out.println("base.fun1()");
}
public void method2(){
System.out.println("base.fun2()");
}
}
class A extends Base{
public void method(){
super.method();
super.method2();
new other().foo();
}
public static void main(String args[]) {
new A().method();
}
}
可以调用某方法与继承一个类有什么关系呢。
按照JVM规范的说法，父类被改写的方法将不被子类继承。如果它不是对的（我们不认同这种说法），父类方法是否被继承要完全不看子类的脸色。
所以，override就与继承压根就没有直接关系，它属于多态。
========================================================================================
嗯，上面这句有助于理清思路
只人定义为private的变量或是方法不能直接继承其它的都可以其实覆盖也是可以引用的
“问这个问题，不如去先去看看C++里面的继承机制，如果你理解了C++的继承机制，那Java的也不是很难的。”好建议。坦白的说，我害怕C++里面的继承机制。晕啊。
另外，仅仅在Java中，我们搞不定这个问题么？应该更容易一些啊。没有private继承等、没有多继承的说，但有一个讨厌的内部类。