United States Patent [19J
`Wong-Insley
`
`I IIIII IIIIIIII Ill lllll lllll lllll lllll lllll lllll lllll lllll 111111111111111111
`US006131166A
`[11] Patent Number:
`[45] Date of Patent:
`
`6,131,166
`Oct. 10, 2000
`
`[54] SYSTEM AND METHOD FOR CROSS(cid:173)
`PLATFORM APPLICATION LEVEL POWER
`MANAGEMENT
`
`[75]
`
`Inventor: Becky Wong-Insley, Sunnyvale, Calif.
`
`[73] Assignee: Sun Microsystems, Inc., Palo Alto,
`Calif.
`
`[21] Appl. No.: 09/256,826
`
`[22] Filed:
`
`Feb. 24, 1999
`
`Related U.S. Application Data
`
`[63] Continuation of application No. 09/042,211, Mar. 13, 1998.
`
`Int. Cl.7 ........................................................ G06F 1/26
`[51]
`[52] U.S. Cl. .......................... 713/300; 713/320; 713/330;
`709/302
`[58] Field of Search ..................................... 713/300, 320,
`713/330, 201; 709/1, 101, 100, 302; 706/45;
`707 /10; 717 /1, 4; 379/10
`
`[56]
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`5,675,814 10/1997 Pearce ..................................... 713/300
`5,696,952 12/1997 Pontarelli ................................ 713/600
`5,845,140 12/1998 Stanley et al. .......................... 713/322
`9/1999 Nowlin, Jr. . ............................ 713/323
`5,953,536
`5,978,923 11/1999 Kou ......................................... 713/323
`
`OIBER PUBLICATIONS
`
`"Advanced Configuration and Power Interface," ACPI-PC
`Webopaedia Definition and Links, http://webopedia.inter(cid:173)
`net.com/TERM/NNACPI.html, Dec. 22, 1998, pp. 1-2.
`"1.6 ACPI Specification and the Structure of ACPI,"
`ACPI-http://www.teleport.com/-acpi/acpihtml/
`topic7.htm, Dec. 28, 1998, pp. 1-2.
`
`"3.1 System Power Mangement," ACPI-http://www.tele(cid:173)
`port.com/-acpi?acpihtml.topic23.htm, Dec. 28, 1998, pp. 1.
`"OnNow Power Management Architecture for Applica(cid:173)
`tions," Microsoft OnNow Design Initiative White Paper,
`1996-1997 Microsoft Corportation, pp. 1-19.
`Primary Examiner-Ario Etienne
`Attorney, Agent, or Firm-Conley, Rose & Tayan P.C.; B.
`Noel Kivlin
`[57]
`
`ABSTRACT
`
`A framework for the development of applications which
`manage the power resources and power states of power(cid:173)
`manageable computer systems and attached devices. In one
`embodiment, the power management framework comprises
`a plurality of Java™ programming interfaces (APis) which
`are part of the Java™ Platform. Therefore, the same frame(cid:173)
`work is configured to enable the same power-aware Java™
`applications to execute on many different computing
`platforms, operating systems, and computer hardware. The
`programming interfaces comprise a system-level program(cid:173)
`ming interface, a notification programming interface, an
`exception programming interface, and a device-level pro(cid:173)
`gramming interface. The system-level programming inter(cid:173)
`face permits Java™ applications to obtain a current system
`power state and, with the proper privilege, to influence the
`current system power state. The notification programming
`interface permits Java™ applications to be notified regard(cid:173)
`ing transitions from one system power state to another
`system power state. The exception programming interface
`permits Java TM applications to be notified regarding errors in
`power management. The device-level programming inter(cid:173)
`face permits Java™ applications to obtain a current device
`power state and, with the proper privilege, to influence the
`current device power state. The power management frame(cid:173)
`work defines a plurality of standardized system power states,
`standardized device power states, and power state transi(cid:173)
`tions.
`
`42 Claims, 6 Drawing Sheets
`
`Applications
`232
`
`Java Power Management APl(s)
`Java API
`262
`252
`----------------- -------------
`Java Power Management Classes
`Java Classes
`260
`250
`
`Java Virtual Machine
`222
`
`Porting Interface
`220
`
`Adapter
`216a
`
`Browser
`214
`
`OS
`212a
`
`Hardware
`210a
`
`Java on a
`Browser
`
`Adapter
`216b
`
`OS
`212b
`
`Hardware
`210b
`
`Java on a
`Desktop OS
`
`Adapter
`216c
`
`OS
`212c
`
`Hardware
`210c
`
`Java on a
`Smaller OS
`
`Java OS
`218
`
`Hardware
`210d
`
`Java on
`Java OS
`
`Page 1 of 23
`
`GOOGLE EXHIBIT 1017
`
`

`

`U.S. Patent
`
`Oct. 10, 2000
`
`Sheet 1 of 6
`
`6,131,166
`
`-
`
`-
`
`o:
`
`102
`
`[]
`
`100
`
`106
`
`108
`
`FIG. 1 (PRIOR ART)
`
`Page 2 of 23
`
`

`

`Applications
`232
`
`Java Standard Extension API
`230
`Java Base API
`226
`i - - - - - - - - - - - - - - - - - - ----------------
`Java Standard Extension Classes 228
`224
`Java Base Classes
`
`Java Virtual Machine
`222
`
`Porting Interface
`220
`
`Adapter
`216a
`
`Browser
`214
`
`OS
`212a
`
`Hardware
`210a
`
`Java on a
`Browser
`
`Adapter
`216b
`
`OS
`212b
`
`Hardware
`210b
`
`Java on a
`Desktop OS
`
`Adapter
`216c
`
`OS
`212c
`
`Hardware
`210c
`
`Java on a
`Smaller OS
`
`Java OS
`218
`
`Hardware
`210d
`
`Java on
`Java OS
`
`FIG. 2 (PRIOR ART)
`
`d •
`rJJ.
`•
`~
`~ ......
`~ = ......
`
`0
`I")
`!"""
`
`"""" ~=
`N c
`8
`
`'JJ. =(cid:173)~
`~ ......
`N
`0 ......,
`O'I
`
`0--.
`....
`~
`~
`~ ....
`~
`0--.
`0--.
`
`Page 3 of 23
`
`

`

`Applications
`232
`
`Java Power Management APl(s)
`Java API
`262
`252
`~--------------------------------
`Java Classes
`Java Power Management Classes
`250
`260
`
`Java Virtual Machine
`222
`
`Porting Interface
`220
`
`FIG. 3
`
`Adapter
`216a
`
`Browser
`214
`
`OS
`212a
`
`Hardware
`210a
`
`Java on a
`Browser
`
`Adapter
`216b
`
`OS
`212b
`
`Hardware
`210b
`
`Java on a
`Desktop OS
`
`Adapter
`216c
`
`OS
`212c
`
`Hardware
`210c
`
`Java on a
`Smaller OS
`
`Java OS
`218
`
`Hardware
`210d
`
`Java on
`Java OS
`
`d •
`rJJ.
`•
`~
`~ ......
`~ = ......
`
`0
`I")
`!"""
`
`"""" ~=
`N c c c
`
`'JJ. =-~
`~ ......
`~
`0 ......,
`O'I
`
`0--.
`....
`~
`~
`~ ....
`~
`0--.
`0--.
`
`Page 4 of 23
`
`

`

`U.S. Patent
`
`Oct. 10, 2000
`
`Sheet 4 of 6
`
`6,131,166
`
`Relative Power Consumption
`
`Highest
`
`Wattage
`
`Lowest
`
`Full Power> PM Active > Sleep > Suspend > Off
`
`FIG. 4
`
`Relative Wakeup Latency
`
`Longest
`
`Time
`
`Shortest
`
`Off> Suspend > Sleep > PM Active > Full Power
`
`FIG. 5
`
`Page 5 of 23
`
`

`

`U.S. Patent
`
`Oct. 10, 2000
`
`Sheet 5 of 6
`
`6,131,166
`
`System Power State Transitions
`....- - - ---
`
`-
`
`/
`
`-
`
`.........
`
`'
`
`/
`
`/
`
`/
`1
`1
`I
`I
`I
`\
`\
`
`' OS Active
`'\ \States
`\410
`\
`\
`
`:
`I
`I
`I
`
`Full Power
`400
`
`450
`
`PM Active
`402
`
`-
`
`/ - /
`
`-
`
`I
`
`/
`
`/
`
`454
`
`Off
`408
`
`Suspend
`406
`
`458
`
`Sleep
`404
`
`460
`
`FIG. 6
`
`Page 6 of 23
`
`

`

`U.S. Patent
`
`Oct. 10, 2000
`
`Sheet 6 of 6
`
`6,131,166
`
`System Power State
`
`Device Power State
`
`Full Power
`
`DO
`
`PM Active
`
`Transition from DO to 03
`
`Sleep
`
`DO or D 1 or 02 or 03
`
`Suspend
`
`DO or 01 or 02 or 03
`
`Off
`
`03
`
`FIG. 7
`
`Page 7 of 23
`
`

`

`6,131,166
`
`1
`SYSTEM AND METHOD FOR CROSS(cid:173)
`PLATFORM APPLICATION LEVEL POWER
`MANAGEMENT
`
`RELATED APPLICATIONS
`
`This application is a continuation in part of U.S. Ser. No.
`09/042,211 entitled "Java Application Level Power
`Management," filed Mar. 13, 1998, whose inventor was
`Becky Wong-Insley.
`
`BACKGROUND OF THE INVENTION
`
`5
`
`2
`therefore ideal for the Internet, where one program should be
`capable of running on any computer in the world. The
`Java™ Platform is designed to provide this "write once, run
`anywhere" capability.
`Developers use the Java™ Language and Java™ APis to
`write source code for Java™-powered applications.A devel(cid:173)
`oper compiles the source code only once to the Java™
`Platform, rather than to the machine language of an under(cid:173)
`lying system. Java™ programs compile to bytecodes which
`10 are machine instructions for the Java™ Virtual Machine. A
`program written in the Java™ Language compiles to a
`bytecode file which can run wherever the Java™ Platform is
`present, on any underlying operating system and on any
`hardware. In other words, the same exact Java TM application
`can run on any computing platform that is running the
`15 Java™ Platform.
`Although the prior art has provided power management
`schemes, they are system-specific and thus inadequate for a
`cross-platform environment. The Microsoft OnNow power
`management initiative provides application programming
`20 interfaces (APis) and specifies device-class-specific hard(cid:173)
`ware requirements for power management. OnNow will
`allow an OnNow-compliant operating system running on
`OnNow-compliant hardware to determine power and con(cid:173)
`figuration information about each OnNow-compliant device
`25 linked to the system. The OnNow-compliant operating sys(cid:173)
`tem will control the power states for the OnNow-compliant
`devices and share this information with OnNow-compliant
`applications. However, the OnNow initiative is targeted only
`for Microsoft operating system environments such as
`30 Win32, Windows "Memphis," Windows NT version 5 .0, and
`future versions thereof. Therefore, OnNow will not be
`implemented for other operating systems and for hardware
`platforms for which a Microsoft operating system is not
`available. As such, OnNow is a platform-specific solution
`that is not a "write once, run anywhere" method for appli-
`35 cations which are intended to participate in power manage(cid:173)
`ment. Furthermore, OnNow functions are performed at an
`operating system level and not at a higher level such as the
`Java™ Platform.
`The Advanced Configuration and Power Interface (ACPI)
`40 is a power management specification developed by Intel,
`Microsoft, and Toshiba. ACPI is an interface specification,
`not a hardware or software specification, and it does not set
`forth APis to be used by programmers. The ACPI interface
`gives an operating system direct control over the power
`45 management functions of a computer. For example, ACPI
`enables an ACPI-compliant operating system to control the
`amount of power given to ACPI-compliant devices attached
`to an ACPI-compliant computer. The ACPI specification
`comprises three run-time components: the ACPI Tables
`50 which describe the interfaces to the hardware, the ACPI
`Registers, and the ACPI BIOS which refers to the portion of
`the firmware that is ACPI-compliant. Nevertheless, there is
`no guarantee that ACPI will be implemented on computer
`systems built on anything other than Intel or compatible
`CPUs with Microsoft operating systems. As such, ACPI is
`not a "write once, run anywhere" solution for applications
`which are intended to participate in power management.
`Furthermore, ACPI functions are performed at an operating
`system level and not at a higher level such as the Java™
`Platform.
`Therefore, there is a need for a power management
`architecture that is a "write once, run anywhere" solution
`which operates on a plurality of hardware platforms and
`operating systems.
`
`1. Field of the Invention
`The present invention relates generally to computer pro(cid:173)
`gramming languages and more specifically to a method
`implemented in the Java™ programming language on the
`Java™ platform for allowing applications to participate in
`the power management of a computer system.
`2. Description of the Relevant Art
`In recent years, as advances in technology have led to
`smaller and cheaper computing devices, mobile computing
`has become increasingly popular. The portability of mobile
`computing devices is an attractive feature for users who
`cannot be tied down to a traditional, stationary desktop
`computer. Nevertheless, it is the very portability of mobile
`computing devices which leads to one of their biggest
`drawbacks: dependence on a finite power source such as a
`battery. Consequently, hardware and software architectures
`to extend battery life and otherwise manage power resources
`are a critical feature in the design of mobile computing
`devices. Power management is an important issue not only
`for mobile computing devices, but also for computer-based
`devices of all sorts: desktop computers, laptop computers,
`palmtop computers, network computers, personal digital
`assistants, embedded devices, smart phones, and other com(cid:173)
`puting devices which may exist now or which may be
`developed in the future.
`Another recent trend in computing is the trend towards
`cross-platform computing for increased interoperability of
`different types of computer hardware and software. The
`computing world currently has many different operating
`systems and hardware architectures which combine to form
`many disparate platforms. Because of the differences in both
`system software and underlying hardware among different
`platforms, software compiled for one platform usually can(cid:173)
`not function on another platform. Therefore, developers who
`desire to create software for multiple platforms must incur
`the expense of porting software to the additional platforms,
`and consumers must eventually shoulder these costs.
`Furthermore, it is inconvenient and inefficient to maintain
`and deliver multiple system-specific software packages. One
`popular cross-platform solution to these problems is the
`Java™ Platform, a software platform for delivering and
`running the same applications on a plurality of different
`operating systems and hardware platforms. What sets the
`Java™ Platform apart is that it sits on top of these other
`platforms, in a layer of software above the operating system
`and above the hardware.
`The Java™ Platform has two basic parts: the Java™ 60
`Virtual Machine, and the Java™ Application Programming
`Interface (Java™ API). While each underlying platform has
`its own implementation of the Java TM Virtual Machine, there
`is only one Virtual Machine specification. Because of this,
`the Java™ Platform can provide a standard, uniform pro- 65
`gramming interface which allows Java™ applets and appli(cid:173)
`cations to run on any hardware. The Java™ Platform is
`
`55
`
`SUMMARY OF THE INVENTION
`One or more of the problems outlined above may be
`solved by various embodiments of the system and method of
`
`Page 8 of 23
`
`

`

`6,131,166
`
`4
`In one embodiment, the invention comprises a plurality of
`Java™ classes and a plurality of Java™ interfaces. System(cid:173)
`level, notification, and exception objects can be instantiated
`from the classes when a system-specific power manager
`5 application implements the system-level and/or exception
`interfaces, when power-aware Java™ applications utilize
`the system-level and/or exception interfaces, and when
`power-aware Java™ applications implement the notification
`interface. The programming interfaces and Java™ applica-
`10 tions are expressed in an object-oriented programming lan(cid:173)
`guage with corresponding source code and machine lan(cid:173)
`guage. The Java™ Platform translates the machine language
`into a machine language which is native to the underlying
`computing platform.
`The applications and programming interfaces can, of
`course, be stored on any suitable storage medium.
`
`3
`the present invention. The invention provides a framework
`for the development of Java™ applications (including
`applets) to manage the power resources and power states of
`power-manageable computer systems and attached devices.
`The power management framework is part of the Java™
`Platform, and therefore the same framework is operable on
`many different computing platforms without alteration. The
`Java™ Platform includes the Java™ Virtual Machine and
`the Java™ Application Programming Interfaces (APis). The
`Java™ Virtual Machine is a specification of a "soft" com(cid:173)
`puter which can be implemented in software or hardware.
`The Java™ APis are reusable "building blocks" for Java™
`developers which serve as interfaces between Java™ appli(cid:173)
`cations and the Java™ Virtual Machine.
`In one embodiment, the invention comprises one or more 15
`Java™ programming interfaces or APis which permit
`Java™ applications to participate in power management. To
`utilize the APis, a Java TM programmer must make references
`to the APis in the source code for a power-aware Java™
`application. The programming interfaces for power manage- 20
`ment may comprise a system-level programming interface,
`a notification programming interface, an exception program(cid:173)
`ming interface, and a device-level programming interface.
`Although the system-dependent details of the programming
`interfaces may be implemented by a developer for a par- 25
`ticular computing platform, the power-management inter(cid:173)
`faces between the Java TM applications and the Java TM Virtual
`Machine remain standard across all computing platforms on
`which the Java™ Virtual Machine has been implemented,
`and therefore are standard across a plurality of different 30
`operating systems and underlying computer hardware.
`In one embodiment, the system-level programming inter(cid:173)
`face permits Java™ applications to obtain a current system
`power state and, with the proper privilege, to influence the
`current system power state. The power management frame- 35
`work defines a plurality of standardized, system(cid:173)
`independent system power states which may represent the
`current power status of an entire computer system: full
`power, power management active, sleep, suspend, and off. A
`developer may map the system-independent power states to 40
`the system-dependent power states of the underlying com(cid:173)
`puter system. The system-level programming interface
`includes methods for: getting a system power source, getting
`a system battery capacity, getting a system power state,
`adding a system state change event listener, removing a 45
`system state change event listener, setting a system power
`state, and getting a system power monitor object.
`In one embodiment, the notification programming inter(cid:173)
`face permits Java™ applications to be notified regarding
`transitions from one system power state to another system
`power state. The power management framework defines a
`plurality of valid power state transitions for which power(cid:173)
`aware applications may be notified. The notification pro(cid:173)
`gramming interface includes methods for: receiving a sys(cid:173)
`tem state change event, getting a new power state, getting a 55
`previous power state, and determining if a power state
`change can be opposed.
`In one embodiment, the exception programming interface
`permits Java TM applications to be notified regarding errors in
`power management. In one embodiment, the device-level 60
`programming interface permits Java TM applications to obtain
`a current device power state and, with the proper privilege,
`to influence the current device power state. The power
`management framework inherits from the ACPI standard a
`plurality of standardized device power states which may 65
`represent the current power status of a particular attached
`device: DO, Dl, D2, and D3.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`Other objects and advantages of the invention will
`become apparent upon reading the following detailed
`description and upon reference to the accompanying draw(cid:173)
`ings in which:
`FIG. 1 (Prior Art) is an illustration of a computer system
`in one embodiment.
`FIG. 2 (Prior Art) is an illustration of the Java™ Platform
`and the relationships between the elements thereof in one
`embodiment.
`FIG. 3 is an illustration of the Java™ Platform including
`Java™ Power Management in one embodiment of the inven(cid:173)
`tion.
`FIG. 4 is an illustration of the relative power consumption
`of different system power states in one embodiment of the
`invention.
`FIG. 5 is an illustration of the relative wakeup latency of
`different system power states in one embodiment of the
`invention.
`FIG. 6 is an illustration of the system power states and
`system power state transitions in one embodiment of the
`invention.
`FIG. 7 is an illustration of the relationship between system
`power states and device power states in one embodiment of
`the invention.
`While the invention is susceptible to various modifica-
`tions and alternative forms, specific embodiments thereof
`are shown by way of example in the drawings and will
`herein be described in detail. It should be understood,
`however, that the drawing and detailed description thereto
`50 are not intended to limit the invention to the particular form
`disclosed, but on the contrary, the intention is to cover all
`modifications, equivalents and alternatives falling within the
`spirit and scope of the present invention as defined by the
`appended claims.
`
`DETAILED DESCRIPTION OF THE
`PREFERRED EMBODIMENTS
`
`One embodiment of the invention is described below. In
`this embodiment, a set or package of programming inter(cid:173)
`faces is implemented in the Java™ Language to provide one
`or more Java™ applications with the capability to manage
`the power resources and power states of the underlying
`computer system. As used herein, a programming interface
`is an application programmer interface or API: a set of
`routines, protocols, methods, variables, tools, and/or other
`resources for building software applications. Therefore, a
`single API can actually comprise a plurality of APis of lesser
`
`Page 9 of 23
`
`

`

`6,131,166
`
`5
`
`5
`scope. An API permits easier development of software by
`providing building blocks to the programmer.
`FIG. 1 is an illustration of a computer system 100 in one
`embodiment. The computer system 100 comprises computer
`hardware 102, a display device such as a monitor 104, an
`alphanumeric input device such as a keyboard 106, and
`optionally a directional input device such as a mouse 108.
`The computer hardware 102 preferably comprises at least
`one central processing unit (CPU) and associated memory
`medium such as RAM and/or a nonvolatile memory such as
`a hard disk. The computer system 100 executes one or more
`computer programs 110. The computer programs 110 may
`comprise operating system or other system software, appli(cid:173)
`cation software, utility software, Java™ applets, and/or any
`other sequence of instructions which are executed by the
`computer system 100. An operating system performs basic
`tasks such as recognizing input from the keyboard 106,
`sending output to the display screen 104, keeping track of
`files and directories on the disk, and controlling peripheral
`devices such as disk drives and printers. Application soft(cid:173)
`ware runs on top of the operating system. Because applica(cid:173)
`tions take advantage of services offered by operating
`systems, and because operating systems differ in the services
`they offer and in the way they offer the services, an appli(cid:173)
`cation must usually be designed to run on a particular
`operating system. The computer programs 110 are stored in
`a memory medium or storage medium. In various
`embodiments, the computer system 100 may comprise a
`desktop computer, a laptop computer, a palmtop computer,
`a network computer, a personal digital assistant (PDA), an
`embedded device, a smart phone, or any other computing
`device which may exist now or which may be developed in
`the future.
`Together, the computer hardware 102 and the operating
`system define a computing platform. The programming
`interfaces of one embodiment of the present invention are
`cross-platform: they work on different computing platforms
`without alteration. Preferably, the programming interfaces
`are implemented in the Java™ Language for execution on
`the Java™ Platform.
`The Java™ Language is an object-oriented programming
`language. In an object-oriented programming language, data
`and related methods can be grouped together or encapsu(cid:173)
`lated to form an entity known as an object. The object is the
`fundamental building block of object-oriented program(cid:173)
`ming. The data structures within an object may alternately
`be referred to as the object's state, its attributes, its fields, or
`its variables. In the Java™ Language, the data structures are
`normally referred to as the variables of the object. If the
`object represents a telephone, the variables may include a
`telephone number, a color and a type (e.g., touch-tone or
`pulse). The procedures which operate on the variables are
`referred to in Java™ as the methods of the object. In the
`telephone example, the methods could include ringing,
`receiving a call or placing a call. These methods will be
`discussed in more detail below. The variables and methods
`of an object may all be referred to as the members of the
`object.
`In object-oriented programming, the grouping together of
`the variables and methods within an object is referred to as 60
`encapsulation. When the variables relating to an object and
`the methods which might affect the object are encapsulated
`within the object, other entities usually do not have direct
`access to these data and procedures. The other entities
`instead call on the object itself to invoke its own methods 65
`and thereby operate on its own data. The encapsulation of
`the members of the object thereby provides some protection
`
`6
`for the data within the object and prevents unauthorized,
`unwanted, or unintended manipulation of the data. This is
`sometimes referred to as data hiding. (The concept of data
`hiding through encapsulation should be distinguished from
`the hiding of variables in Java™ variable declarations, as
`explained in more detail below.)
`If a user wants to hide the data within an object, the
`variable which contains the data is made private. Private
`variables within an object may only be accessed by the
`10 methods of the object. Because it may, in some cases, be
`inconvenient or impractical to require manipulation of cer(cid:173)
`tain data through the methods of the associated object, some
`variables may be made public. These public variables are
`directly accessible to entities other than the object with
`15 which the variables are associated. Thus, in practice, the
`variables within objects normally comprise some which are
`hidden or inaccessible and some which are public.
`All objects in an object-oriented programming system
`belong to a class, which can be thought of as a category of
`20 like objects which describes the characteristics of those
`objects. Each object is created as an instance of the class by
`a program. The objects may therefore be said to have been
`instantiated from the class. The class sets out variables and
`methods for objects which belong to that class. The defini-
`25 tion of the class does not itself create any objects. The class
`may define initial values for its variables, and it normally
`defines the methods associated with the class (i.e., includes
`the program code which is executed when a method is
`invoked.) The class may thereby provide all of the program
`30 code which will be used by objects in the class, hence
`maximizing re-use of code which is shared by objects in the
`class.
`Classes in the Java™ Language may be hierarchical. That
`is, some classes may be subclasses of a higher class, also
`35 known as a superclass. For example, in addition to the
`telephone class (i.e., superclass) above, subclasses may be
`created for mobile phones and speaker phones. An object
`which is instantiated from the mobile phone class will also
`be an object within the telephone class. It may therefore be
`40 treated as belonging to the narrower class of only mobile
`phones, or it may be treated as belonging to the broader class
`of telephones in general. In the Java™ Language, the
`subclass (e.g., mobile phones) is said to extend the super(cid:173)
`class (e.g., telephones). Alternatively, the superclass is said
`45 to be extended by the subclass. For the purposes of this
`disclosure, a subclass is considered to extend all or any of
`the classes which are above it in the hierarchy. It may also
`be said that the subclass directly extends the class immedi(cid:173)
`ately above it in the hierarchy, and indirectly extends higher
`50 classes in the hierarchy. For example, if a parent class is
`extended by a first subclass and that subclass is in turn
`extended by a second subclass, the second subclass can be
`said to extend the parent class as well as the first subclass.
`This terminology will also be applied to the hierarchical
`55 structure of interfaces, which will be described in more
`detail below.
`This hierarchical definition of classes and subclasses
`based on shared variables and methods is very useful. A
`subclass includes all the variables and methods in the class
`of which it is a member (its parent class). The subclass is
`said to inherit the variables and methods of its parent class.
`This property is useful in defining subclasses because only
`those variables and methods which do not appear in the
`parent class need to be defined in the subclass (although
`variables or methods which appear in the parent class may
`be redefined in the subclass.) This allows the code written in
`the parent classes to be re-used so that the programmer does
`
`Page 10 of 23
`
`

`

`6,131,166
`
`10
`
`7
`not have to rewrite or cut and paste code into each new
`subclass. Methods which are defined in the parent class may,
`however, be redefined in subclasses. This is referred to as
`overriding or hiding the previously defined method(s). By
`redefining a variable which has already been defined in a
`superclass, the programmer may hide the previously defined
`variable (which is distinct from the object-oriented data(cid:173)
`hiding concept inherent in encapsulation.) In some object(cid:173)
`oriented languages, subclasses may inherit variables and
`methods from several classes. This is called multiple inher(cid:173)
`itance. If a subclass can only inherit from one parent class,
`this is called single inheritance. The Java™ Language is
`characterized by single inheritance, not multiple inheritance.
`This hierarchical class structure also allows the program(cid:173)
`mer to take advantage of a property referred to as polymor(cid:173)
`phism. Polymorphism is a mechanism by which various 15
`objects may be handled in the same way externally, even
`though there are differences in the way they are handled
`internally. In other words, the interface which the different
`objects present to an external entity is the same for each
`object, but the details of each object's implementation may 20
`vary. This allows objects instantiated from different sub(cid:173)
`classes to be handled identically even though the subclasses
`are not identical. For example, assume that a drawing
`program implements a class for shapes, a subclass for
`circles, and a subclass for squares, each of which has a 25
`method called draw( ). While draw( ) will be implemented
`differently for the circle subclass and the square subclass, the
`drawing program does not have to know the details of how
`a shape will be drawn, or even which of the shapes is to be
`drawn. The drawing program simply calls the draw( ) 30
`method for the object to be drawn and the implementation
`defined in the object's class will be used.
`Another important element of the Java TM Language is the
`interface. Interfaces are closely related to classes. Interfaces
`may declare what classes do, but not how they do it. For 35
`example, in the case of the telephone class above, an
`interface would declare that a telephone could ring, place
`calls, and receive calls, but it would not define the way in
`which this was accomplished. A telephone class, on the other
`hand, would set out the functions that define each of these 40
`actions so that when a telephone is instantiated, it can
`actually ring, place a call, or receive a call (in the context of
`the application). An interface may declare methods and/or
`constants. To utilize an interface, one or more classes must
`implement the interface.
`The Java™ Platform which utilizes the object-oriented
`Java™ Language is a software platform for delivering and
`running the same applications on a plurality of different
`operating systems and hardware platforms. The Java™
`Platform sits on top of these other platforms, in a layer of 50
`software above the operating system and above the hard(cid:173)
`ware. FIG. 2 is an illustration of the Java™ Platform and the
`relationships between the elements thereof in one embodi(cid:173)
`ment. The Java™ Platform has two basic parts: the Java™
`Virtual Machine 222, and the Java™ Application Program(cid:173)
`ming Interface (Java™ API). While each underlying plat(cid:173)
`form has its own implementation of the Java™ Virtual
`Machine 222, there is only one Virtual Machine specifica(cid:173)
`tion. By allowing the Java™ applications 232 to execute on
`the same Virtual Machine 222 across many different under- 60
`lying computing platforms, the Java™ Platform can provide
`a standard, uniform programming interface which allows
`Java™ applications 232 to run on any hardware The Java™
`Platform is designed to provide this "write once, run any(cid:173)
`where" capability.
`As used herein, "applications" includes applets as well as
`traditional deskt