我被困在我的C++个人学习过程的一点上。我来自Java语言。
我试图在C++中设置一个类,它有一个抽象的方法。到目前为止,没什么大不了的。但是,我想实例化这个类,就像我可以在Java中做的那样:
// MyClass has an abstract method named "AbstractMethod"
MyClass class_object = new MyClass()
{
@Override
public void AbstractMethod()
{
// Do something here
}
};
class_object.A
假设下面的Java代码,
public class ParentClass{
private parentClass(){}
public class ChildClass {
public ChildClass(){}
}
}
我不能像这样实例化ChildClass:
new ParentClass.ChildClass();
这只能通过在Java中实现ChildClass static来实现,而可以在C#中完成而不使其成为静态的。
我的问题是,如果嵌套类是静态的,那么为什么可以在Java中实例化它,为什么在C#中不可能实例化。这两种语言的静态定义不同
我有一个java类如下所示:
public class MyClass {
public MyClass() {
System.out.println("In Constuctor.");
}
{
System.out.println("Where am I?");
}
public static void main(String[] args) {
new MyClass();
}
}
上述类别的输出如下:
Where am I?
In Constuctor.
在Java中初始化块的需要是什么?它在编码方面有什么帮助?
我们是否只是在代码中额外添加了一组花括号?
例:
public class GFG
{
// Initializer block starts..
{
// This code is executed before every constructor.
System.out.println("Common part of constructors invoked !!");
}
// Initializer block ends
public G
将所有类代码保存为单独的.java文件是否重要,如下所示?
Outer.java,
Inner.java,
Test.java
或者,我可以将一个java文件创建为Test.java。请解释一下匿名类,我们如何在java中创建匿名类,与普通类相比,它的优缺点是什么?
class Outer {
private int data = 50;
class Inner {
void msg() {
System.out.println("Data is: " + data);
}
}
}
class
我是Java新手。我想知道它们之间的区别:
List< String > list = new ArrayList<>();
和
ArrayList< String > list = new ArrayList<String>();
和
ArrayList< String > list = new ArrayList<>();
谢谢
我正在学习JAVA,并试图制作一个程序,对任意数量的整数进行求和和平均数。我已经为此创建了两种方法,一种是获取条目的数量:
private Scanner takeNumberOfEntries(){
Scanner numberOfEntries = new Scanner(System.in);
System.out.println("Number of entries:");
while (!numberOfEntries.hasNextInt()){
System.out.println("Enter the right
请考虑以下课程:
package test;
public class Container {
public class Contained {
public void foo() {
System.out.println("printed");
}
}
}
Main.java:
package test;
public class Main {
public static void main(String[] args){
Container c = new Containe
我正在尝试在Clojure中创建一个新的SimpleLinkResolver。这是JavaDoc:
我的clojure代码是:
(def lr (new io.prismic.SimpleLinkResolver))
但是,在repl中,我得到了以下错误:
CompilerException java.lang.InstantiationException, compiling:(form-init460449823042827832.clj:1:1)
我没有问题创建一个java.util.Date:
(def d (new java.util.Date))
=> #'pris
在下面的示例中,如果我为一个名为示例的类创建一个构造函数,如下所示:
public class Example{
public Example(){
this.super();
}
}
由于javac Example.java通知以下编译错误,上述操作将无法工作:
Example.java:3: error: illegal qualifier; Object is not an inner class
this.super();
^
1 error
但是,它不应该像使用super()那样隐式地声明super(),而是
我在matlab脚本(但面向对象)软件中使用java公共接口。
我们经常要调用java方法,并且这项工作完美无缺。如果我有以下java类:
package com.toto
public class Foo {
public static void printHello() {
System.out.println("Hello World");
}
}
然后在Matlab中我只调用:
com.toto.Foo.printHello
使打印显示在我的控制台命令中。
现在,我想做的是类似于:
package com.toto
public c
我正在阅读Java库中的一些源代码,在这里我感到很困惑;
这段代码来自jaxb库中的Document.java,而ContentVisitor是同一个包中的接口,我们如何使用新关键字创建接口实例?这不违法吗?
public final class Document {
.
.
private final ContentVisitor visitor = new ContentVisitor() {
public void onStartDocument() {
throw new IllegalStateException();
}
public
我在这里遇到了一个奇怪的结果,我不确定这是Java中的错误还是预期行为。我有一个内部类,在这个类上我使用反射来获取声明的字段(class.getDeclaredFields())。但是,当我循环遍历字段列表并检查各个类型时,"this“字段返回的是外层类而不是内部类。
这是预期的行为吗?这对我来说似乎很奇怪。
例如:
import java.lang.reflect.Field;
public class OuterClass {
public class InnerClass{
public String innerClassString;
我有三节课
class WithInner {
class Inner {}
}
public class InheritInner extends WithInner.Inner
{ //constructor
InheritInner(WithInner wi) {
wi.super();
}
}
这个例子取自Eckel在Java中的思想。我不明白为什么我们不能调用wi = new WithInner();而不是.super()?在调用wi.super()时,我们正在调用对象的默认构造函数,不是吗?
当我们在java中的语句System.out.println()输出屏幕上的东西时。在这个语句中,System是类,out是该类的对象,println()是该类的方法。
当我们在B类中声明A类的实例或对象时,使用下面的语法A object;,然后如果该类中有任何方法被声明为公共的,则在下面的语法中调用object.method(argument)。
现在我的问题是,为什么我们不能用下面的语法out来声明类System的对象System out = new System();。
当我们试图在java中实例化一个内部类(又名:非静态嵌套类)时,假设我们在两种情况下这样做:
1.在外部类的同一个文件中的一个主要方法中,我们有两个选项:(ex:)
public class Test1
{
class InnerClass
{
}
public static void main(String[] args)
{
InnerClass inner = new Test1().new InnerClass();
}
}
或:
public class Test1
{
class InnerClass
{
}
pub
考虑以下片段:
(我在检查一些反编译的类文件时遇到了这种语法,这是一个最小的表示)
public class Main {
public static void main(String[] args) {
Main.Inner o = new Main().new Inner() {};
System.out.println("Bye from " + o.getClass());
}
class Inner {}
}
它编译并运行良好(我测试了一堆JDK)。
请有人解释一下这是如何编译的,这段代码代表什么?
此代码创
// allows passing in arguments to the MyActor constructor
ActorRef myActor = system.actorOf(new Props(new UntypedActorFactory()
{ //
public UntypedActor create() { //
return new MyActor("..."); // <- this part confuses me
}
考虑下面的代码:
class Outer {
class Inner
}
在Java中,可以使用以下命令创建一个Inner实例:
Outer.Inner inner = new Outer().new Inner();
我知道我可以用Scala写下:
val outer = new Outer
val inner = new outer.Inner
但我想知道是否可以在不对outer赋值的情况下表达相同的内容。
两者都有
new Outer.new Inner
和
new (new Outer).Inner
都不被编译器接受。
我是不是漏掉了什么?
我正在读一篇关于内部课堂的文章。我找到了一个演示匿名内部类的示例(下面提到)。
button1 = new JButton();
button2 = new JButton();
...
button1.addActionListener(
new java.awt.event.ActionListener()
{
public void actionPerformed(java.awt.event.ActionEvent e)
{
// do something
}
}
)