Skip to content Skip to navigation Skip to collection information

OpenStax_CNX

You are here: Home » Content » Object-Oriented Programming (OOP) with Java » Ap0130: Self-assessment, Comparing objects, packages, import directives, and some common exceptions

Navigation

Table of Contents

Recently Viewed

This feature requires Javascript to be enabled.
 

Ap0130: Self-assessment, Comparing objects, packages, import directives, and some common exceptions

Module by: R.G. (Dick) Baldwin. E-mail the author

Summary: Part of a self-assessment test designed to help you determine how much you know about comparing objects, packages, import directives, and some common exceptions in Java.

Preface

This module is part of a self-assessment test designed to help you determine how much you know about object-oriented programming using Java.

The test consists of a series of questions with answers and explanations of the answers.

The questions and the answers are connected by hyperlinks to make it easy for you to navigate from the question to the answer and back.

I recommend that you open another copy of this document in a separate browser window and use the links to under Listings to easily find and view the listings while you are reading about them.

Questions

Question 1 .

What output is produced by the program shown in Listing 1 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. Joe Joe false
  • D. Joe Joe true
  • E. None of the above.
1
Listing 1: Listing for Question 1.
public class Ap141{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap141

class Worker{
  void doIt(){
    char[] anArray = {'J','o','e'};
    String Str1 = new String(anArray);
    String Str2 = new String(anArray);

    System.out.println( 
              Str1 + " " + Str2 + " " +
              (Str1 == Str2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 2

What output is produced by the program shown in Listing 2 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. Joe Joe false
  • D. Joe Joe true
  • E. None of the above.
2
Listing 2: Listing for Question 2.
public class Ap142{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap142

class Worker{
  void doIt(){
    char[] anArray = {'J','o','e'};
    String Str1 = new String(anArray);
    String Str2 = new String(anArray);

    System.out.println( 
              Str1 + " " + Str2 + " " +
              Str1.equals(Str2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 3

What output is produced by the program shown in Listing 3 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. ABC DEF GHI
  • D. None of the above.
3
Listing 3: Listing for Question 3.
public class Ap143{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap143

class Worker{
  void doIt(){
    java.util.ArrayList ref = 
            new java.util.ArrayList(1);
    ref.add("ABC ");
    ref.add("DEF ");
    ref.add("GHI");
    
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 4

What output is produced by the program shown in Listing 4 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. ABC DEF GHI
  • D. None of the above.
4
Listing 4: Listing for Question 4.
public class Ap144{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap144

class Worker{
  void doIt(){
    ArrayList ref = 
            new ArrayList(1);
    ref.add("ABC ");
    ref.add("DEF ");
    ref.add("GHI");
    
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 5

What output is produced by the program shown in Listing 5 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. ABC DEF GHI
  • D. None of the above.
5
Listing 5: Listing for Question 5.
import java.util.ArrayList;

public class Ap145{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap145

class Worker{
  void doIt(){
    ArrayList ref = null;
    ref = new ArrayList(1);
    ref.add("ABC ");
    ref.add("DEF ");
    ref.add("GHI");
    
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 6

What output is produced by the program shown in Listing 6 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. ABC DEF GHI
  • D. None of the above.
6
Listing 6: Listing for Question 6.
import java.util.ArrayList;

public class Ap146{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap146

class Worker{
  void doIt(){
    ArrayList ref = null;
    ref.add("ABC ");
    ref.add("DEF ");
    ref.add("GHI");
    
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 7

What output is produced by the program shown in Listing 7 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. ABC DEF GHI
  • D. None of the above.
7
Listing 7: Listing for Question 7.
import java.util.ArrayList;

public class Ap147{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap147

class Worker{
  void doIt(){
    ArrayList ref = null;
    ref = new ArrayList(1);
    ref.add("ABC ");
    ref.add("DEF ");
    
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 8

What output is produced by the program shown in Listing 8 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. Infinity
  • D. None of the above.
8
Listing 8: Listing for Question 8.
public class Ap148{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap148

class Worker{
  void doIt(){
    System.out.println(1.0/0);
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 9

What output is produced by the program shown in Listing 9 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. Infinity
  • D. None of the above.
9
Listing 9: Listing for Question 9.
public class Ap149{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap149

class Worker{
  void doIt(){
    System.out.println(1/0);
  }//end doIt()
}// end class Worker

Answer and Explanation

Question 10

What output is produced by the program shown in Listing 10 ?

  • A. Compiler Error
  • B. Runtime Error
  • C. AB CD EF
  • D. None of the above.
10
Listing 10: Listing for Question 10.
public class Ap150{
  public static void main(
                        String args[]){
    new Worker().doIt();
  }//end main()
}//end class Ap150

class Worker{
  void doIt(){
    String[] ref = {"AB ","CD ","EF "};
    for(int i = 0; i <= 3; i++){
      System.out.print(ref[i]);
    }//end forloop
    System.out.println("");
  }//end doIt()
}// end class Worker

Answer and Explanation

Listings

I recommend that you open another copy of this document in a separate browser window and use the following links to easily find and view the listings while you are reading about them.

Miscellaneous

This section contains a variety of miscellaneous information.

Note:

Housekeeping material
  • Module name: Ap0130: Self-assessment, Comparing objects, packages, import directives, and some common exceptions
  • File: Ap0130.htm
  • Originally published: 2004
  • Published at cnx.org: 12/18/12
  • Revised: 11/17/13

Note:

Disclaimers:

Financial : Although the Connexions site makes it possible for you to download a PDF file for this module at no charge, and also makes it possible for you to purchase a pre-printed version of the PDF file, you should be aware that some of the HTML elements in this module may not translate well into PDF.

I also want you to know that, I receive no financial compensation from the Connexions website even if you purchase the PDF version of the module.

In the past, unknown individuals have copied my modules from cnx.org, converted them to Kindle books, and placed them for sale on Amazon.com showing me as the author. I neither receive compensation for those sales nor do I know who does receive compensation. If you purchase such a book, please be aware that it is a copy of a module that is freely available on cnx.org and that it was made and published without my prior knowledge.

Affiliation : I am a professor of Computer Information Technology at Austin Community College in Austin, TX.

Answers

Answer 10

Both of the following occur.

C. AB CD EF

B. Runtime Error

Explanation 10

Another index out of bounds

This is another example of a program that throws an index out of bounds exception. In this case, since the container is an array object, the name of the exception is ArrayIndexOutOfBoundsException .

Populate a three-element array object

The code in the following fragment creates and populates a three-element array object containing reference to three String objects.

Note:
  void doIt(){
    String[] ref = {"AB ","CD ","EF "};

Access an out-of-bounds element

The next fragment attempts to access elements at indices 0 through 3 inclusive.

Note:
    for(int i = 0; i <= 3; i++){
      System.out.print(ref[i]);
    }//end forloop

Since index value 3 is outside the bounds of the array, the program throws the following exception and aborts:

Note:
AB CD EF 
java.lang.ArrayIndexOutOfBoundsException
 at Worker.doIt(Ap150.java:22)
 at Ap150.main(Ap150.java:14)

Note however that the program displays the contents of the three String objects referred to by the contents of the first three elements in the array before the problem occurs.

That's the way it often is with runtime errors. Often, a program will partially complete its task before getting into trouble and aborting with a runtime error.

Back to Question 10

Answer 9

B. Runtime Error

Explanation 9

A setup

If you feel like you've been had, chances are you have been had. The purpose for Question 8 was to set you up for this question.

Division by zero for integer types

This program deals with the process of dividing by zero for int types. The code in the following fragment divides the int value 1 by the int value 0.

Note:
  void doIt(){
    System.out.println(1/0);
  }//end doIt()

Not the same as double divide by zero

However, unlike with type double , this process doesn't return a very large value and continue running. Rather, for type int , attempting to divide by zero will result in a runtime error of type ArithmeticException that looks something like the following under JDK 1.3:

Note:
java.lang.ArithmeticException: / by zero
 at Worker.doIt(Ap149.java:20)
 at Ap149.main(Ap149.java:14)

An exercise for the student

I won't attempt to explain the difference in behavior for essentially the same problem between type int and type double . As the old saying goes, I'll leave that as an exercise for the student.

Back to Question 9

Answer 8

C. Infinity

Explanation 8

A double divide by zero operation

This program deals with the process of dividing by zero for floating values of type double .

The following code fragment attempts to divide the double value 1.0 by the double value 0.

Note:
  void doIt(){
    System.out.println(1.0/0);
  }//end doIt()

The program runs successfully, producing the output Infinity .

What is Infinity?

Suffice it to say that Infinity is a very large number.

(Any value divided by zero is a very large number.)

At this point, I'm not going to explain it further. If you are interested in learning what you can do with Infinity , see the language specifications.

Back to Question 8

Answer 7

B. Runtime Error

Explanation 7

This program illustrates an IndexOutOfBounds exception.

Instantiate and populate an ArrayList object

By now, you will be familiar with the kind of container object that you get when you instantiate the ArrayList class.

The code in the following fragment instantiates such a container, having an initial capacity of one element.

Then it adds two elements to the container. Each element is a reference to an object of the class String .

Note:
  void doIt(){
    ArrayList ref = null;
    ref = new ArrayList(1);
    ref.add("ABC ");
    ref.add("DEF ");

Increase capacity automatically

Because two elements were successfully added to a container having an initial capacity of only one element, the container was forced to increase its capacity automatically.

Following execution of the code in the above fragment, String object references were stored at index locations 0 and 1 in the ArrayList object.

Get reference at index location 2

The next fragment attempts to use the get method to fetch an element from the container at index value 2.

Index values in an ArrayList object begin with zero. Therefore, since only two elements were added to the container in the earlier fragment, there is no element at index value 2.

Note:
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));

An IndexOutOfBounds exception

As a result, the program throws an IndexOutOfBounds exception. The error produced under JDK 1.3 looks something like the following:

Note:
Exception in thread "main" java.lang.IndexOutOfBoundsException:
Index: 2, Size: 2
at java.util.ArrayList.RangeCheck
  (Unknown Source)
at java.util.ArrayList.get
  (Unknown Source)
at Worker.doIt(Ap147.java:27)
at Ap147.main(Ap147.java:16)

Attempting to access an element with a negative index value would produce the same result.

An ArrayIndexOutOfBounds exception

A similar result occurs if you attempt to access an element in an ordinary array object outside the bounds of the index values determined by the size of the array. However, in that case, the name of the exception is ArrayIndexOutOfBounds .

Back to Question 7

Answer 6

B. Runtime Error

Explanation 6

The infamous NullPointerException

Interestingly, one of the first things that you read when you start reading Java books, is that there are no pointers in Java . It is likely that shortly thereafter when you begin writing, compiling, and executing simple Java programs, one of your programs will abort with an error message looking something like that shown below :

Note:
Exception in thread "main" java.lang.NullPointerException
        at 
Worker.doIt(Ap146.java:23)
        at 
Ap146.main(Ap146.java:16)

What is a NullPointerException?

Stated simply, a NullPointerException occurs when you attempt to perform some operation on an object using a reference that doesn't refer to an object.

That is the case in this program

The following code fragment declares a local reference variable and initializes its value to null .

Note:
  void doIt(){
    ArrayList ref = null;

(A reference variable in Java must either refer to a valid object, or specifically refer to no object (null). Unlike a pointer in C and C++, a Java reference variable cannot refer to something arbitrary.)

In this case, null means that the reference variable doesn't refer to a valid object.

No ArrayList object

Note that the code in the above fragment does not instantiate an object of the class ArrayList and assign that object's reference to the reference variable.

(The reference variable doesn't contain a reference to an object instantiated from the class named ArrayList , or an object instantiated from any class for that matter.)

Call a method on the reference

However, the code in the next fragment attempts to add a String object's reference to a nonexistent ArrayList object by calling the add method on the reference containing null.

Note:
    ref.add("ABC ");

This results in the NullPointerException shown earlier .

What can you do with a null reference?

The only operation that you can perform on a reference variable containing null is to assign an object's reference to the variable. Any other attempted operation will result in a NullPointerException .

Back to Question 6

Answer 5

C. ABC DEF GHI

Explanation 5

The purpose of this program is to

  • Continue to illustrate the use of java packages, and
  • Illustrate the use of the Java import directive.

Program contains an import directive

This program is the same as the program in Question 4 with a major exception. Specifically, the program contains the import directive shown in the following fragment.

Note:
import java.util.ArrayList;

A shortcut

The designers of Java recognized that having to type a fully-qualified name for every reference to a class in a Java program can become burdensome. Therefore, they provided us with a shortcut that can be used, so long as we don't need to refer to two or more class files having the same name.

Import directives

The shortcut is called an import directive.

As can be seen above, the import directive consists of the word import followed by the fully-qualified name of a class file that will be used in the program.

A program may have more than one import directive, with each import directive specifying the location of a different class file.

The import directive(s) must appear before any class or interface definitions in the source code.

The alternative wild-card syntax

An alternative form of the import directive replaces the name of the class with an asterisk.

The asterisk behaves as a wild-card character. It tells the compiler to use any class file that it finds in that package that matches a class reference in the source code.

The wild-card form should be used with care, because it can sometimes cause the compiler to use a class file that is different from the one that you intended to use (if it finds the wrong one first) .

Class file name collisions

If your source code refers to two different class files having the same name, you must forego the use of the import directive and provide fully-qualified names for those class files.

Back to Question 5

Answer 4

A. Compiler Error

Explanation 4

The purpose of this program is to continue to illustrate the use of java packages.

No fully-qualified class names

This program is the same as the program in Question 3 with a major exception. Neither of the references to the ArrayList class use fully-qualified names in this program. Rather, the references are as shown in the following fragment.

Note:
    ArrayList ref = 
            new ArrayList(1);

Compiler errors

As a result, the JDK 1.3 compiler produces two error messages similar to the following:

Note:
Ap144.java:20: cannot resolve symbol
symbol  : class ArrayList
location: class Worker
    ArrayList ref =

Doesn't know how to find the class file

This error message indicates that the compiler didn't know where to look on the disk to find the file named ArrayList.class

Back to Question 4

Answer 3

C. ABC DEF GHI

Explanation 3

Illustrate the use of java packages

Since it was necessary to make use of a class to illustrate packages, this program also previews the use of the ArrayList class. We will be very interested in this class later when we study Java data containers.

What is an ArrayList object?

Some of this terminology may not make much sense to you at this point, but I'll go ahead and tell you anyway, just as a preview.

According to Sun, the ArrayList class provides a

"Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. (This class is roughly equivalent to Vector , except that it is unsynchronized.)"

Stated more simply ...

Stated more simply, an object of the ArrayList class can be used as a replacement for an array object. An ArrayList object knows how to increase its capacity on demand, whereas the capacity of a simple array object cannon change once it is instantiated.

An ArrayList object

The following statement instantiates a new object of the ArrayList class, with an initial capacity for one element. The initial capacity is determined by the int value passed to the constructor when the object is instantiated.

Note:
    java.util.ArrayList ref = 
            new java.util.ArrayList(1);

Back to the primary purpose ...

Getting back to the primary purpose of this program, what is the meaning of the term java.util that appears ahead of the name of the class, ArrayList ?

Avoiding name conflicts

One of the age-old problems in computer programming has to do with the potential for name conflicts. The advent of OOP and reusable code didn't cause that problem to go away. If anything, it made the problem worse.

For example, you and I may work as programmers for separate companies named X and Y. A company named Z may purchase our two companies and attempt to merge the software that we have written separately. Given that there are only a finite number of meaningful class names, there is a good possibility that you and I may have defined different classes with the same names. Furthermore, it may prove useful to use both of the class definitions in a new program.

Put class files in different directories

Sun's solution to the problem is to cause compiled class files to reside in different directories. Simplifying things somewhat, if your compiled file for a class named Joe is placed in a directory named X , and my compiled file for a different class named Joe is placed in a directory named Y , then source code in the same Java program can refer to those two class files as X.Joe and Y.Joe . This scheme makes it possible for the Java compiler and the Java virtual machine to distinguish between the two files having the name Joe.class .

The java and util directories

Again, simplifying things slightly, the code in the above fragment refers to a file named ArrayList.class , which is stored in a directory named util , which is a subdirectory of a directory named java .

The directory named java is the root of a directory tree containing a very large number of standard Java class files.

(As an aside, there is another directory named javax, which forms the root of another directory tree containing class files considered to be extensions to the standard class library.)

Many directories (packages)

Stated simply, a Java package is nothing more or less than a directory containing class files.

The standard and extended Java class libraries are scattered among a fairly large number of directories or packages (a quick count of the packages in the JDK 1.3 documentation indicates that there are approximately 65 standard and extended packages) .

A fully-qualified class name

With one exception, whenever you refer to a class in a Java program, you must provide a fully-qualified name for the class, including the path through the directory tree culminating in the name of the class. Thus, the following is the fully-qualified name for the class whose name is ArrayList .

java.util.ArrayList

(Later we will see another way to accomplish this that requires less typing effort.)

The exception

The one exception to the rule is the use of classes in the java.lang package, (such as Boolean , Class , and Double ) . Your source code can refer to classes in the java.lang package without the requirement to provide a fully-qualified class name.

An ArrayList object

Now back to the use of the object previously instantiated from the class named ArrayList . This is the kind of object that is often referred to as a container.

(A container in this sense is an object that is used to store references to other objects.)

Many methods available

An object of the ArrayList class provides a variety of methods that can be used to store object references and to fetch the references that it contains.

The add method

One of those methods is the method named add .

The following code fragment instantiates three objects of the String class, and stores them in the ArrayList object instantiated earlier.

(Note that since the initial capacity of the ArrayList object was adequate to store only a single reference, the following code causes the object to automatically increase its capacity to at least three.)

Note:
    ref.add("ABC ");
    ref.add("DEF ");
    ref.add("GHI");

The get() method

The references stored in an object of the ArrayList class can be fetched by calling the get method on a reference to the object passing a parameter of type int .

The code in the following fragment calls the get method to fetch the references stored in index locations 0, 1, and 2. These references are passed to the println method, where the contents of the String objects referred to by those references are concatenated and displayed on the computer screen.

Note:
    System.out.println(
                   (String)ref.get(0) + 
                   (String)ref.get(1) + 
                   (String)ref.get(2));

The output

This results in the following being displayed:

ABC DEF GHI

Summary

The above discussion gave you a preview into the use of containers in general, and the ArrayList container in particular.

However, the primary purpose of this program was to help you to understand the use of packages in Java.

The ArrayList class was simply used as an example of a class file that is stored in a standard Java package.

Back to Question 3

Answer 2

D. Joe Joe true

Explanation 2

Two String objects with identical contents

As in Question 1 , the program instantiates two String objects containing identical character strings, as shown in the following code fragment.

Note:
    char[] anArray = {'J','o','e'};
    String Str1 = new String(anArray);
    String Str2 = new String(anArray);

Compare objects for equality

Also, as in Question 1 , this program compares the two objects for equality and displays the result as shown by the call to the equals method in the following fragment.

Note:
    System.out.println( 
              Str1 + " " + Str2 + " " +
              Str1.equals(Str2));

Compare using overridden equals method

The == operator is not used to compare the two objects in this program. Instead, the objects are compared using an overridden version of the equals method. In this case, the equals method returns true, indicating that the objects are of the same type and contain the same data values.

The equals method

The equals method is defined in the Object class, and can be overridden in subclasses of Object . It is the responsibility of the author of the subclass to override the method so as to implement that author's concept of "equal" insofar as objects of the class are concerned.

The overridden equals method

The reason that the equals method returned true in this case was that the author of the String class provided an overridden version of the equals method.

The default equals method

If the author of the class does not override the equals method, and the default version of the equals method inherited from Object is called on an object of the class, then according to Sun:

"for any reference values x and y, this method returns true if and only if x and y refer to the same object (x==y has the value true)"

In other words, the default version of the equals method inherited from the class Object provides the same behavior as the == operator when applied to object references.

Back to Question 2

Answer 1

C. Joe Joe false

Explanation 1

The identity operator

This program illustrates the behavior of the == operator (sometimes referred to as the identity operator) when used to compare references to objects.

Two String objects with identical contents

As shown in the following fragment, this program instantiates two objects of the String class containing identical character strings.

Note:
class Worker{
  void doIt(){
    char[] anArray = {'J','o','e'};
    String Str1 = new String(anArray);
    String Str2 = new String(anArray);

The fact that the two String objects contain identical character strings is confirmed by:

  • Both objects are instantiated using the same array object of type char as input.
  • When the toString representations of the two objects are displayed later, the display of each object produces Joe on the computer screen.

Compare object references using identity (==)

The references to the two String objects are compared using the == operator, and the result of that comparison is displayed. This comparison will produce either true or false. The code to accomplish this comparison is shown in the following fragment.

Note:
    System.out.println( 
              Str1 + " " + Str2 + " " +
              (Str1 == Str2));

The statement in the above fragment produces the following display:

Joe Joe false

How can this be false?

We know that the two objects are of the same type ( String ) and that they contain the same character strings. Why does the == operator return false?

Doesn't compare the objects

The answer lies in the fact that the above statement doesn't really compare the two objects at all. Rather, it compares the values stored in the reference variables referring to the two objects. That is not the same as comparing the objects.

References are not equal

Even though the objects are of the same type and contain the same character string, they are two different objects, located in different parts of memory. Therefore, the contents of the two reference variables containing references to the two objects are not equal.

The correct answer is false

The == operator returns false as it should. The only way that the == operator could return true is if both reference variables refer to the same object, (which is not the case) .

The bottom line is ...

The == operator cannot be used to compare two objects for equality. However, it can be used to determine if two reference variables refer to the same object.

Back to Question 1

-end-

Collection Navigation

Content actions

Download:

Collection as:

EPUB (?)

What is an EPUB file?

EPUB is an electronic book format that can be read on a variety of mobile devices.

Downloading to a reading device

For detailed instructions on how to download this content's EPUB to your specific device, click the "(?)" link.

| More downloads ...

Module as:

PDF | EPUB (?)

What is an EPUB file?

EPUB is an electronic book format that can be read on a variety of mobile devices.

Downloading to a reading device

For detailed instructions on how to download this content's EPUB to your specific device, click the "(?)" link.

| More downloads ...

Add:

Collection to:

My Favorites (?)

'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'.

| A lens I own (?)

Definition of a lens

Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

Who can create a lens?

Any individual member, a community, or a respected organization.

What are tags? tag icon

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

| External bookmarks

Module to:

My Favorites (?)

'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'.

| A lens I own (?)

Definition of a lens

Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

Who can create a lens?

Any individual member, a community, or a respected organization.

What are tags? tag icon

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

| External bookmarks