父类:
package inherit;public class Supper{
protected f1(){
system.out.println("protected f1() in Supper");
}
}子类:
import inherit.Supper;public class Sub{
public static void main(string[] args){
Supper Sup=new Supper();
Sup.f1();
}
}发生错误:
Sub.java:11: f1() 可以在 inherit.Supper 中访问 protected
Sup.f1();
^
1 错误子类为什么不能访问Supper的protected方法?
package inherit;public class Supper{
protected f1(){
system.out.println("protected f1() in Supper");
}
}子类:
import inherit.Supper;public class Sub{
public static void main(string[] args){
Supper Sup=new Supper();
Sup.f1();
}
}发生错误:
Sub.java:11: f1() 可以在 inherit.Supper 中访问 protected
Sup.f1();
^
1 错误子类为什么不能访问Supper的protected方法?
...
}即便这样,下边的代码仍然是行不通的: Supper Sup=new Supper();
Sup.f1();以这种方式调用,f1 必须是 public 的。
为什么不能调用
但是子类和父类不在同一个包中 ;
因此不能调用父类的protected方法 ;
仔细想一下 protected的使用方法 要点不是在哪里创建 是protected方法的使用
system.out.println("protected f1() in Supper");
}这是一个构造函数,即使换成public,也不能像你那样调用。
改成
protected void f1(){
system.out.println("protected f1() in Supper");
}
应该就可以了。
但是子类和父类不在同一个包中 ;
因此不能调用父类的protected方法 ;
仔细想一下 protected的使用方法 要点不是在哪里创建 是protected方法的使用
-----------------------------------------------------------------------------------
没错,你只要将Sub和Supper放到同一个包下就可以了
public class Sub extends Supper {
protected f1(){
system.out.println("protected f1() in Supper");
}
}
这样是编译通不过的,换成
public class Sub extends Supper {
protected void f1(){
system.out.println("protected f1() in Supper");
}
}
就可以了。构造函数一定没有返回值,非构造函数一定要有返回值。
我不知道其他人回答问题的时候是不是亲自编程试过了。就象上面
那位回答子和父在同一个包,这是java的package private的问题,
和本问没有关系。
protected void f1(){
system.out.println("protected f1() in Supper");
}我的程序是这样的,但是就是不能调用。这里也是我写漏的。
但是子类和父类不在同一个包中 ;
因此不能调用父类的protected方法 ;
仔细想一下 protected的使用方法 要点不是在哪里创建 是protected方法的使用
我不认为这样,java设置protected的目的就是让他的子类也可以访问它的父类,就算他们不是同一个包。如果非得放在同一个包,protected创造出来的意义就没有了java的本意。
package inherit;public class Supper{
protected void f1(){
system.out.println("protected f1() in Supper");
}
}子类:
import inherit.Supper;public class Sub extends Supper{
public static void main(string[] args){
Supper Sup=new Supper();
Sup.f1();
}
}发生错误:
Sub.java:11: f1() 可以在 inherit.Supper 中访问 protected
Sup.f1();
^
1 错误子类为什么不能访问Supper的protected方法?protected权限是就算你不在同一个包,只要你是子类就可以访问的,为什么访问不 了?
就是说:子类可以拥有父类的(pubilc,protected)方法
但是如果子类和父类是在同一个包里面,那么子类可以拥有父类的(public,protected,packaged)方法我这里所谓的packaged方法在父类是如下定义的:
fun(){ //不加任何public,protected和private修饰
....
}
protected void f1() {
System.out.println("protected f1() in Supper");
}
}//////////////////////////////////////////////import inherit.Supper;public class Subber extends Supper {
public void method() {
System.out.println("you can see f1()");
f1();
} public static void main(String args[]) {
Subber s = new Subber();
s.method();
// Sup.f1();
}
}---初学者
我想问大家的是,为什么我这样写,父类的对象(在子类创建的)就不能调用protected方法。而且是针对我的程序给出解答。我那个程序编译的错误以写出。
可能是你对protected理解有问题吧。
-------------------------------------------对啊,我说的是在同一包中和子类中可见,子类不一定在同一包中,呵呵,估计楼主应该理解了同一包中的含义,protected的最主要还是让你的类中的属性和方法在你的子类中可见,也就是说你的子类中的任意方法都可以调用他们,不知楼主是否明白?
Sub sub = new Sub(); sub.f1();这样肯定是可以的,这样才是子类访问父类吧。我是这么认为的。
但是这个不是我想讨论的。
对一般用户而言,它是private 的,但是如果你想继承这个类,或者开发一个也属于这个package 的类的话,就可以访问它。所以,通过继承关系能够调用f1()方法,怎么通过继承关系调用?你只能用super.f1();或者
Sub sub = new Sub();
sub.f1();
来使用f1()方法。这是继承的语义。但是像
Supper s = new Supper();
s.f1();
这就是组合关系了,你可以把Sub类放在和Supper一个package中,或者将Supper类中的f1()方法定义为public,都是可以正确调用的。这个里面其实有一个界线。好好体会一下。
Supper s = new Supper();
s.f1();
这就是组合关系了,其实说确切一点,这不是组合关系。如果这样都是组合,那么我们的面向对象的程序就都是组合来的。组合不是这样定义的,组合是对类中的类成员来说的。
public void method() {
System.out.println("you can see f1()");
f1();
} public void method2(){
Supper s = new Supper();
super.f1();
s.f1(); //error
}
public static void main(String args[]) {
Subber s = new Subber();
s.method();
s.method2();
super.f1(); //error
}
}//不是protected还是public的问题吧.
//在子类里建个父类的对象,然后用这个父类的对象就想访问protected方法
//是不是一些概念搞混了---初学者
真的。
但是我还是不能明白编译器为什么不能通过编译。
而且好像大家开始不是讨论我的问题了,不过都学到很多东西。
package inherit;public class Supper{
protected f1(){
system.out.println("protected f1() in Supper");
}
}子类:
import inherit.Supper;public class Sub{
public static void main(string[] args){
Supper Sup=new Supper();
Sup.f1();
}
}发生错误:
Sub.java:11: f1() 可以在 inherit.Supper 中访问 protected
Sup.f1();
^
1 错误子类为什么不能访问Supper的protected方法?//好长的贴子.
//---子类为什么不能访问Supper的protected方法?
//你的这句话是什么意思?
//你的子类是指子类的定义吧.
//子类能访问基类的protected,这是地球人都知道的.
//但你这里是用对象Sup
//编译程序可不管你在子类方法里用的对象到底是哪家的.
//如果还不明白,继续讨论(如果你觉得有必要的话)---初学者
It says “This is private as far as the class user is concerned, but available to anyone who inherits from this class or anyone else in the same package.”
是“or”关系的
子类访问父类的protected类型method,field,是指通过继承的方式来访问,其他的访问方式,都是非法访问方式。在同一个Package里子类能通过父类的实例访问父类的protected方法,并不是因为这个方法是protected,而是因为protected方法在同一个package里具有package性,其他类都可以像public方法一样访问,与是不是继承没有关系。
老大,亏你还5个三角,是不是看错了?别误人子弟啊,f1()怎么能是构造函数啊,构造函数要和类名相同
system.out.println("protected f1() in Supper");
}这是一个构造函数,即使换成public,也不能像你那样调用。
改成
protected void f1(){
system.out.println("protected f1() in Supper");
}
应该就可以了。
-----------------------------
大放屁。
public class Sub extends Supper {
protected f1(){
system.out.println("protected f1() in Supper");
}
}
这样是编译通不过的,换成
public class Sub extends Supper {
protected void f1(){
system.out.println("protected f1() in Supper");
}
}
就可以了。构造函数一定没有返回值,非构造函数一定要有返回值。
我不知道其他人回答问题的时候是不是亲自编程试过了。就象上面
那位回答子和父在同一个包,这是java的package private的问题,
和本问没有关系。
---------------
再次大放屁。
package inherit;public class Supper{
protected f1(){
system.out.println("protected f1() in Supper");
}
}
这能compile吗?
所以无法调用。
看了上面的讨论,我只能发笑。子类:
import inherit.Supper;
public class Sub{
public void f2(){
super.f1();//此处的super是关键字,不是你的类名。注意。
//在子类的类方法内,可以访问父类的protected方法
}}
public static void main(string[] args)main函数是不在继承的讨论范围内的--------------------------------------------------这个是对的
实际上是可以的,实际你的错误应该与你的包有关系,我把你的包去掉后就可以了!
父类:
public class Supper{
protected void f1(){
System.out.println("protected f1() in Supper");
}
}
子类:public class Sub extends Supper{
public static void main(String[] args){
Supper Sup=new Supper();
Sup.f1();
}
}
运行通过:
protected f1() in Supper
还有请你在编写的时候注意大小写!
?
你要讨论的问题是“子类竟然不能创建父类对象调用父类的protected方法”
实际上是可以的,实际你的错误应该与你的包有关系,我把你的包去掉后就可以了!
父类:
public class Supper{
protected void f1(){
System.out.println("protected f1() in Supper");
}
}
子类:public class Sub extends Supper{
public static void main(String[] args){
Supper Sup=new Supper();
Sup.f1();
}
}
运行通过:
protected f1() in Supper
还有请你在编写的时候注意大小写!-------------------------------------------------------
你是把子类和父类都放一个包中了吧?那样的话即使Sub类没有继承Super类,都可以
用Super的对象访问protected的成员函数。换句话说,你这个是protected对同个包的
可访问性。
其实我觉得上面tlowl(风流才子) ( 三级(初级)) 信誉:100 2005-10-07 21:00:00 得分:0
的贴是把问题说的最清楚明白的
public static void f(){ f1(); } //define in class Sub;你能编译过去吗?
public static void main(String[] args){
//Supper Sup=new Sub();
//Sup.f1();
f1();//直接指向Supper中的f1()
}
把声明父类对象注释掉,一样可以编译运行,这样就不会造成混淆了
package inherit;public class Supper{ protected void f1(){ ///非static只是protected方法
System.out.println("protected supper.f1()");
} protected static void f2(){////既是static又是protected方法
System.out.println("protected static suppe.f2()");
}
}子类:
import inherit.Supper;class Sub extends Supper{
protected static void f2(){////覆盖Supper的f2()方法
System.out.println("protected static Sub.f2()");
} public static void f3(){
System.out.println("f3() method in Sub");
Supper a=new Supper();
a.f1(); ///ERROR
}
public static void main(String[] args){
Supper b =new Supper();
b.f1(); ///ERROR
Supper c =new Supper();
c.f2(); ///But no ERROR
}
}编译错误如下:Sub.java:14: f1() 可以在 inherit.Supper 中访问 protected
a.f1(); ///ERROR
^
Sub.java:19: f1() 可以在 inherit.Supper 中访问 protected
b.f1(); ///ERROR
^
2 错误 这些错误就是我想讨论的东西:子类为什么不能通过创建父类的对象调用protected方法。不用super这关键字。
我认为:就像package权限一样,同一个包的类可以通过在另一个类(这两个类是同一个包的)中创建的对象调用package方法,protected的方法应该也可以通过在子类中创建父类的对象调用,但是编译器就告诉我:你不能这样!!
我就是想知道为什么这样的!这样让我觉得编译器违反了protected的定义:“This is private as far as the class user is concerned, but available to anyone who inherits from this class or anyone else in the same package.”
System.out.println("protected static Sub.f2()");
} 这并没有覆盖因为你父类的F2是STATIC的你这个只能说又重写了一个F2
类中所有的PRIVATE和STATIC方法都是FINAL的不能被覆盖,就算编译过了其实你运行看看就明白了
package test.test.aaa;public class Super
{
protected void f1(){
System.out.println("protected f1() in Supper");
}
}子类:
package test.test.aaa;public class Sub extends Super{
public static void main(String[] args){
Super Sup=new Super();
Sup.f1();
}
}没有问题!
但是这样有违protected的初衷……我认为。
这个问题我原来也理解错了,现在我引用一段java2学习指南上的原话,
以方便楼主和各位理解。
我现在想想可能还真没有多少人能完全真正的理解过protected这个关键字。
我先引用如下,大家可以再讨论。
------------------------------------------------------------------------
包外子类有权访问父类成员是什么意思?它指子类继承该成员。
然面,这不意味着包外子类能够使用父类实例的引用访问该成员。
换句话说,保护=继承。
保护不是指子类能够处理受保护的父类成员,就好像它是公有的那样。
因此,如果包外子类获得父类引用,该子类不能在父类引用上使用点运算符来
访问受保护的成员。
子类只能通过继承看到受保护的成员。