关于JAVA的继承!有兴趣的可以进来讨论一下!

先看程序:
类A是一个抽象类,只有一个受保护的方法:
[code:1]
package a;

public abstract class A
{
protected String a;

protected String getA()
{
return a;
}
}

[/code:1]
下面接着看类B,类B没有代码,只是单单的继承了类A:
[code:1]
package b;

import a.A;

public class B extends A
{

}
[/code:1]
下面看类C,类C做的事情就是调用类B的方法:
[code:1]
package c;

import b.B;

public class C
{
public static void main(String[] args)
{
B b = new B();
b.getA();
}

}
[/code:1]
程序结束!类C会报错,会提示b的getA()方法是不可见的.
研究了一下,总结如下:
当类x继承类y的时候,会自动继承类y的所以public、protected 方法和属性。如果想在类z里调用类y的基类的protected方法，必须要在类y里覆写类x的相应方法，并修改方法的可见范围为public．这样，类z里才可以调用类主的基类方法．
修改类B,代码如下:
[code:1]
package b;

import a.A;

public class B extends A
{
public String getA()
{
return super.getA();
}
}

[/code:1]
当然,如果嫌麻烦的话,在基类里直接定义为public也可以.
可能参考Object的finalize方法.

在同一个package的话, C的写法是可以编译通过执行的。
（java 5.0下编译通过）

另外，既然继承了 C，一般不会直接在C 里访问 B吧。

new 一个 C 调 C的getA方法比较正常。

你说的是类C和类A是一个包吧?不太可能会这样做吧!

类B继承类A,在类C中调用类B,这种情况很常见啊![/b]

protected属性和方法的限制是只有是同一个包下的类或是继承这个类的子类,才可以访问!

没仔细看，我以为C是继承B的。

根据我的理解:
由protected定义属性也好,方法也好都只是为了提供给派生类使用,这里强调的是用途,如果要让其他地方调用则应以public定义.
总之,我认为在设计一个类时首先决定哪些是私有的,哪些是派生类需要的,哪些需要公开的,注意考虑的顺序:private->protected->public(这也许是我学C++时养成的,想听听大家的意见).
当这些决定好后其他的甭管他了,只要有点OO思想,很多OO设计问题不需要太多解释("本来就该这样,为什么非得试试那样可不可行呢",我喜欢近自然的方式去考虑对象,不喜欢专语言特性的空子,以不自然的方式去创建一个类或派生类等等)
设计就是设计,而非写代码-------->纸上的东西就是纸上.

补充一下顺序:
private -> 默认-> protected -> public

我发这个帖子的本意是:在当前类里引用其它类的基类的protected方法是不可用的.条件是当前类和其它类的基类不在同一包里.因为protected的可见范围是子类和当前包下的所有类.上面说的有点绕口.
因为最开始我的想法是如果子类继承了基类的话,就继承了这个基类的所有protected属性和方法.这样在其它类引用这个子类的时候就可以调用这个子类的基类的protected方法.结果我想错了.呵呵!

上面这位朋友说的不错(对JAVA来说).(我上面说的跑题了,楼主的标题是:"关于JAVA的继承!有兴趣的可以进来讨论一下!")
为什么我会这样说呢?我记得C++中只有三种限定词,当然我突出的是:不依赖于某种语言的特性,也就是根本上在设计时抛开某种语言特性使用OO理念去设计.
虽然我对OO思想了解的并不多,但我根据所用过的几种语言(C++,Delphi,JAVA,C#)来看,如果设计一个类,可以在几种语言中使用相同的表达方法,无疑,只有遵守OO思想.
比如说:类中嵌类,在Delphi7中不可能,但在Delphi2006中可行(当然我和同事曾经激烈的讨论过(我表示赞同,他表示反对,具体讨论不详细讲述了)),为什么呢?在外部定义同样也可以做到吗!当然我认为有时以自然的方式去描述一个对象,类中类会更合适,现在的工具给你设计很大的灵活性,但我认为只要根据OO设计思想定义出来的一定可以在每种面向对象的语言中实现,甚至也可以在基于对象的语言中轻松实现!

[code:1]package com.king.util;

class Super
{
public void opration(Super s){
System.out.println("Super operation!");
}
};

class SuperA extends Super
{
public void opration(SuperA a){
System.out.println("SuperA operation A!");
}
public void opration(SuperB b){
System.out.println("SuperA operation B!");
}
public void opration(Super s){
System.out.println("SuperA operation S!");
}
};

class SuperB extends Super
{
public void opration(SuperA a){
System.out.println("SuperB operation A!");
}
public void opration(SuperB b){
System.out.println("SuperB operation B!");
}
public void opration(Super s){
System.out.println("SuperB operation S!");
}
};

public class Test
{
private static Super a;
private static SuperB b;
public static void main(String[] args)
{
b=new SuperB();
a=new SuperA();
a.opration(b);
}
}[/code:1]

这个例子的答案竟然是 SuperA operation S!
觉得大家也可以讨论一下

相反
[code:1]package com.king.util;

class Super
{

};

class SuperA extends Super
{

};

class SuperB extends Super
{

};

public class Test
{
public void opration(SuperA a){
System.out.println("SuperB operation A!");
}
public void opration(SuperB b){
System.out.println("SuperB operation B!");
}
public void opration(Super s){
System.out.println("SuperB operation S!");
}
public static void main(String[] args)
{
Super a =null ;
SuperB b = null;
b=new SuperB();
a=new SuperA();
new Test().opration(b);
}
}[/code:1]
这个的结果却是SuperB operation B!
完成了java运行时的动态匹配实际类型功能