相关疑难解决方法(0)

错误来自此行BoardState addme = new BoardState();

由于某种原因,它所指向的非静态变量是"新的".我不清楚如何修复此错误,因为新的并不意味着变量,而不是.

通过stackoverflow记录查看此错误通常来自非静态方法,该方法通常通过使方法静态或完全绕过该方法来解决.Ť

下面的代码用于引用此语句之前和之后发生的事情.

public class IntelligentTicTacToe extends TicTacToe {

public class BoardState{
    public String TTTState;
    public int[][] defensiveOppsArray;
    public int[][] offensiveOppsArray;
    public String str;
    public int cnt;
}

public static ArrayList<BoardState> memory = new ArrayList<BoardState>();


public static boolean makeMove(){
    char[] oArray = new char[TicTacToeArray.length];
    int[][] defensiveOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
    int[][] offensiveOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
    int[][] sumOppsArray = new int[TicTacToeArray.length][TicTacToeArray.length];
    //converts our Array into a String
    String x = convertTTTArrayToString();

    //Goes through the conditions to see …

我正在尝试使用与view pager + tabsPlayStore 5.1.x 相同的设计.这是我的布局:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_gravity="center_vertical|center_horizontal"
    android:gravity="center_vertical|center_horizontal"
    android:orientation="vertical">

    <com.astuetz.PagerSlidingTabStrip
        android:id="@+id/tabs"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:background="@drawable/background_tabs" />

    <android.support.v4.view.ViewPager
        android:id="@+id/pager"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</LinearLayout>

我的适配器:

public class MainPagerAdapter extends FragmentStatePagerAdapter {

    private ArrayList<FakeFragment> fragments;

    public MainPagerAdapter(FragmentManager fm) {
        super(fm);
        // TODO Auto-generated constructor stub
        fragments = new ArrayList<FakeFragment>();
    }

    @Override
    public Fragment getItem(int position) {
        // TODO Auto-generated method stub      
        if(position < getCount()) {
            FakeFragment fragment = FakeFragment.newInstance(position);
            fragments.add(fragment);
        }
        return fragments.get(position);
    }

    @Override …

我很困惑为什么这是允许的

public class Foo {
    class Bar extends Foo {
    }
}

但这是不允许的

public class Foo {
    class Bar extends Foo {
    }

    class Fooey extends Bar {
    }
}

编译器通知它在调用超类型构造函数之前无法引用Fooey.this.

这是允许的

public class Foo {
    static class Bar extends Foo {
    }

    class Fooey extends Bar {
    }
}

这里发生了什么？我在哪里可以找到有关内部类继承如何工作的更多信息？

编辑我遇到了两个相当糟糕的想法; 内部类扩展外部类,内部类扩展其他静态内部类.我不确定到底发生了什么以及我应该如何重构这一点.我最终只是将内部类拉出来并将它们封装在外部类中.

class Outer {    
    class Inner {       

    }    
}

public class Demo {
    public static void main(String args[]) {

        Outer o = new Outer();
        Outer.Inner inner = o.new Inner();    

    }    
}

我为Inner类对象创建引用的方式就像访问类中的static成员一样Outer？
你能解释一下这背后的机制吗？

试着在LocalDateSpring Data MongoDB和Spring 4中使用JodaTime ,但是我得到以下异常:

SEVERE: Servlet.service() for servlet [dispatcher] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.data.mapping.model.MappingException: No property node found on entity class com.th.model.Price to bind constructor parameter to!] with root cause
org.springframework.data.mapping.model.MappingException: No property node found on entity class com.th.model.Price to bind constructor parameter to!
    at org.springframework.data.mapping.model.PersistentEntityParameterValueProvider.getParameterValue(PersistentEntityParameterValueProvider.java:74)
    at org.springframework.data.mapping.model.SpELExpressionParameterValueProvider.getParameterValue(SpELExpressionParameterValueProvider.java:63)
    at org.springframework.data.convert.ReflectionEntityInstantiator.createInstance(ReflectionEntityInstantiator.java:71)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.read(MappingMongoConverter.java:249)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.read(MappingMongoConverter.java:230)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.read(MappingMongoConverter.java:190)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.read(MappingMongoConverter.java:186)
    at org.springframework.data.mongodb.core.convert.MappingMongoConverter.read(MappingMongoConverter.java:77)
    at org.springframework.data.mongodb.core.MongoTemplate$ReadDbObjectCallback.doWith(MongoTemplate.java:2121)
    at org.springframework.data.mongodb.core.MongoTemplate.executeFindMultiInternal(MongoTemplate.java:1805)
    at org.springframework.data.mongodb.core.MongoTemplate.doFind(MongoTemplate.java:1628)
    at org.springframework.data.mongodb.core.MongoTemplate.doFind(MongoTemplate.java:1611) …

我在内部类中创建了一个内部类:

public class EnclosingClass {

    public class InnerClass {
        private EnclosingClass getEnclosing() {
            return EnclosingClass.this;
        }

        public class InnerInnerClass {
            private InnerClass getEnclosing() {
                return InnerClass.this;
            }

            private EnclosingClass getEnclosingOfEnclosing() {
                return EnclosingClass.this;
            }
        }        
    }
}

我很惊讶java允许InnerInnerClass直接访问EnclosingClass.这个代码是如何在Java内部实现的？

在InnerInnerClass保持两个指针(一个在InnerClass和其他的EnclosingClass)或InnerInnerClass访问EnclosingClass过InnerClass？

更新:

我还不清楚这一点.我正试图找到JLS来描述这种行为.相反,我在JLS的8.3中找到了这个引用:

成员类声明(第8.5节)描述了作为周围类成员的嵌套类.成员类可以是静态的,在这种情况下,它们无法访问周围类的实例变量; 或者他们可能是内部阶级(§8.1.3).

这是不是意味着嵌套的静态类不应该访问外部类变量？我在哪里可以找到应该是什么行为的澄清？

结束更新

我正在寻求通过静态嵌套类的实例来澄清外部类的私有成员的可访问性.在Java教程状态:

静态嵌套类在行为上是一个顶级类,它嵌套在另一个顶级类中以方便打包

这个问题的接受答案(Java内部类和静态嵌套类)提到:

创建静态内部类的唯一真正可能的原因是这样的类可以访问其包含类的私有静态成员

但似乎静态嵌套类也可以访问封闭类的任何实例的私有成员？这将与任何其他顶级课程有所不同.在下面的示例中,静态嵌套类Builder可以访问该类的任何实例的私有成员Config.但是另一个顶级类将无法做到这一点(例如,一个实例ConfigTest将无法更改配置对象的私有成员,如注释manipulateConfig方法中所示.

我理解正确吗？我没有在JLS中找到一个参考来为我澄清这一点.

配置:

public class Config {

    private String param1;
    private int param2;

    private Config() {}

    public String getParam1() { return param1; }
    public int getParam2() { return param2; }

    @Override
    public String toString() {
        return "Config{" + "param1=" + param1 + ", param2=" + param2 + '}';
    }



    public static class Builder { …

Outer outer = new Outer();

一个Object的Outer类是在堆中创建和参考变量指向它.

如果我在写作时就明白了

Outer.Inner inner=outer.new Inner();

Inner类的对象在堆上创建并inner指向它.在堆中,我们有两个独立的对象,它们包含自己的实例变量.

但如果我写

Outer.Inner inner=new Outer().new Inner();

仍然Object会在堆上创建两个for for Outer和other for Inner.但参考,inner只有Inner Object's成员可以访问.谁在指Object堆外？如果它没有被任何引用引用,那么它应该有资格进行垃圾收集,这会影响其使用inner.

非静态成员类的构造函数采用额外的隐藏参数,该参数是对直接封闭类的实例的引用.还有一个'new'的语法扩展.

在下面的代码中,

class K{
    static class Ka{
        static class Kb{
            class Kc{
                class Kd{

                }
            }
        }
    }
}

class Test{
    K.Ka.Kb.Kc.Kd k = new K.Ka.Kb().new Kc().new Kd();
}

能否请您帮助我理解的意思Kb()的K.Ka.Kb().new Kc().new Kd()？据我所知,这new Kc()是第一段所述.

只是一个简短的问题:在我在android文档中看到的所有示例中,片段都是静态内部类.这是Android的要求吗？或者他们可以设置为常规内部类？是否有人了解Android的内部结构足以提供答案？

从我在OCJP文档中读到的内容来看,这些静态内部类根本不是类,而只是包含它们的类的静态成员,就像任何静态方法一样 - 例如main.

您的见解表示赞赏.