我知道嵌套类没有静态成员,
class OuterClass {
class InnerClass {
private static int x = 0; // this is error
}
}
但当我们最终宣布
class OuterClass {
class InnerClass {
private static final int x = 0; // ok
}
}
它与最后一个关键字有关吗?因为变量不能再改变了吗?还是还有别的原因?
当用户旋转android设备时,我正在尝试保存类的状态。我想使用putSerializable和getSerializable函数来获取和设置android Bundle中的类。这个类的简化版本如下所示:
public class State implements Serializable
{
public class Unit implements Serializable
{
private static final long serialVersionUID = 9107072458243854482L;
private String mName;
pri
我需要从静态类中的方法引用顶级类的变量。
此方法应该作用于顶级类的唯一实例,因此感觉我不应该在静态类中实例化顶级类。
基本上我想要像这样的东西
public class TopLevel{
// private
int innerV
public static class Inner implements X {
for(i=0; i<innerV,i++){
doSomething
}
}
}
在for循环和类似的地方,是否可以只说this.innerV或类似的东西?
import javax.swing.*;
import javax.swing.event.*;
public class NewGUIStuff{
public static void main(String args[]){
NewGUIStuff gui = new NewGUIStuff();
gui.go();
}
class handlesListListeners implements ListSelectionListener{
public void valueChanged(ListSelect
final TextView dob = (TextView) findViewById(R.id.TextView_DOB);
DatePickerDialog dateDialog = new DatePickerDialog(this,
new DatePickerDialog.OnDateSetListener() {
@Override
public void onDateSet(DatePicker view, int year, int monthOfYear,
我想创建一个只能从超类的实例访问的子类,但不能从超类本身访问,以确保超类的变量已经初始化。例如:
public class SuperClass
{
int num;
SuperClass(int number){
num = number;
}
//Make this\/ accessible from instance only
class SubClass
{
SubClass(){}
public int read(){
retur
在以下场景中,我很难找到正确的重构选项:
我有这样的代码(在Outer.java中):
public class Outer {
// ... class stuff
public static class Inner {
// ... inner class stuff
}
}
我正在寻找一种方法来选择内部,并让它转换为顶级类,在它自己的.java源文件。我知道手动复制/粘贴等操作非常容易,但是内部类在很多地方都是引用的,我希望refactor选项可以在引用的任何地方处理更改。
我已经尝试了Refactor -> Extract Cla
我很想了解为什么下面的实例化不会编译:
Superclass.Subclass myObject = new Superclass.Subclass();
错误消息如下:
No enclosing instance of type Superclass is accessible. Must qualify the allocation with an enclosing instance of type Superclass (e.g. x.new A() where x is an instance of Superclass).
包围实例是什么意思?为什么有这个必要?
这条消息似乎是在声
这是我刚刚写的代码的一部分。基本上,类Document实现了Iterable接口。迭代器将像链表一样遍历节点。在remove方法中,我使用了Document类范围内的nodeMap引用。但是,this引用应该引用Iterator本身,那么它怎么能找到那个对象呢?或者Iterator是Document的子类
我以前没有想过这个问题。突然间就把自己搞糊涂了。
public class Document implements Iterable<DocumentNode> {
Map<Integer, DocumentNode> nodeMap;
public
在下面发布的代码中,HTEsotericPoliticsOfTheWest是一个内部类,当我试图定义一个接口时,eclipse生成了一个错误,因为接口不是ststic!您能解释一下为什么接口必须在内部类的上下文中声明为ststic吗?
**代码:
//This is an inner-class
private class HTEsotericPoliticsOfTheWest extends HandlerThread {
private final String TAG = HTEsotericPoliticsOfTheWest.class.getSimpleName();
我尝试声明一个类,如下所示
class Outer{
private final class Inner{
public static final String s1 = new String("123");
public static final byte[] bytes = new byte[]{0x00, 0x01};
public static final String s2 = "123";
public static final byte byte1 = 0x02;
}
}
在上面的
我是科特林的新手。我在Adapter中使用了以下代码:
class TravelListAdapter(private var context: Context) : RecyclerView.Adapter<TravelListAdapter.MyViewHolder>() {
lateinit var onClickListener: TravelListAdapterListener
lateinit var holderView: View
interface TravelListAdapterListener {
fun onC
由于某些原因,当试图将单击侦听器应用到我的RecyclerView项以启动新活动时,不会读取RecyclerView适配器中的上下文。myContext.startActivity(intent)返回一个“未解决的引用”错误。为了阅读上下文,应该将其更改为什么?我是否需要使用视图持有者或TextView的上下文或其他什么东西?
未解析引用: myContext
class MyAdapter(
val myContext: Context,
var listCompany: MutableList<ItemCompany>,
pri
我有一个类称为A,而静态嵌套类称为B。
public class A {
public static class B {
B(Temp x) {
x.reg(this); // need to pass the nested class reference.
}
}
}
以上代码正确吗?我们可以在嵌套的静态类构造函数中使用this关键字吗?
请帮帮我。谢谢。
我对Java很陌生,但我在C#上工作了多年。所以我要把用Java编写的代码翻译成C#。一切都还好,但我想出了一个似乎很奇怪的密码。以下是代码:
//Java Version
public class ParentClass{
ArrayList<SomeType> values;
void MyFunction(){ /*some codes*/ }
//other codes
public class NestedClass {
public void handleMessage(SomeType val) {
假设我有一些如下的java代码:
public class MainClass {
private static class NestedClass {
<modifier> int field;
}
}
修饰符做了什么吗?IE说public int field和private int field有什么区别吗,因为在这两种情况下,字段都只能在MainClass中访问?这类代码的标准样式指南是什么?我知道如果NestedClass不是私有的,那么修饰符可能会区分作用域,但是因为它是私有的,所以字段的有效访问模式将是相同的,无论修饰符是什么,对吗?
是否可以从外部类中初始化具有标记为私有的构造函数的内部类的实例。我的印象是,一旦一个构造函数被声明为私有,除了类本身之外,没有人可以创建该类的实例。示例
Public class Outerclass
{
newinstance = new Innerclass();
private final class InnerClass
{
private InnerClass(//paremeters)
{
//constructor declaration inside
假设我有一个内部类B,我将在外部类的一个成员函数中创建一个实例,有没有一种方法可以在不创建外部类的实例的情况下做到这一点?
非常感谢。
class A {
class B {
}
public void function() {
// create an instance of B, normally have to create a
// instance of A to be bond to by b
B b = new B();
}
}
使用Google Web Toolkit,我编写了一个基于模型-视图-控制器概念的应用程序。现在,我的ClientController类有两个ClientModel和ClientView类型的对象,它们被声明为私有和非静态的。使用异步调用的对象,我已经编写了一些确实有效的远程过程调用,但是附加一个来自AsyncCallback<T>类型的匿名对象使我成为一个问题,因为如果不在我的函数中编写一些讨厌的final变量,我就无法访问两个ClientModel和ClientView对象,如下所示:
package com.foo.bar;
/**
* Represents the ma
当我用C语言编写面向对象的代码时,我通常将结构定义和公共函数放在一个头文件中,并在一个单独的.c文件中实现公共函数。我将static关键字赋予这个类的所有“私有”函数,并在.c文件中实现它们。然后,公共函数可以调用属于同一类的私有函数。私有函数不能从外部调用,这要归功于static关键字,所以GCC可以优化其中的许多函数。它们通常是内联的,原始函数会从输出对象文件中完全删除。
现在来看我的问题:如何对C++类执行相同的操作?
假设我有一个头文件:
class A {
int private_field;
int private_function();
public:
i
我正在学习Java,对内部类被声明为静态类的概念有点困惑。据我所知,声明任何成员静态意味着它属于类级别,而不是类的实例,而内部类是外部类的实例,我们可以想实例化多少次就实例化多少次。
那么,我们如何将其声明为静态呢?它与静态关键字的概念相矛盾。如果将类声明为static,那么该类的所有成员在缺省情况下都不应该成为static吗?但事实并非如此。为什么?
class Outerclass{
static int a=10;
static class Innerclass{
System.out
我正在阅读有关接口和类中的内部类的内容。我无法理解真正的用途。然而,在这篇文章中,我不想讨论任何关于接口内部类的内容。
到目前为止,我一直使用内部类作为回调。我可以在外面的某个地方做同样的声明。
假设我有一个学生列表,我想按id对它们进行排序。我必须实现比较器接口,并将其作为集合的排序方法的参数。
public class StudentList {
public static void main(String[] args) {
List<Student> students = new ArrayList<Student>();
我正在学习内部班级。出于好奇,我扩展了内部类,它有一个参数化的构造函数。但是,当我编写super(int )来调用它时,代码不能编译。
class Outer{
class Inner{
private int a;
Inner(int i){
this.a=i;
}
public void inheritFromInner(){
System.out.println("Inherited from inner");
}
}
}
class Test extends Outer.Inner{
此代码有错误
public class DoIt {
public static void main(String[] args) {
final class Apple {
public static String place = "doIt";
}
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.
abstract class A {
public void disp() {
System.out.print("Abstract");
}
}
public class B {
public static void main(String args[]) {
A object = new A(){ };
object.disp();
}
}
我知道抽象类不能被实例化,但在这段代码中是混乱的。这段代码到底是什么意思?
对于匿名内部类,Java如何处理在匿名内部类块外部声明的字段。
在policyOwnerModelObject案例中,该字段在生成的匿名内部类中是如何定义的?
// Local variable
final Bean policyOwnerModelObject = XXXXX <--- here, how is the class built with access to this object. Is it a final field in the class?
final WebMarkupContainer container = new WebMarkupConta
可能重复:
让我们来看看下面的Java代码片段。它只是总结了在Inner类中声明的Outer类中的两个数字,并且按照预期工作得很好。
package staticfields;
final class Outer
{
final public static class Inner
{
private static int x;
private static int y;
public Inner(int x, int y)
{
Inner.x=x;
Inne
当实例化中的嵌套类时,它如何引用外部类?它总是扩展外部类还是以其他方式引用它?有人告诉我,内部扩展了外部,但是为什么下面的例子不能工作呢?
例如,:
public class OuterClass {
public String fruit = "apple";
public class InnerClass {
public String fruit = "banana";
public void printFruitName(){
System.out.println(this.f
从下面的代码中可以看到,我们编写RemoveDups_1.LinkedList linkedList = new RemoveDups_1.LinkedList();来获取非静态类RemoveDups_1中的静态类LinkedList的实例。
import java.util.*;
public class RemoveDups_1{
public static class LinkedList{
static int i = 5;
class Node{
int data;
Node next;
这是我的密码
class LinkedUserList implements Iterable{
protected LinkedListElement head = null; /*Stores the first element of the list */
private LinkedListElement tail = null; /*Stores the last element of the list */
public int size = 0; /* Stores the number of item
为什么java不允许在非静态内部类中带有静态初始化块的静态声明?
在下面的代码中,尽管做了同样的事情,但outer2可以工作,而inner2不能。有什么想法吗?我并不是在寻找变通的方法,我只是想知道为什么java不能做到这一点。
public class WhyUNoStatic {
public static final String outer1 = "snth"; // ok
public static final String outer2; // ok
static
{
outer2 = "snth"