One common approach (which is taken in UNIX) is to allow access to all devices in a similar way. Devices may be "opened" and "closed" just like files can. (It also treats them uniformly in other ways.)
A common naming scheme for all these objects is to use a prefix and colon, which specifies the device or filesystem, followed by a directory path if the prefix specifies a filename, e.g., in MS-DOS:
A:\letters\granny.txt -- file on a floppy
LPR: -- printer treated as a file
D:\readme.doc -- file on a CD-ROM drive (or ZIP disk, or 2nd hard drive)
This means that you can tell which device you're using by looking at the prefix. Problem that all names are a bit inconsistant. One part of the name uses a colon separator, the others use a slash (or whatever characters are used). More generally, there are one set of rules for names of devices, and another set of rules for names of files. The filesystems and devices themselves are essentially in a flat 'directory', and it could be awkward choosing distinct names (not that many of these systems let you choose you own names for devices).
UNIX works a bit differently. It has a single filesystem, called the root filesystem, or virtual filesystem (so you don't need to specify a filesystem with a colon-prefix), and other filesystems and all the devices appear in directories in this filesystem. UNIX systems have a single namespace, in which all files and devices may be found.
The mechanism for adding filesystems and devices to the root filesystem is to mount them on the system. This involves telling the system where the device should appear within the root filesystem. For example, when the system boots up, it mounts the terminal (screen and keyboard) to a file called "/dev/tty". It may mount filesystems containing user accounts within the "/home/" directory. (Since all processes in a UNIX machine share the same namespace (the root filesystem), mounting and unmounting of devices and of filesystems is privilidged, and may not be performed by ordinary users.)
The big advantage of this scheme is that devices now look like files, and filesystems now look like directories. It is a simple matter to list all the files in a UNIX system by typing "ls /dev". Similarly, there is a single 'root' directory '/'. Devices may be opened and read or written just like files. Permissions and owners may be assigned to devices, just as they are assigned to files. The rules for dealing with devices become simpler, and programs need not be aware whether what they are writing to is the screen, a file, or "/dev/null".
In UNIX, devices and filesystems have inodes, just like files and directories do. In principle these special inodes are stored in the root filesystem, and have various flags set to identify them as being 'special'.
It is worth mentioning an OS which evolved from UNIX, called Plan 9. Not only does Plan 9 place devices in the same namespace as files, but it allows each process to have its own namespace. A process inherits its namespace from its parent, but thereafter is at liberty to mount and unmount devices and filesystems at will. This lets users and processes arrange their namespaces as they choose, and makes it easier for folk working on remote machines to work in a namespace which resembles their local environment (all the files are in a familiar place).