what is state retention in object orientation that has java visibility?
91626
State retention is a way to keep track of the client's state.  This is more applicable in any application which needs to keep track of the client's activity.  For example, you can think more like a session (HttpSession), which is used to keep track of one's session.
758524
In Java, everything is an object. This way, true encapsulation is achieved. Java is more strongly typed than C++. Java also has stronger enumerated types and the ability to synchronize threads.\n\nWith Java's swing library, it makes it easier to develop GUI applications. A single window can be created by using a few lines of code with Java rather than hundreds for C++...
922186
look into the dimaso variable in the help files, if you change that it I bet it clears up.
737081
If you want to know visit www.java.com\n\nHope ds is d best answer!
932102
You...cannot. Either declare it as a static variable, or create an instance of the object it is in.
150490
Information hiding (a.k.a. encapsulation) is a concept in OO (Object Oriented) programming.  Java is an OO language, so by extension (another OO concept) this is a true statement.  However, it is possible to write (bad) Java classes that do not encapsulate information.
108544
Your object will be passed by reference because\nthat's how Java passes all objects.  Only the\nprimitive types like "int" are passed by value.
465940
Typically it's encrypted data stored in hidden fields in the page returned to the client. If you visit an .aspx page that has viewstate enabled, and view the html source that it sent to you, you will probably see something like this somewhere in it:\n\n<input type="hidden" name="__VIEWSTATE" value="dDwtMTg3NTYwOTI4NTt0PDts" />
792978
all types in java are signed.  that's how it was designed.  i have found it to be a problem only very rarely.
880270
dont know if this could help, i have no idea myself\n   bytesAvailable : uint \n[read-only] The number of bytes of data available for reading from the current position in the byte array to the end of the array. ByteArray \n   constructor : Object \nA reference to the class object or constructor function for a given object instance. Object \n    defaultObjectEncoding : uint \n[static] Denotes the default object encoding for the ByteArray class to use for a new ByteArray instance. ByteArray \n    endian : String \nChanges or reads the byte order for the data; either "bigEndian" or "littleEndian". ByteArray \n    length : uint \nThe length of the ByteArray object, in bytes. ByteArray \n    objectEncoding : uint \nUsed to determine whether the ActionScript 3.0, ActionScript 2.0, or ActionScript 1.0 format should be used when writing to, or reading from, a ByteArray instance. ByteArray \n    position : uint \nMoves, or returns the current position, in bytes, of the file pointer into the ByteArray object. ByteArray \n   prototype : Object \n[static] A reference to the prototype object of a class or function object. Object \n\nPublic Methods\n Hide Inherited Public Methods \n Show Inherited Public Methods \n  Method Defined by \n    ByteArray()\nCreates a ByteArray instance representing a packed array of bytes, so that you can use the methods and properties in this class to optimize your data storage and stream. ByteArray \n    compress():void \nCompresses the byte array using zlib compression. ByteArray \n   hasOwnProperty(name:String):Boolean \nIndicates whether an object has a specified property defined. Object \n   isPrototypeOf(theClass:Object):Boolean \nIndicates whether an instance of the Object class is in the prototype chain of the object specified as the parameter. Object \n   propertyIsEnumerable(name:String):Boolean \nIndicates whether the specified property exists and is enumerable. Object \n    readBoolean():Boolean \nReads a Boolean value from the byte stream. ByteArray \n    readByte():int \nReads a signed byte from the byte stream. ByteArray \n    readBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0):void \nReads the number of data bytes, specified by the length parameter, from the byte stream. ByteArray \n    readDouble():Number \nReads an IEEE 754 double-precision (64-bit) floating-point number from the byte stream. ByteArray \n    readFloat():Number \nReads an IEEE 754 single-precision (32-bit) floating-point number from the byte stream. ByteArray \n    readInt():int \nReads a signed 32-bit integer from the byte stream. ByteArray \n    readMultiByte(length:uint, charSet:String):String \nReads a multibyte string of specified length from the byte stream using the specified character set. ByteArray \n    readObject():* \nReads an object from the byte array, encoded in AMF serialized format. ByteArray \n    readShort():int \nReads a signed 16-bit integer from the byte stream. ByteArray \n    readUnsignedByte():uint \nReads an unsigned byte from the byte stream. ByteArray \n    readUnsignedInt():uint \nReads an unsigned 32-bit integer from the byte stream. ByteArray \n    readUnsignedShort():uint \nReads an unsigned 16-bit integer from the byte stream. ByteArray \n    readUTF():String \nReads a UTF-8 string from the byte stream. ByteArray \n    readUTFBytes(length:uint):String \nReads a sequence of UTF-8 bytes specified by the length parameter from the byte stream and returns a string. ByteArray \n   setPropertyIsEnumerable(name:String, isEnum:Boolean = true):void \nSets the availability of a dynamic property for loop operations. Object \n    toString():String \nConverts the byte array to a string. ByteArray \n    uncompress():void \nDecompresses the byte array. ByteArray \n   valueOf():Object \nReturns the primitive value of the specified object. Object \n    writeBoolean(value:Boolean):void \nWrites a Boolean value. ByteArray \n    writeByte(value:int):void \nWrites a byte to the byte strea
587233
More details pls.\nGo to the source:\nhttp://www.java.com/en
55122
Better way is to creat an instance of Random class.\nIt has methods, nextInteger(), nextdouble(), and others.
1172918
There is something called the "plain view doctrine". If it's in plain view, then it's free for all. You cannot claim the right to privacy if you place the object in such a situation wherein it can be accessed by anyone.
59731
Try the Java reference library.  Here is a link to it online:
92706
There are three ways to interpret your question.\n\nIf you are looking into this timing for the purposes of code optimization, there are many profiling tools for this purpose.  If your JVM includes HotSpot (it probably does), you can use the built in profiler by using the command line argument, "-Xprof" (case sensitive, without quotes).\n\nIf you are trying to determine how long a specific function takes to run, you can use some sort of stopwatch tool.  See Sources for an example.\n\nIf you are trying to determine how long a specific instruction takes to run, you can still use a stopwatch tool, so long as you run the instruction many times in a loop and also run an empty loop (with the same number of iterations) to check the time used for things other than the instruction.  You can (and probably should) also try looking up benchmarking information on the internet.  I leave that as something for you or another answer to do.\n\nBe aware that all three of these issues are very much system dependent.  For best results, do tests on multiple systems and OSs, depending on where your future applications will be deployed.
78985
No it does not.\n\nSometimes it's appropriate to have exactly one instance of a class: window managers, print spoolers, and filesystems are prototypical examples. Typically, those types of objects—known as singletons—are accessed by disparate objects throughout a software system, and therefore require a global point of access. Of course, just when you're certain you will never need more than one instance, it's a good bet you'll change your mind.\n\nThe Singleton design pattern addresses all of the previous paragraph's concerns. With the Singleton design pattern you can:\n\n    * Ensure that only one instance of a class is created\n    * Provide a global point of access to the object\n    * Allow multiple instances in the future without affecting a singleton class's clients\n\nAlthough the Singleton design pattern—as evidenced below by the figure below—is one of the simplest design patterns, it presents a number of pitfalls for the unwary Java developer. This article discusses the Singleton design pattern and addresses those pitfalls. \n\n Example 1. The classic singleton\n\npublic class ClassicSingleton {\n   private static ClassicSingleton instance = null;\n\n   protected ClassicSingleton() {\n      // Exists only to defeat instantiation.\n   }\n   public static ClassicSingleton getInstance() {\n      if(instance == null) {\n         instance = new ClassicSingleton();\n      }\n      return instance;\n   }\n}\n\nThe singleton implemented in Example 1 is easy to understand. The ClassicSingleton class maintains a static reference to the lone singleton instance and returns that reference from the static getInstance() method.\n\nThere are several interesting points concerning the ClassicSingleton class. First, ClassicSingleton employs a technique known as lazy instantiation to create the singleton; as a result, the singleton instance is not created until the getInstance() method is called for the first time. This technique ensures that singleton instances are created only when needed.\n\nSecond, notice that ClassicSingleton implements a protected constructor so clients cannot instantiate ClassicSingleton instances; however, you may be surprised to discover that the following code is perfectly legal:\n\npublic class SingletonInstantiator {\n  public SingletonInstantiator() {\n   ClassicSingleton instance = ClassicSingleton.getInstance();\nClassicSingleton anotherInstance =\nnew ClassicSingleton();\n       ...\n  }\n}\n\nHow can the class in the preceding code fragment—which does not extend ClassicSingleton—create a ClassicSingleton instance if the ClassicSingleton constructor is protected? The answer is that protected constructors can be called by subclasses and by other classes in the same package. Because ClassicSingleton and SingletonInstantiator are in the same package (the default package), SingletonInstantiator() methods can create ClassicSingleton instances. This dilemma has two solutions: You can make the ClassicSingleton constructor private so that only ClassicSingleton() methods call it; however, that means ClassicSingleton cannot be subclassed. Sometimes, that is a desirable solution; if so, it's a good idea to declare your singleton class final, which makes that intention explicit and allows the compiler to apply performance optimizations. The other solution is to put your singleton class in an explicit package, so classes in other packages (including the default package) cannot instantiate singleton instances.\n\nA third interesting point about ClassicSingleton: it's possible to have multiple singleton instances if classes loaded by different classloaders access a singleton. That scenario is not so far-fetched; for example, some servlet containers use distinct classloaders for each servlet, so if two servlets access a singleton, they will each have their own instance.\n\nFourth, if ClassicSingleton implements the java.io.Serializable interface, the class's instances can
897216
go to properties and click on lock items to desktop that should highlight them for you