Actionscript – Creating Dynamically Flex Custom ItemRender (Constructor)

If you are wanting this as the constructor it needs to have the same name as the file, smileface rather than smilefunction

as you are creating the instance before you are adding it to stage, the call for the stage width in the constructor is going to be null. you should move it onto an added to frame event listener:

package {
    import flash.display.MovieClip;
    import flash.display.Stage;
    public class smileface extends MovieClip {
        public function smileFace() {
        addEventListener(Event.ADDED_TO_STAGE, init);
        }

    public function init(ev:Event){
            this.width = stage.stageWidth/5;
            this.height = stage.stageHeight/5;
            trace("Done!");
        }
    }
}

ActionScript 3 Classes

The package statement.

Okay, so firstly like you mentioned, a class must be wrapped by a package¹. This gives us the first block, where you need to define the class.

package
{
    // Your class here.
}

The package statement reflects the location of the class relative to the .fla². For example, if you have a folder "classes" within the same directory as the project .fla, then classes within that folder will need a package statement that reflects that:

package classes
{
    // Your class here.
}

Defining the class.

Within a package statement, you may insert one class. Do not confuse this with the package itself, which can contain many classes - each class just needs to have its own file with the same package statement.

A class definition is made up of up to 5 parts:

1. The namespace. A class can be internal or public. An internal class can only be seen by classes within the same package, whereas public classes can be seen from anywhere in the project.
2. The class name.
3. A base class (optional). If a base class is defined, then your new class will act as an extension to that class, inheriting all of the qualities of the base class.
4. An interface to implement (optional). Interfaces are an advanced topic thus I suggest you forget about these for now until your AS3 and OOP have evolved.

If you wanted to create a class called "Person" within the package classes, then we would end up with:

package classes
{
    public class Person
    {
        // Class qualities here.
    }
}

Properties.

Classes can contain properties. Properties are defined using the var keyword. They may belong to one of a number of namespaces (including your own) and are used to hold values that belong to your class. Properties are most commonly found clustered together at the top of your class.

Our Person class may enjoy the properties height and weight:

package classes
{
    public class Person
    {
        // Properties.
        public var height:Number = 1.70;
        public var weight:Number = 67.5;
    }
}

These properties can be accessed via any instance of Person that you create. Each instance will have its own set of these properties.

Class constructors (I believe this is what you're asking about).

Constructors are used to hold logic that should be run as soon as an instance of your class is created. The class constructor has the same name as the class itself. It must be public and it does not return anything. Constructors can accept arguments, which are typically used to pass in references to dependencies for that class or required values.

package classes
{
    public class Person
    {
        // Properties.
        public var height:Number = 1.70;
        public var weight:Number = 67.5;

        // Constructor.
        public function Person(height:Number, weight:Number)
        {
            this.height = height;
            this.weight = weight;
        }
    }
}

Methods.

Methods are used to hold logic that can be run when calling that method. Methods often return values and can accept arguments. Methods can belong to any namespace that you would expect properties to be able to belong to.

We may want to be able to easily determine the BMI of each instance of Person that we create, so we should create a method for that:

package classes
{
    public class Person
    {
        // Properties.
        public var height:Number = 170;
        public var weight:Number = 65.5;

        // Constructor.
        public function Person(height:Number, weight:Number)
        {
            this.height = height;
            this.weight = weight;
        }

        // Determine my BMI and return the result.
        public function getBMI():Number
        {
            return weight / (height * height);
        }
    }
}

Instances.

Now that we've defined our new class, we can create instances of this class using the new keyword. This can be done from anywhere that can access the Person class, which in this case is anywhere in the project because we've made the class public.

Though the class is public, accessing it from anywhere outside of the package it belongs in will require the use of an import statement. This statement will need to be used within any class that belongs to a different package. The import statement follows the same name used for the package and includes the name of the class you want to include on the end:

import classes.Person;

Once you've imported Person, you can create instances of it and assign them to a variable with different height and weight values:

var marty:Person = new Person(71, 1.76);
var bruce:Person = new Person(96.4, 1.72);

We can then obtain the BMI for each person using their getBMI() method:

trace(marty.getBMI()); // 22.9
trace(bruce.getBMI()); // 32.6

¹ You can place classes outside of a package which can be referred to in the same .as file.
² You can add more source paths, and packages can be relative to that.