我是一个Java新手,遇到了一些问题。我想让一个班变成另一个班。很难用抽象的方法来解释它,所以我给你举一个例子。
public class WorldGuard extends WorldGuardPlugin {
public WorldGuard(Plugin parent) {
WorldGuardPlugin plugin = parent.getServer().getPluginManager().getPlugin("WorldGuard")
// make plugin the actual class
}
}
W
我试图使用反射来声明一个ArrayList。下面是我的代码
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
String intClass="java.lang.Integer"; //This string will be replaced by a string taken from user which will be a class name.
Class classOf=C
我得到了代码下面的NullPointerException。
Parent.java
public abstract class Parent {
public Parent(){
parentFunc();
}
public abstract void parentFunc();
}
Child.java
public class Child extends Parent {
ArrayList<String> list = new ArrayList<String>();
@Override
pu
我刚开始学Java.I我明白
与实例方法不同的是,实例变量不能被重写,并且JVM在运行时不能在多形性访问时动态地选择实例变量。
执行流程:静态块,超级构造函数,初始化块,然后构造函数。
但是我被困在一个代码中,在那里我多形性地调用了一个实例变量,但是它显示了重写的值(它不应该显示)。实例变量在子类init块中被重写。
package package1;
public class Other {
public static void main(String [] args){
Parent referToChild = new Chil
我是Java的新手,请看下面的代码
//Parent Class
public class Abc {
Abc(){System.out.println("hiii");
}
}
//Child Class
public class CDE extends Abc{
@Test
public void Xyz(){
System.out.println("hi");
}
}
Output is coming as
hiii
hi
PASSED: Xyz
请帮助,我不知道为什么要调用父
请考虑以下几点:
public class parent {
int x;
parent() {
x = 5;
}
}
public class child extends parent {
int y;
child() {
super();
y = 10;
}
public static void main(String[] args) {
parent p = new child();
System.out.println(p.y);//can't access variable y
}
}
在这里
public class Exceptions {
static class Second extends RuntimeException {
public Second() {
throw this;
}
}
static class First extends RuntimeException {
public First() {
throw new Second();
}
}
public static void main(S
我有两个班,A班和B班。
class A {
String abcd;
String efgh;
}
class B extends A {
String check1;
String check2;
}
我在另一堂课上有一个B类的对象。我想从子类B中得到A类的一个单独的对象。在java中有什么特殊的方法来分离这两个类吗?请帮我找到正确的答案。
在Java中,据我所知,子类不继承带有参数的构造函数。
例如。
public class Parent {
public Parent(int x) {
DoSomethingWithX(x);
}
}
public class Child extends Parent {
// Compile fails with "Implicit super constructor Parent() is undefined
// for default constructor. Must define an explicit construc
我最近上了一门Java课程,我们正在处理程序输出、编译错误等问题。我自己也尝试过不同的代码,有一件事让我感到很困惑:首先,主要的方法如下:
public static void main(String[] args){
A a = new A();
B b = new B();
A ab = new B();
System.out.println(a.a + " " + b.a + " " + ab.a);
}
现在,我尝试了这些不同的版本:
//1
public class A {
public static i
我希望创建一个名为Global的运行配置类,它将存储重要的变量。这个班将传递给许多班级和他们的孩子。例如:
class Global:
def __init__(self):
self._var = 1
@property
def var(self):
return self._var
class parent:
def __init__(self, GLOBAL):
self.GLOBAL = GLOBAL
print(self.GLOBAL.var) # this works
class
在下面的类HiddenWord中,我创建了一个实例变量,它是通过字符串初始化的。这样做对吗?
而且,当我使用这个对象时,我是否需要一个toString方法来做到这一点?
public class HiddenWord{
private String Hword;
public HiddenWord(String word){
Hword = new HiddenWord(word);
}
}
我有一个关于Java继承的问题。
我有两个类A和B,B类继承了A的:
public class A {
public A() {
System.out.println("Hi!");
}
}
public class B extends A {
public B() {
System.out.println("Bye!");
}
public static void main(String[] args) {
B b = new B();
}
不能把标题具体化,抱歉。
例如,我们有一个Parent类和一个Child类:
package test;
public class Parent {
}
package test;
public class Child extends Parent {
}
和一个可以在其字段中包含Parent的子类的类,名为a。
package test;
public class Holder<A extends Parent> {
public A a;
}
让我们创建该类的一个实例,并尝试将一个值赋值给a
package test;
public class Main {
为什么我不能像这样使用代码?
<?php
class NoConstructor {
}
class ChildWithConstructor extends NoConstructor {
public function __construct() {
parent::__construct();
// do something
}
}
$foo = new ChildWithConstructor();
// **Fatal error: Cannot call constructor in file.php on line 8*
我可能错了,但从我在java中创建对象时所理解的情况来看:
Class object = new Class;
new Class创建类类型的新对象,然后应用于"object"引用
因此,当您通过以下方法创建对象数组时:
Class[] objects = new Class[10];
这是否意味着new Class[10]创建了10个类类型的对象,然后将其应用到objects引用中,还是只保留了10个类类型对象的内存,然后需要创建特定的对象
我对OOP比较陌生,所以想澄清几件事,
我有下面的代码
class Parent
{
public Parent()
{
Console.WriteLine("Parent Class constructor");
}
public void Print()
{
Console.WriteLine("Parent->Print()");
}
}
class Child : Parent
{
public Child()
{
最近,我遇到了一个不寻常的Java语法.下面是一个例子:
List list = new <String, Long>ArrayList();
注意<String, Long>类型参数的位置.它不是像往常一样在类型之后,而是在前面。我不介意承认我以前从未见过这种语法。还请注意,当ArrayList只有1时,有2个类型的参数。
类型参数的位置是否与将它们放在类型后面具有相同的意义?如果没有,不同的定位意味着什么?
为什么在ArrayList只有1的情况下有两个类型的参数是合法的?
我已经搜查了通常的地方。Angelika和这里,但是除了ANTLR项目的Java语法文件中的
请帮助我理解继承是如何工作的。
如果我有两个班,父母和孩子。当我创建一个子实例时,父类实例是否也被构造了?
我的Parent类代码。
public class Parent {
private char s;
@Override
public int hashCode() {
return s;
}
}
和Child
public class Child extends Parent {
private int i;
public Child(int i) {
super();
this.i =
我对C#中的多态性和继承有些困惑。在学习多态性时,我发现像这样的新的P= ParentClass ChildClass();,这有点令人困惑。为什么有人要创建父类的类型来存储子类的对象?然而,它在c#中是有效的,我只想理解三件事: 1.这样做的目的是什么? 2.这样做的好处是什么? 3.我们什么时候应该像这样创建对象?下面是我的代码以供参考:
using System;
class ParentClass
{
public void Display()
{
Console.WriteLine("Display method in Parent clas
考虑以下代码片段:
class Parent {
Parent() {
this = new Child();
}
}
class Child extends Parent { }
以上将引发语法错误:The left hand side of an assignment operator must be a variable
在java中,this关键字存储当前调用对象的内存地址。我希望用类子类的实例覆盖当前对象。我理解上面的片段抛出了一个错误,因为this不是一个变量,而且可能是不可变的。
但是,我想知道为什么java不允许这样的特性?有什么不好的地方吗?
我就是这样遇到这个问题的。我举一个例子:
package check;
public class Check {
int a,b;
Check (int i,int j) {
a = i;
b = j;
}
}
这很好。现在,我想通过扩展Check来创建一个子类。所以我写到:
class V extends Check {
}
我一写完它,Eclipse中就出现了一个十字架,点击它,我找到了一条消息:
implicit super constructor Check() is undefined for default constructor. Must def
我正在学习std::vector in C++。I 表示,const std::vector<int>意味着我们不能更改该向量中的单个元素,也不能在其中追加/回推更多的元素,也就是说,我们只能从一个const实体中读取对元素的访问。但是,我发现在定义const std::vector时与定义其他const类型(如int、double等)有区别。情况如下:
int main()
{
const int i; //doesn't compiler as expected: initializer needed here
const std::vector&