setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JFrame.DISPOSE_ON_CLOSE

// a new JFrame

public class myClass() extends JFrame
{

    // constructor for the class
    public myClass()
    {
        super("Hello World");    // call the super constructor for the JFrame, and set the frame title
        setBounds(0,0,200,200);    // set the window size to 200x200
        setVisible(true);        // after this the window is visible. Without this call, the program will terminate.
            
    }

    // the entry point , this is the first bit of code that is executed.
    
    public static void main( String[] args )
    {
        // create a new myClass object
        new myClass();
    }
    
}

File f1= new File("filename");
boolean itWorked = f1.delete();

File file=new File("filename");
int size=file.length();            // get File Length
byte[] contents=new byte[size];        // allocate buffer
FileInputStream in=new FileInutStream(file); // input stream
in.read(contents);    // Read the data
in.close();        // Close the file

String curDir = System.getProperty("user.dir");

FileInputStream saveFile;
try
{
    fileHandle = new FileInputStream(filename);
    ObjectInputStream data = new ObjectInputStream(fileHandle);
    MyClass myclass = (MyClass) data.readObject();
    return hist;
}

try
{
    FileOutputStream fileHandle;
    fileHandle = new FileOutputStream(<filename>);
    ObjectOutputStream save = new ObjectOutputStream(fileHandle);
    save.writeObject(<myClass>);
    save.close();
}

    
// create a new shader object that we can reference later to activate it.
shader = new ShaderControl();
shader.fsrc = shader.loadShader("f.txt"); // fragment GLSL Code
shader.vsrc = shader.loadShader("v.txt"); // vertex GLSL Code
shader.init(gl);

// The shader control class.
// loads and starts/stops shaders.
Public class ShaderControl
{
    private int vertexShaderProgram;
    private int fragmentShaderProgram;
    private int shaderprogram;
    public String[] vsrc;
    public String[] fsrc;

    // this will attach the shaders
    public void init( GL gl )
    {
        try
        {
            attachShaders(gl);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    // loads the shaders
    // in this example we assume that the shader is a file located in the applications JAR file.
    //
    public String[] loadShader( String name )
    {
        StringBuilder sb = new StringBuilder();
        try
        {
            InputStream is = getClass().getResourceAsStream(name);
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String line;
            while ((line = br.readLine()) != null)
            {
                sb.append(line);
                sb.append('\n');
            }
            is.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        System.out.println("Shader is " + sb.toString());
        return new String[]
        { sb.toString() };
    }

    // This compiles and loads the shader to the video card.
    // if there is a problem with the source the program will exit at this point.
    //
    private void attachShaders( GL gl ) throws Exception
    {
        vertexShaderProgram = gl.glCreateShader(GL.GL_VERTEX_SHADER);
        fragmentShaderProgram = gl.glCreateShader(GL.GL_FRAGMENT_SHADER);
        gl.glShaderSource(vertexShaderProgram, 1, vsrc, null, 0);
        gl.glCompileShader(vertexShaderProgram);
        gl.glShaderSource(fragmentShaderProgram, 1, fsrc, null, 0);
        gl.glCompileShader(fragmentShaderProgram);
        shaderprogram = gl.glCreateProgram();
        //
        gl.glAttachShader(shaderprogram, vertexShaderProgram);
        gl.glAttachShader(shaderprogram, fragmentShaderProgram);
        gl.glLinkProgram(shaderprogram);
        gl.glValidateProgram(shaderprogram);
        IntBuffer intBuffer = IntBuffer.allocate(1);
        gl.glGetProgramiv(shaderprogram, GL.GL_LINK_STATUS, intBuffer);
        
        if (intBuffer.get(0) != 1)
        {
            gl.glGetProgramiv(shaderprogram, GL.GL_INFO_LOG_LENGTH, intBuffer);
            int size = intBuffer.get(0);
            System.err.println("Program link error: ");
            if (size > 0)
            {
                ByteBuffer byteBuffer = ByteBuffer.allocate(size);
                gl.glGetProgramInfoLog(shaderprogram, size, intBuffer, byteBuffer);
                for (byte b : byteBuffer.array())
                {
                    System.err.print((char) b);
                }
            }
            else
            {
                System.out.println("Unknown");
            }
            System.exit(1);
        }
    }
    
    // this function is called when you want to activate the shader.
    // Once activated, it will be applied to anything that you draw from here on
    // until you call the dontUseShader(GL) function.
    public int useShader( GL gl )
    {
        gl.glUseProgram(shaderprogram);
        return shaderprogram;
    }

    // when you have finished drawing everything that you want using the shaders,
    // call this to stop further shader interactions.
    public void dontUseShader( GL gl )
    {
        gl.glUseProgram(0);
    }
}

// Turn on the shader
useShader();
    ... Drawing code here that uses the shader    
// turn off the shader
dontUseShader();

< FILE :: f.txt >
uniform sampler2D fish_y_offset;
uniform float alphavalue;
void main()
{
    gl_FragColor = texture2D(fish_y_offset, gl_TexCoord[0].st);
    gl_FragColor.a=alphavalue;

}

< FILE :: v.txt >
uniform float waveTime;
uniform float waveWidth;
uniform float waveHeight;
void main(void)
{
    vec4 v = vec4(gl_Vertex);
    v.y = 11 + sin(waveWidth * v.x + waveTime) * cos(waveWidth * v.z + waveTime) * waveHeight;
    gl_Position = gl_ModelViewProjectionMatrix * v;
    gl_TexCoord[0] = gl_MultiTexCoord0;
}

int waveWidthLoc = gl.glGetUniformLocation(sp, "waveWidth");
gl.glUniform1f(waveWidthLoc, waveWidth);

Texture text = TextureIO.newTexture(new File(filename), false);

Texture text = TextureIO.newTexture(new File(filename), true);

gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_GENERATE_MIPMAP, GL.GL_TRUE);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_BASE_LEVEL, 0);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 5);

float[] lightPos = { 2000,3000,2000,1 };        // light position
float[] noAmbient = { 0.2f, 0.2f, 0.2f, 1f };     // low ambient light
float[] diffuse = { 1f, 1f, 1f, 1f };        // full diffuse colour

gl.glEnable(GL.GL_LIGHTING);
gl.glEnable(GL.GL_LIGHT0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, noAmbient, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse, 0);
gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION,lightPos, 0);

public void setOrtho()
{
    gl.glLoadIdentity();
    gl.glMatrixMode(GL.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(0, getWidth(), getHeight(), 0, 0, 2000);
    gl.glMatrixMode(GL.GL_MODELVIEW);
    gl.glViewport(0, 0, getWidth(), getHeight());
    gl.glDisable(GL.GL_CULL_FACE); // Disable Culling
    gl.glDisable(GL.GL_DEPTH_TEST); // Disable Depth Testing
    gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
    gl.glDisable(GL.GL_LIGHTING);
    gl.glColor4f(1, 1, 1, 1);
}

gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_BASE_LEVEL, 0);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_LEVEL, 5);
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_GENERATE_MIPMAP, GL.GL_TRUE);
gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST_MIPMAP_NEAREST);

texture = TextureIO.newTexture(ABufferedImage, true);

public static Texture createFromMemory( BufferedImage img )
{
    if (img == null) return null;
    Texture text = TextureIO.newTexture(img, true); // mipmap on
    return text;
}

public void DoFog( GL gl )
{
    FOG_DISTANCE = 90;
    
    float[] fogcol = { 0, 0, 0, 0 };
    
    gl.glEnable(GL.GL_FOG);                // Enable FOG
    gl.glFogi(GL.GL_FOG_MODE, GL.GL_LINEAR);    // Set the FOG Type
    gl.glFogf(GL.GL_FOG_DENSITY, 0f);        // Set Density
    gl.glFogfv(GL.GL_FOG_COLOR, fogcol, 0);        // Set Fog Color
    gl.glFogf(GL.GL_FOG_START, FOG_DISTANCE - 30);    // Start FOG
    gl.glFogf(GL.GL_FOG_END, FOG_DISTANCE);        // End of FOG
    gl.glHint(GL.GL_FOG_HINT, GL.GL_NICEST);    // NICE!
}

    for ( var methods in object )
    {
        var meth = methods;
        var value = object[methods];

    }

<script>

bob = function()
{
    this.a = 1;
    this.b = 2;
    this.meth = function(test)
    {
        var c=a+b;
    }
}


var bb = new bob();

for ( var methods in bb )
{
document.write("name: "+methods+"<br>");
document.write("value: "+bb[methods]+"<br><br>");

}

</script>

name: a
value: 1

name: b
value: 2

name: meth
value: function (test) { var c=a+b; }