假设有以下基类:
package bg.svetlin.ui.controls;
public abstract class Control {
protected int getHeight() {
//..
}
//...
}
此外,在同一个包中,有一个继承:
package bg.svetlin.ui.controls;
public abstract class LayoutControl extends Control {
public abstract void addControl(Control control);
/
我正在学习java中的访问级别,我已经创建了3个类:在包my.inheritance中,我有A类和C类
package my.inheritance;
public class A {
protected int a=15;
}
package my.inheritance;
public class C {
public static void main(String[] args)
{
A a = new A();
System.out.println(a.a);
}
}
在另一个名为my.inheritance.test的包中,我有一个类B试图访问int值为a的受保
我有一个受保护的方法(我不希望在超类或它的子类之外看到这个方法)。我想在复制构造函数中使用它,但我不能。代码:
public class Superclass {
protected HashMap<Object, Object> getData() {
return new HashMap<>();
}
}
public class Subclass extends Superclass {
public Subclass(Superclass abstractClass) {
init(abstractCla
当我从另一个包中扩展一个类时,我发现了一些不能编译的东西,尽管我认为它应该编译。
我有两个类,在不同的包中。在com.foobar.a包中:
package com.foobar.a;
public class A {
protected void foo1() {
System.out.println("foo1() was called!");
}
protected static void foo2() {
System.out.println("foo2() was called!");
我已经浏览了很多网站,这些网站解释了java中的访问说明符,比如、,以及许多其他的堆栈溢出问题,比如。
所有这些人都解释说,任何子类(也是包外子类)都可以访问受保护的成员,包级别的类也可以访问该成员。
在对受保护的成员进行实验时,我发现无法从包外的子类访问受保护的成员。
检查下面的代码。有受保护成员的公共班级:
package com.One;
public class ProVars {
protected int i = 900;
protected void foo()
{
System.out.println("foo
从可以实现的普通超类继承有什么不同吗?
atm我有一个名为abstractcar的抽象类,bigcar / smallcar扩展了这个abstract class。
public abstract class AbstractCar{
private int capacity;
}
class BigCar extends AbstractCar{}
class SmallCar extends AbstractCar{}
摘要中的一个字段被设置为“私有int容量”。
但在子类“小型车”中,当我将“容量”作为构造函数中使用的变量时,它表示“容量在抽象中具有私有访问权限”。
我以为:
我的A班有一个受保护的成员:
package p1;
public class A{
protected int number;
}
现在,我将它子类到另一个包中:
package p2;
public class B extends A{}
现在在主修班:
package p3;
public class Main{
public static void main(String[] args){
B b = new B();
System.out.println(b.number);
}
}
它执行得很完美。受保护成员在子类中的
假设我们有一个包"p1":
package p1;
public class A {
protected void method() { }
}
..。我们还有一个包"p2":
package p2;
import p1.A;
public class B extends A { }
class Tester {
static void run() {
new B().method(); //compile-time error
}
}
现在,如果我们试图编译一个完整的例子,我们将使用编译时错误标记行:编译器只是看
我对java很陌生,我了解受保护的可见性的诀窍。
我的A类保护了方法method1,如下所示-
public abstract class A {
public A(...){}
protected void method1(){
// do something
}
现在我有另一个B类,它扩展了一个不同的C类。B类有一个嵌套的静态类,类D扩展了A类。
public class B extends C {
public B(...){
super(...);
}
private static class D e
这听起来很傻,但我真的很困惑。请参阅以下代码:
package com.one;
public class SuperClass {
protected void fun() {
System.out.println("base fun");
}
}
----
package com.two;
import com.one.SuperClass;
public class SubClass extends SuperClass{
public void foo() {
SuperClass s = new SuperCla
我有一个扩展Activity的类,如下所示:
public abstract class AndroidGame extends Activity implements Game
该类有一个onCreate()方法,如下所示:
public void onCreate(Bundle savedInstanceState) {
// I do stuff here
}
然后我创建了另一个扩展AndroidGame的类,如下所示:
public class ScatmanNomGame extends AndroidGame {
// The loading screen will
我正在读一本Java的书,我偶然发现:
受保护的访问控制级别与默认的访问控制级别几乎相同,但有一个关键区别。只有当访问成员的类属于同一个包时,才能访问默认成员,而子类可以(通过继承)访问受保护成员,即使子类位于不同的包中。
所以我决定测试protected点。
我的包里有个超级名校
package scjp;
public class Token {
protected int age = 6; //This is the protected class-level variable.
public Token(String name){
this
最近,我在Java中练习继承主题。我遇到这样的说法:“超类中的protected成员变量是子类中的private”。
我的问题是,如果子类本身是另一个子类的父类,那么该子类能够访问基类的成员变量吗?
public class A
{
protected int a;
public A(int a)
{
this.a = a;
}
}
public class B extends A
{
public B(int a)
{
super(a);
}
}
public class C extends B
可能重复:
在爪哇,
受保护的成员可以从类、其子类和存在于同一包中的所有类中访问,
但是,我希望一个成员只能从类及其子类中访问(就像c++中的受保护成员一样)。
例如:
class A
{
protected void fun()
{
System.out.println("Hello");
}
}
class B
{
public static void main(String args[])
{
A a = new A();
a.fun();
}
}
在这里
下面是示例代码:
package com.ankur.javapractice;
public class SuperClass {
public void someMethod(int val) {
System.out.println("Public method in SuperClass");
}
}
class SubClass extends SuperClass {
public void someMethod() {
System.out.println("Public method in S
在我的安卓项目中,我有一个名为Activity的主TestFIO,它位于org.testing.file.io.main包中,我试图保持它的清晰性,并将我所拥有的所有函数发送给位于org.testing.file.io.main.manipulator的一个名为FileManipulator的新类。下面是FileManipulator类的样子:
package org.testing.file.io.main.manipulator;
// imports here
public class FileManipulator extends TestFIO {
public Stri
我有以下几个类:
package abc;
public class A {
public int publicInt;
private int privateInt;
protected int protectedInt;
int defaultInt;
public void test() {
publicInt = 0;
privateInt = 0;
protectedInt = 0;
defaultInt = 0;
}
}
"A“包含所有四个访问修饰符的属性
为什么当我在子类中创建超类的引用时,只能从引用中调用公共方法,而不能调用受保护的方法。(类在不同的包中)
package pet;
public class Dog {
protected void bark(){};
void jump(){};
public void lick(){};
}
package other;
import pet.*;
public class Husky extends Dog {
public static void main(String[] args){
Husky h = new Husk
我有一个映射的超类和两个扩展基类的实体。我遵循了,但是当我运行bin/console doctrine:schema:update时,我的两个实体都是用实体本身声明的属性生成的,而不是映射的超类声明的属性。我遗漏了什么或做错了什么?
映射的超类:
<?php
namespace AppBundle\Model;
use Doctrine\ORM\Mapping as ORM;
use AppBundle\Entity\User;
/**
* @ORM\MappedSuperclass(repositoryClass="Doctrine\ORM\EntityReposito
我很难弄清楚如何从我的ListQueue类中调用“前台”方法。ListQueue类实现了接口"Queue",该接口还包含作为变量的“前台”。该方法在队列中是公共的,在ListQueue中是保护的。
当我尝试用q1和q2调用前台时,这个方法是不被识别的。我认为这是因为它是受保护的访问修饰符,因为它能够识别其他具有公共访问权限的方法。如果是这样的话,有什么办法可以绕过这种情况而不把保护变成公众呢?我试着在ListQueue中的方法上面添加@覆盖,但是说它不会覆盖超类。
public class BaseMerging {
private static Queue mergeQue
为了用一个简单的例子来回答我的问题,我有三个类,如下所示:动物-> ->鹦鹉
为什么我不能只在Parrot类中使用Parrot的字段值,即使该值是在构造函数中传递的,而必须使用来自Animal类的getName()方法呢?
public abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public abstract void eat();
public abstract void b
class Main {
public static void main(String[] args) {
new Cloned().clone();
}
}
class Cloned implements Cloneable {
}
这会给出一个错误,说明它是受保护的。object的子类都不能调用该方法。
有人能解释一下为什么我们需要“保护”这个词吗?如果我没听错,
默认访问:在同一个包中的类中可用。
受保护的访问:相同包中的默认访问+对任何包中继承的类(子类)可用。基本上,我们在同一个包中获得相同的默认访问权限。
那我什么时候该用呢?只是为了你的代码风格?从继承的角度来标记它,您将使用它吗?
谢谢。
package firstPack;
public class First {
protected int a;
protected void Chat(){
System.out.println("Here I am");
}
}
假设我有这样一门课:
public class ClassA
{
[...]
protected void methodIWantToTest()
{
[...]
}
[...]
}
当我用IntelliJ Idea 13编写单元测试时,当我编写以下内容时,不会出现编译器错误:
public class ClassATest
{
@Test
public void test()
{
final ClassA objectUnderTest = new ClassA();
obj
我有两堂课
package a;
public class A {
protected void doSomething() {
}
protected static class C {
protected C(int c) {
}
}
}
package b;
public class B extends A {
@Override
protected void doSomething() {
C c = new C(0); //compile error
C c2 = new C(0){}; //legal
}
}
为什么我会得到4,而基类函数fun(int)是私有的,如果它是默认的,那么是5?
class one
{
int a;
private void fun(int a)
{
System.out.println(a);
}
public static void main (String [] args)
{
one y= new B();
y.fun(4);
// B obj =new B();
// obj.fun(4);
}
}
cl
我有父类和子类,其中父类有一个方法- getData。我可以直接从带有或不创建对象的子类调用此方法。我想知道该方法如何在不创建对象的情况下在子类中可用。(它也不是静态方法)据我理解,我们必须创建一个对象来访问这些方法。有谁能解释一下原因吗?
public class testbase {
public void getData(String Data) throws IOException{
Properties prop1;
prop1= new Properties();
FileInputStream f= new FileI
我有一个程序来解释和排序一个汽车经销商的数据,当试图检索存储在一个数组中的汽车的颜色时有一个错误。
这里是主类及其子类。
class Car
{
protected String model;
protected int price;
protected int year;
public Car(String m, int y, int p)
{
model = m;
price = p;
year = y;
}
}
class NewCar extends Car
{
protected String color;
public NewCar(String