Why inner classes cannot have static declarations ?

Hi Friends,
When i tried to make static declarations on a inner class which is non static, i am getting compilation error saying "inner classes cannot have static declarations". I want to know reason behind this implementation.
Code which i have tried:
public class TestOuter
class TestInner{
static int i =10;
public static boolean validate(int a){
if(a==0)
System.out.println("Invalid data");
return false;
return true;
public static void main(String a[]){
boolean result = new TestOuter.TestInner.validate(0);
System.out.println("Result="+result);
Thanks,
Shiju V.

so I think if the
outer class is not static , then Inner class can't be
static as well. This is incorrect. An enclosed class can be indeed static while the outer is not, and vice versa.
The difference between static/non static in regards to enclosed classes is that the static ones are 'top-level' and cannot access the members of the enclosing class.
The effect of making an enclosed class static means there is only one instance of any variables, no matter how many instances of the outer class are created. In this situation how could the static inner class know which variables to access of its non static outer class. Of course the answer is that it could not know, and thus an static inner class cannot access instance variables of its enclosing class.
Now, regarding non-static inner classes, and trying to give a valid answer to the original post:
As with instance methods and variables, a non-static inner class is associated with an instance of its enclosing class and has direct access to that object's instance variables and methods.
TestOuter outer = new TestOuter();
TestOuter.TestInner inner = outer.new TestInner();Because an inner class is associated with an instance (inner class implicitly keeps a reference to the object of the enclosing class that created it), it cannot define any static members itself. Static members cannot access the this pointer.
So, in an ordinary (non-static) inner class, the link to the outer class object is achieved with a special this reference. A static inner class does not have that special this reference, nor would a static method/variable of an ordinary (non-static) inner class.

Similar Messages

  • Why Inner class cannot access static variables

    Why is it that inner class can use only static final variables of the outerclass, and not ordinary static variables of the outer class. "Yes the JLS sepcifies that only final static variables can be used inside an inner class, esp a non blank final variable". But why this restriction.
    Thanks.

    so what are final static variables treated as if they
    are not variables. So if the final static value is
    not loaded when the class is loaded how will the
    class know about the value.??The actual value wil be substituted for the name of a static final value at compile time. That's why you can use them in switch statements where you can't use any variable variable.
    This is something to watch out for, by the way, because if you use a public static final value from one class in another the actual value will be compiled into the using class, so if you change the value where it's defined the class using it will have the old value until it's recompiled.

  • Why is it that the interfaces cannot have static methods?

    why is it that the interfaces cannot have static methods?

    Interfaces contain polymorphic methods. Static methods are not polymorphic, and therefore would not make any sense to be in interfaces.

  • Why can an inner.inner class not be static?

    First, look at these 2 classes:
    public class A1 {
    public A1() {
    new B1.C1();
    public class B1 {
    public static class C1 {
    public class A2 {
    public A2() {
    new B2.C2();
    class B2 {
    public static class C2 {
    Class A2 will compile just fine, but A1 will not saying that I can't define class C1 as static.
    Why not?
    Class C1 is not associated with an instance of B1 (because it's static), and we already have an instance of A1 (since we're in the constructor).
    Why is this so radically different that A2 (which works)?

    In class A1 the inner class B1 is just like a mehtod of class A1.
    So how we cant create static variable inside a method , similarly the class A1
    didnt accepting its inner class b! to create static class.
    (This is my assumption/view only, may be wrong)

  • JDeveloper 10.1.2.0.0 - Inner class cannot be found

    Hi!<br>
    <br>
    I use Apache MyFaces 1.1.1 (Nightly Build 20051130) to create a Web app and imported all necessary libraries. I want to write a custom ViewHandler at the moment and experience a strange problem. I want to use a public inner class of javax.faces.application.StateManager, named SerializedView, but this class cannot be found when I try to import it with the following statement:<br>
    import javax.faces.application.StateManager.SerializedView;<br>
    JDeveloper just says: <br>
    Imported class 'javax.faces.application.StateManager.SerializedView' not found<br>
    I already successfully use many other javax.faces classes, like StateManager...<br>
    Any help would highly be appreciated, since this is a real blocker for me.<br>
    <br>
    Regards,
    Matthias

    Hi again!<br>
    <br>
    The problem is solved for the most part now. Compilation works fine, although the Java editor says the class SerializedView cannot be found.<br>
    <br>
    So the Java editor's behavior is still strange...<br>
    <br>
    Regards,<br>
    Matthias

  • Why Portlet regions cannot have their own style ? We need to use it.

    We need to visually group portlets on the same page.
    So we need to give different background different
    But Portlet regions cannot have their own style.
    So we cannot do it.
    Can we by pass this restriction? How ? ( We try to use html template, html content layout. But they don’t work.)
    Is this restriction will remove from future versions? (especilly 11g)
    Thanks.

    We ran into the same thing. I'm assuming you want to display different portlets on the same page with different looks. Here are a few things you might try (depending on the portlets, of course).
    - Adding another .css file in the cascade within the UI template
    - If using page portlets, add your own formatting to the page
    - Use dynamic pages with hard-coded formatting
    None of these will work for all cases, mind you. But it might give you a starting point. Good luck!

  • About  "abstract class cannot have be instantiated"

    in java coding it means
    ========
    abstract  class X
      public X();
    }========
    no {} is allowed to public X
    or i can not write a invoke as
    ========
    X x=new X();========
    or both of them are forbidden by abstract class?
    why body{} is related to instantiated?
    why a abstract class can not has a static method?

    in java coding it means
    ========
    abstract class X
    public X();
    ========
    no {} is allowed to public X???
    You must include the braces for the constructor. The code you have posted won't compile.
    or i can not write a invoke as
    ========
    X x=new X();
    ========Correct. You need to provide the implementation first, which can be as simple as "X x = new X() { };".
    why body{} is related to instantiated?It's not.
    why a abstract class can not has a static method?It can. Try writing some of your own tests to validate your (incorrect) assumptions.
    Example:abstract class X
      public X() { };
      static void foo() {};
    }

  • Why my iPhone4s cannot have access to wifi in my house?

    It just said "Failed to join xxx".
    Solution needed.thanks a lot
    Cheusie

    Has your iPhone 4S ever connected to your wi-fi network at home?
    Do you have problems connecting your 4S to any other wi-fi network besides your own?

  • Your Opinions: Inner Classes Need static Members

    Hi All,
    I want to solicit opinions for a minor change to the way inner classes work. I submitted this as an RFE to Sun and they rejected it, really without giving a reason. I'd like to know your opinions. If there is strong support I will repost the RFE.
    As you probably know, inner classes cannot have static members. The following generates a compiler error:import java.util.*;
    public class MyClass {
       class MyInnerClass {
          // Next line causes compiler error...
          static Map m = new HashMap();
    }In order to get around this you have to make the Map variable a static member of the containing class:import java.util.*;
    public class MyClass {
       static Map m = new HashMap(); // so much for encapsulation...
       class MyInnerClass {
    }I am suggesting that inner class be allowed to contain static members. Here's my reasoning...please comment:
    There are times when members (i.e., fields and methods) rightfully belong to the class as a whole, not to any particular instance of a class. I'm sure we've all found times when it was necessary to have static members in our classes. The same issues that necessitated using static members in top-level classes make them desirable for inner classes as well.
    Designing a class as an inner class is a step toward encapsulation. By forcing static members that logically belong in an inner class to be declared in the containing class is to crack the encapsulation, IMHO.
    Even though a containing class has access to all of an inner class' members (including private members) and vice versa, I think the notion of inner static members still is more OO-ish.
    What are your opinions? Would allowing inner classes to contain static members make Java more object oriented? I think it would.
    Technically, I don't think there's any reason this cannot work since the JVM has no notion of inner classes, per se.
    What do you think?

    an inner class is effectively a non static instance
    variable of its enclosing class. Instance member, but not a variable. it's a class, a type, not a variable.
    >
    I think the problem here is that making a field static
    means more than just that that field and its value are
    common to every instance of the class. It means that
    the value is valid without an instantiation of that
    class.
    Since the class itself must be instantiated (it is
    not static), What do you mean, excatly, by "_must_ be instantiated"? You are not ever "required" to instantiate anything unless you want to use it.
    you can't have static member data inside it. I don't see how this follows from the previous part of the statement.
    How would you reference the static member data of
    the inner class? You would have to specify an
    instance of the inner class, and since this breaks
    the meaning of static, you can't have static members
    in an inner class.How about outerObj.InnerClass.staticMember The syntax is well defined. The question at hand is, do we really want to allow this? The syntax to do this should only be an issue after that question has been answered in the affirmative. The people at Sun have decided not to allow it, so for now, syntax is a non-issue.
    >
    if you wanted a static member in an inner class you
    could put it in a super class of the inner class...Or in the enclosing class, as suggested in the orginal post.

  • Serializable inner classes

    How does one deal with the serialVersionUID issue with non-static member classes? Is this the best we can do?
    class A implements java.io.Serializable {
      static final long serialVersionUID = 42;
      @SuppressWarnings("serial") class B implements java.io.Serializable {...}
    }MC

    How interesting. I never even tried! The language specs say: "inner classes cannot have static members, <em>except for static final fields that are initialized to constants</em>". This means that the declaration of m is valid but the declaration of n is rejected at compile-time:
    class A implements java.io.Serializable {
      static final long serialVersionUID = 42;
      class B implements java.io.Serializable {
        static final long serialVersionUID = 42;
        static final String m = "42";
        static final String n = String.valueOf(42);
    }MC

  • A question about non-static inner class...

    hello everybody. i have a question about the non-static inner class. following is a block of codes:
    i can declare and have a handle of a non-static inner class, like this : Inner0.HaveValue hv = inn.getHandle( 100 );
    but why cannot i create an object of that non-static inner class by calling its constructor? like this : Inner0.HaveValue hv = Inner0.HaveValue( 100 );
    is it true that "you can never CREATE an object of a non-static inner class( an object of Inner0.HaveValue ) without an object of the outer class( an object of Inner0 )"??
    does the object "hv" in this program belong to the object of its outer class( that is : "inn" )? if "inn" is destroyed by the gc, can "hv" continue to exist?
    thanks a lot. I am a foreigner and my english is not very pure. I hope that i have expressed my idea clearly.
    // -------------- the codes -------------------
    import java.util.*;
    public class Inner0 {
    // definition of an inner class HaveValue...
    private class HaveValue {
    private int itsVal;
    public int getValue() {
    return itsVal;
    public HaveValue( int i ) {
    itsVal = i;
    // create an object of the inner class by calling this function ...
    public HaveValue getHandle( int i ) {
    return new HaveValue( i );
    public static void main( String[] args ) {
    Inner0 inn = new Inner0();
    Inner0.HaveValue hv = inn.getHandle( 100 );
    System.out.println( "i can create an inner class object." );
    System.out.println( "i can also get its value : " + hv.getValue() );
    return;
    // -------------- end of the codes --------------

    when you want to create an object of a non-static inner class, you have to have a reference of the enclosing class.
    You can create an instance of the inner class as:
    outer.inner oi = new outer().new inner();

  • Local variable can't be accessed from inner class ???????? Why ??????

    Plesae help, help, help. I have no idea what to do with this bug.........
    <code>
    for ( int i = 0; i <= 2; i++ ) {
    for ( int j = 0; j <= 2; j++ ) {
    grids[i][j] = new MyButton ();
    grids[i][j].setBorder(but);
    getContentPane().add(grids[i][j]);
    MyButton sub = grids[i][j];
    sub.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
    if ( sub.getState() == 0 ) {
         sub = new MyButton( (Icon) new ImageIcon(imageFile));
         if ( imageFile.equals("cross.jpg") ) {
              sub.changeState(1);
         else {
              sub.changeState(2);
    </code>
    The compiler complains that "sub" is in the inner class, which is the ActionListener class, must be declared final. Please tell me what to do with it. I want to add an ActionListener to each MyButton Object in the array. Thanks ......

    OK, now I changed my code to this :
    for ( int i = 0; i <= 2; i++ ) {
      for ( int j = 0; j <= 2; j++ ) {
        grids[i][j] = new MyButton ();
        grids[i][j].setBorder(but);
        getContentPane().add(grids[i][j]);
        grids[i][j].addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            if ( grids[i][j].getState() == 0 ) {
               grids[i][j] = new MyButton( (Icon) new ImageIcon(imageFile));
              if ( imageFile.equals("cross.jpg") ) {
               grids[i][j].changeState(1);
              else {
              grids[i][j].changeState(2);
    [/cpde]
    Thanks for your advice !!!!!!
    Now the compiler says that i and j are local variables accessed from inner classes, needs to be declared final. How can I solve this then ???

  • Doubt in inner classes

    public class Outer
               public static void main(String argv[])
                         Outer o=new Outer(); //1                    
                         Inner i =o.new Inner(); //2
                         //Inner i =new Inner();  //3
         i.showName();   
             public      class Inner{   
                    void showName()
            System.out.println("hi");            
          }//End of Inner class
    }I have few doubt regrd the above program..
    1)when i create an inner class instance as in line 3,..Iam having an err like
    non-static variable this cannot be referenced from a static context.. Bcas Inner is a non static member of class Outer it cant be referred without an instance of Outer as in line 2.. But my doubt is why it doesnt give such error (of static context issue) in the case of line 1...its a silly dbt but iam confused ...
    2..Can we refer the inner class without outer class like in line 2., I have used
    Inner without Outer ..is this ok... or shuld we use as
    Outer.Inner i =o.new Inner(); //2
    3)In the above line We r associating the instance of inner class with the instance of outer class and the type of inner class with the type of outer class (Outer.Inner )..wht does this mean..
    can anyone pls help me understand this..
    thnx.
    mysha..

    public class Outer
    public static void main(String argv[])
    Outer o=new Outer(); //1
    er o=new Outer(); //1                    
    Inner i =o.new Inner(); //2
    //Inner i =new Inner();  //3
         i.showName();   
    public      class Inner{   
    void showName()
            System.out.println("hi");            
    }//End of Inner class
    }I have few doubt regrd the above program..
    1)when i create an inner class instance as in line
    3,..Iam having an err like
    non-static variable this cannot be referenced from a
    static context.. Bcas Inner is a non static member of
    class Outer it cant be referred without an instance
    of Outer as in line 2.. But my doubt is why it doesnt
    give such error (of static context issue) in the case
    of line 1...its a silly dbt but iam confused ...
    Static methods of a class exist as soon as Java loads the class. Regular, or non-static, methods of a class belong to an object and only come into existence after you create an object of the class. Regular methods are called by an object. Static members are called using the class name.
    Now, examine this simple program:
    class Apple
         private String color;
         public Apple(String color)
              this.color = color;
         public void show()
              System.out.println("apple color: " + color);
         public static void greeting()
              System.out.println("Hello from the Apple class.");
    public class  Demo
         public static void main(String[] args)
              Apple.greeting();  //1
              Apple a = new Apple("red");  //2
    }After the Apple class loads, any static methods in the class exist. Since greeting() is a static method of the Apple class, it can be called in line 1 before any Apple objects exist. But, what about line 2? How can the Apple constructor with the String parameter, which is a method in the Apple class, be called? The constructor isn't declared as a static, so it shouldn't exist in that regard, and no objects of the class exist. So, when and how did the constructor come into existence. That seems to be the question you're struggling with. I think the answer is: a constructor sort of acts like a static method. In order to be able to call a constructor, the constructor must exist as soon as the class loads and before any objects exist. The result is, you can call a constructor at any time.
    I think your example is similar to my example, but you only have one class:
    public class Outer
    public static void main(String argv[])
    Outer o=new Outer(); //1
    }After Java loads Outer, any static methods in Outer exist. Since main() is a static method, it exists. Subsequently, java calls the static main() method to begin execution of your program. In line 1, you call the default constructor for Outer. The default constructor isn't static, so it shouldn't exist, but just like the constructor in my example above, the default constructor acts like a static method, and therefore you can call it without getting an error.
    Inner i =o.new Inner(); //2
    2..Can we refer the inner class without outer class
    like in line 2., I have used
    Inner without Outer ..is this ok... or shuld we use
    as
    Outer.Inner i =o.new Inner(); //2
    I'm not sure what the difference is. In both cases you end up with an object that was created with the expression:
    o.new Inner()
    you just have a different type for your object, i.e. Outer.Inner versus Inner.
    3)In the above line We r associating the instance of
    inner class with the instance of outer class and the
    type of inner class with the type of outer class
    (Outer.Inner )..wht does this mean..
    can anyone pls help me understand this..
    I think you said it: it means you have an Inner object that is "associated" with an Outer object. Like any other regular member in the Outer class, Inner can refer to any members of Outer. (A static member of Outer can't refer to regular members of Outer because static members exist before any objects exist, and when no objects exist, the regular members don't exist.) That means an Outer object must exist before you can create an Inner object.

  • Inner Classes doubts

    Hi All,
    I am trying to learn Inner classes in Java. I am referring to the book Core Java by Horstmann and Cornell.
    I know that there are various types of inner classes namely:
    - Nested Inner classes
    - Local Inner classes
    - Annonymous Inner classes
    - static inner classes
    First I am on with Nested Inner classes :
    Following is the code which I am executing :
    package com.example.innerclass;
    import java.awt.Toolkit;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.util.Date;
    import javax.swing.JOptionPane;
    import javax.swing.Timer;
    public class InnerClassTest {
          * @param args
         public static void main(String[] args) {
              // TODO Auto-generated method stub
              TalkingClock clock = new TalkingClock(1000,true);
              clock.start();
    //          JOptionPane.showMessageDialog(null,"Quit Program");
    //          System.exit(0);
    class TalkingClock
         private int interval;
         private boolean beep;
         public TalkingClock(int interval, boolean beep){
              this.interval = interval;
              this.beep = beep;          
         public void start(){
              ActionListener listener = new TimePrinter();
              Timer t = new Timer(interval,listener);
              t.start();
         private class TimePrinter implements ActionListener{
              public void actionPerformed(ActionEvent event){
                   Date now = new Date();
                   System.out.println("At the tone time is : "+now);
                   if(beep)
                        Toolkit.getDefaultToolkit().beep();
    }Following are my doubts :
    1. Why do we need to give the line
    JOptionPane.showMessageDialog(null,"Quit Program");
    System.exit(0);without this line the program doesn't show any output.
    2. I didn't understand this syntax.
    You can write inner object constructor more explicitly using the syntax. :
    outerObject.new InnerClass(construction parameters)
    For e.g.
    ActionListener listener = this.new TimePrinter();
    Here the outer class reference of the newly constructed TimePrinter object is set to this reference of the method that creates the inner class object. the this. qualifier is redundant. However, it is also possible to set the outer class reference to another object by explicilty naming it. For e.g if TimePrinter were a public inner class, you could construct a TimePrinter for any talking clock.
    TalkingClock jabberer = new TalkingClock(1000,true);
    TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
    Please do help me understand this concept.
    Thanks
    Siddharth

    I have understood that this explanation :
    i) assuming that TimePrinter is an inner class of TalkingClock, that you'd need an instance of the later in order to create an instance of the former.Yes.
    Being a non-static inner class, it can not be instantiated out of context ... which context is the outer class.No. See my reply 11. The "context" is an instance of the outer class - it bears repeating.
    ii) jabberer is the outer instance that you are providing.Yes (more accurately it's a reference to an instance of the outer class, but that would be nit-picking).
    The left side is identifying the class, the right side is identifying the instanceNo.
    I'm not sure what you're calling left side and right side.
    If you're talking about both sides of the equals sign, then no, it's completely wrong.
    If you're talking about both sides of the "point" sign, then it's wrong too, just a bit less wrong.
    Let's revise this step by step (good thought process).
    1. in first line we are getting an outer class reference with this code
    TalkingClock jabberer = new TalkingClock(1000,true);
    this line is very natural and easily understood. Yes. The correct wording would be merely "we are getting a reference to an instance of the outer class". Sorry to insist densely.
    2. Now when we come to the second line, i.e. where we try to instantiate an inner class with this line of code
    TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
    - I do understand the concept that we need an instance of outer class in order to create an instance of inner class as inner class is visible only to outer class.No. We need an instance of the outer class as the inner class is non-static, and by definition needs an instance of the outer class. That has nothing to do with visibility (public vs private vs...). Again, some words have special meanings in the Java world.
    - I also do understand that it cant be instantiated out of context. I see you like this expression, but it is too vague and misleads you. Please forget about it for a moment (no offense to otherwise helpful and knowledgeable abillconsl).
    - I also do understand that left side is identifying the class and right side is identifying the instance. ANDAgain I'm afraid of which "sides" you're talking about.
    - that in this line TalkingClock.TimePrinter listener = new TalkingClock().new TimePrinter();
    the outer class is anonymous (new TalkingClock()) as we don't require its name here Poor choice of words again. Anonymous classes do exist in Java, but are a totally different concept, that is not related to this line.
    - Also in this line TalkingClock.TimePrinter listener = jabberer.new TimePrinter();
    I understood the left side part i.e. TalkingClock.TimePrinter listener =
    We are attaching the outer class reference with the inner class that's absolutely understandable. Not at all!
    This just declares a variable listener, whose type is TalkingClock.TimePrinter (or more accurately com.example.innerclass.TalkingClock.TimePrinter).
    Then follows an assignment:
    WHAT I don't understand is the right hand side, i.e., the statement jabberer.new TimePrinter();
    1. I am unable to digest the fact that we can do something like anobject.new
    new is an operator that is used to instantiate an instance of an object. I am unable to digest that we can do x.new?See my previous reply. This is short-hand syntax Sun chose to pass a reference to an instance of the outer class (here, jabberer) to the constructor of the inner class. They could have chosen something else. Again, bear with it.
    I only know that we can do is new SomeClass(); AND NOT instance.new SomeClass();
    Now you know better:
    The second form is valid - only if SomeClass is a non-static inner class defined in a class of which instance is an instance.
    2. Is there something to this conceptually OR this is only a syntax and that I should learn it.
    I want to understand and grasp if there is some concept behind it rather than just learn and mug up. See my previous reply. Each instance of a non-static inner class stores a reference to an instance of the outer class. There must be a way (a syntax) to specify which instance (of the outer class) should be stored in the instance (of the inner class).
    This particular syntax is just a syntax, the "concept" is that the instance of the inner class stores a (unmodifiable) reference to the instance of the outer class that was specified when the instance of the inner class was created.
    I don't know if that deserves to be called a concept, but that's an interesting thing to keep in mind (there are some not-so-obvious implications in terms of, e.g. garbage collection).
    Best regards.
    J.

  • Extending a member inner class

    I have a class
    public class A{
    class InnerClassB{
    Now the question is how to extend the inner class would it be
    class ExtendingInnerClassB extends A.B{
    or else?
    I am not sure anybody knows?

    Regarding inheritance from inner classes you must define your constructor:
    public ExtendedInnerClass(EnclosingClass EC) { EC.super(); }
    why?????
    well
    1. Where is the handle? The handle is an internal thing which is designed to accept the enclosing class. It is something which is not in the programmer's control. when there is an inner class, it is natural that the inner class cannot exist without its outer class. And that is the reason why the instantiation of an inner class is done using new OuterClass().new Innerclass(). U can see that the innerClass object is created based on the outer class object (assuming that the inner Class is not static). I hope that this is clear. Now .. the whole point is how does the compiler know that the Outerclass is the enclosing class? When the above line is compiled, the tricky handle in the inner class is assigned to the Outer class. So any reference henceforth is made based on this handle.
    2. In the Inherited Inner class, there is no way to assoicate the handle in the above manner. Hence we are forcing by calling the super().
    3 Otherwise why not simply create with: new InheritedInnerClass(EnclosingClass)? This is not possible. What if the inherited inner class needs a constructor in the above manner. That is assume that there is a class A. Then if the Inner Class needs the constructor to be InnerClass(A a, EnclosingClass b) for some other purpose, then what judgement can the compiler take? So that answers the question <b>Can't the compiler compile the inherited inner class assuming a handle to the enclosing class and then force an instance to be created using the EnclosingClass.new syntax?</b> Becuase in this case it cant go by any assumption.
    4. Maybe the compiler designers can make some change such that the inherited inner class should have all its constructors beginning with the enclosing object and there should be atleast one constructor. But somehow I feel that it is too much of asking.

Maybe you are looking for

  • Web Clipping and a name tags

    Hi! I'm trying to use the webclipping portlet on some static html-pages, and it seems to work just greate, except one thing. The pages uses a lot of anchor-tag that refer to chaper down in the same html-file. You have kind of a chapter-listing in the

  • Cennot login to BI analitics

    I can login to EM and administration Console fine. However, cannot login to Oracle BI (analytic). Get error: Unable to Sign In An error occurred during authentication. Try again later or contact your system administrator. After the initial install of

  • Plug-in for video is missing or needs to be updated?

    Quick time plug 7.6.6 is either missing or needs to be updated. Software update doesnt seem to be working. Anyone have any ideas on this?

  • FIFO buffer control in Windows 7 Home Premium

    Hi all. I'm trying to communicate with a CNC mill through a serial port (RS232). I used to run Windows XP but am now running Windows 7 Home Premium. In XP there was an option in Device Manager on the port(COM) under properties where I could set the F

  • How can I open my itune library from my phone

    How can I open my iTunes library with on my iPhone