本文档为JSDoc解析器的测试文件，通过定义多个JavaScript类来演示JSDoc注释的功能，包括类、构造函数、方法、属性等的标注。
/**
* @fileoverview This file is to be used for testing the JSDoc parser
* It is not intended to be an example of good JavaScript OO-programming,
* nor is it intended to fulfill any specific purpose apart from
* demonstrating the functionality of the
* <a href='http://sourceforge.net/projects/jsdoc'>JSDoc</a> parser
*
* @author Gabriel Reid gab_reid@users.sourceforge.net
* @version 0.1
*/
/**
* Construct a new Shape object.
* @class This is the basic Shape class.
* It can be considered an abstract class, even though no such thing
* really existing in JavaScript
* @constructor
* @throws MemoryException if there is no more memory
* @throws GeneralShapeException rarely (if ever)
* @return {Shape|Coordinate} A new shape.
*/
function
Shape(){
/**
* This is an example of a function that is not given as a property
* of a prototype, but instead it is assigned within a constructor.
* For inner functions like this to be picked up by the parser, the
* function that acts as a constructor <b>must</b> be denoted with
* the <b>@constructor</b> tag in its comment.
* @type String
*/
this
.getClassName =
function
(){
return
"Shape"
;
}
/**
* This is an inner method, just used here as an example
* @since version 0.5
* @author Sue Smart
*/
function
addReference(){
// Do nothing...
}
}
/**
* Create a new Hexagon instance.
* @extends Shape
* @class Hexagon is a class that is a <i>logical</i> sublcass of
* {@link Shape} (thanks to the <code>@extends</code> tag), but in
* reality it is completely unrelated to Shape.
* @param {int} sideLength The length of one side for the new Hexagon
* @example
* var h = new Hexagon(2);
* @example
* if (hasHex) {
* hex = new Hexagon(5);
* color = hex.getColor();
* }
*/
function
Hexagon(sideLength) {
}
/**
* This is an unattached (static) function that adds two integers together.
* @param {int} One The first number to add
* @param {int} Two The second number to add
* @author Gabriel Reid
* @deprecated So you shouldn't use it anymore! Use {@link Shape#getClassName} instead.
*/
function
Add(One, Two){
return
One + Two;
}
/**
* The color of this shape
* @type Color
*/
Shape.prototype.color =
null
;
/**
* The border of this shape.
* @field
* @type int
*/
Shape.prototype.border =
function
(){
return
border;};
/*
* These are all the instance method implementations for Shape
*/
/**
* Get the coordinates of this shape. It is assumed that we're always talking
* about shapes in a 2D location here.
* @requires The {@link Shape} class
* @returns A Coordinate object representing the location of this Shape
* @type Coordinate[]
*/
Shape.prototype.getCoords =
function
(){
return
this
.coords;
}
/**
* Get the color of this shape.
* @see #setColor
* @see The <a href="http://example.com">Color</a> library.
* @link Shape
* @type Color
*/
Shape.prototype.getColor =
function
(){
return
this
.color;
}
/**
* Set the coordinates for this Shape
* @param {Coordinate} coordinates The coordinates to set for this Shape
*/
Shape.prototype.setCoords =
function
(coordinates){
this
.coords = coordinates;
}
/**
* Set the color for this Shape
* @param {Color} color The color to set for this Shape
* @param other There is no other param, but it can still be documented if
* optional parameters are used
* @throws NonExistantColorException (no, not really!)
* @see #getColor
*/
Shape.prototype.setColor =
function
(color){
this
.color = color;
}
/**
* Clone this shape
* @returns A copy of this shape
* @type Shape
* @author Gabriel Reid
*/
Shape.prototype.clone =
function
(){
return
new
Shape();
}
/**
* Create a new Rectangle instance.
* @class A basic rectangle class, inherits from Shape.
* This class could be considered a concrete implementation class
* @constructor
* @param {int} width The optional width for this Rectangle
* @param {int} height Thie optional height for this Rectangle
* @author Gabriel Reid
* @see Shape is the base class for this
* @augments Shape
* @hilited
*/
function
Rectangle(width,
// This is the width
height
// This is the height
){
if
(width){
this
.width = width;
if
(height){
this
.height = height;
}
}
}
/* Inherit from Shape */
Rectangle.prototype =
new
Shape();
/**
* Value to represent the width of the Rectangle.
* <br>Text in <b>bold</b> and <i>italic</i> and a
* link to <a href="http://sf.net">SourceForge</a>
* @private
* @type int
*/
Rectangle.prototype.width = 0;
/**
* Value to represent the height of the Rectangle
* @private
* @type int
*/
Rectangle.prototype.height = 0;
/**
* Get the type of this object.
* @type String
*/
Rectangle.prototype.getClassName=
function
(){
return
"Rectangle"
;
}
/**
* Get the value of the width for the Rectangle
* @type int
* @see Rectangle#setWidth
*/
Rectangle.prototype.getWidth =
function
(){
return
this
.width;
}
/**
* Get the value of the height for the Rectangle.
* Another getter is the {@link Shape#getColor} method in the
* {@link Shape} base class.
* @return The height of this Rectangle
* @type int
* @see Rectangle#setHeight
*/
Rectangle.prototype.getHeight =
function
(){
return
this
.height;
}
/**
* Set the width value for this Rectangle.
* @param {int} width The width value to be set
* @see #setWidth
*/
Rectangle.prototype.setWidth =
function
(width){
this
.width = width;
}
/**
* Set the height value for this Rectangle.
* @param {int} height The height value to be set
* @see #getHeight
*/
Rectangle.prototype.setHeight =
function
(height){
this
.height = height;
}
/**
* Get the value for the total area of this Rectangle
* @return total area of this Rectangle
* @type int
*/
Rectangle.prototype.getArea =
function
(){
return
width * height;
}
/**
* Create a new Square instance.
* @class A Square is a subclass of {@link Rectangle}
* @param {int} width The optional width for this Rectangle
* @param {int} height The optional height for this Rectangle
* @augments Rectangle
*/
function
Square(width, height){
if
(width){
this
.width = width;
if
(height){
this
.height = height;
}
}
}
/* Square is a subclass of Rectangle */
Square.prototype =
new
Rectangle();
/**
* Set the width value for this Shape.
* @param {int} width The width value to be set
* @see #getWidth
*/
Square.prototype.setWidth =
function
(width){
this
.width =
this
.height = width;
}
/**
* Set the height value for this Shape
* Sets the {@link Rectangle#height} attribute in the Rectangle.
* @param {int} height The height value to be set
*/
Square.prototype.setHeight =
function
(height){
this
.height =
this
.width = height;
}
/**
* Create a new Circle instance based on a radius.
* @class Circle class is another subclass of Shape
* @extends Shape
* @param {int} radius The optional radius of this {@link Circle }
* @mixin Square.prototype.setWidth as this.setDiameter
*/
function
Circle(radius){
if
(radius) {
/** The radius of the this Circle. */
this
.radius = radius;
}
}
/* Circle inherits from {@link Shape} */
Circle.prototype =
new
Shape();
/**
* The radius value for this Circle
* @private
* @type int
*/
Circle.prototype.radius = 0;
/**
* A very simple class (static) field that is also a constant
* @final
* @type float
*/
Circle.PI = 3.14;
/**
* Get the radius value for this Circle
* @type int
* @see #setRadius
*/
Circle.prototype.getRadius =
function
(){
return
this
.radius;
}
/**
* Set the radius value for this Circle
* @param {int} radius The {@link Circle#radius} value to set
* @see #getRadius
*/
Circle.prototype.setRadius =
function
(radius){
this
.radius = radius;
}
/**
* An example of a class (static) method that acts as a factory for Circle
* objects. Given a radius value, this method creates a new Circle.
* @param {int} radius The radius value to use for the new Circle.
* @type Circle
*/
Circle.createCircle =
function
(radius){
return
new
Circle(radius);
}
/**
* Create a new Coordinate instance based on x and y grid data.
* @class Coordinate is a class that can encapsulate location information.
* @param {int} [x=0] The optional x portion of the Coordinate
* @param {int} [y=0] The optinal y portion of the Coordinate
*/
function
Coordinate(x, y){
if
(x){
this
.x = x;
if
(y){
this
.y = y;
}
}
}
/**
* The x portion of the Coordinate
* @type int
* @see #getX
* @see #setX
*/
Coordinate.prototype.x = 0;
/**
* The y portion of the Coordinate
* @type int
* @see #getY
* @see #setY
*/
Coordinate.prototype.y = 0;
/**
* Gets the x portion of the Coordinate.
* @type int
* @see #setX
*/
Coordinate.prototype.getX =
function
(){
return
this
.x;
}
/**
* Get the y portion of the Coordinate.
* @type int
* @see #setY
*/
Coordinate.prototype.getY =
function
(){
return
this
.y;
}
/**
* Sets the x portion of the Coordinate.
* @param {int} x The x value to set
* @see #getX
*/
Coordinate.prototype.setX =
function
(x){
this
.x = x;
}
/**
* Sets the y portion of the Coordinate.
* @param {int} y The y value to set
* @see #getY
*/
Coordinate.prototype.setY =
function
(y){
this
.y = y;
}
/**
* @class This class exists to demonstrate the assignment of a class prototype
* as an anonymous block.
*/
function
ShapeFactory(){
}
ShapeFactory.prototype = {
/**
* Creates a new {@link Shape} instance.
* @return A new {@link Shape}
* @type Shape
*/
createShape:
function
(){
return
new
Shape();
}
}
/**
* An example of a singleton class
* @param ... Arguments represent {@link coordinate}s in the shape.
* @constructor
*/
MySingletonShapeFactory =
function
(){
/**
* Get the next {@link Shape}
* @type Shape
* @return A new {@link Shape}
*/
this
.getShape =
function
(){
return
null
;
}
}
/**
* Create a new Foo instance.
* @class This is the Foo class. It exists to demonstrate 'nested' classes.
* @constructor
* @see Foo.Bar
*/
function
Foo(){}
/**
* Creates a new instance of Bar.
* @class This class exists to demonstrate 'nested' classes.
* @constructor
* @see Foo.Bar
*/
function
Bar(){}
/**
* Nested class
* @constructor
*/
Foo.Bar =
function
(){
/** The x. */
this
.x = 2;
}
Foo.Bar.prototype =
new
Bar();
/** The y. */
Foo.Bar.prototype.y =
'3'
;
扫一扫
183
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
