diff options
Diffstat (limited to 'coldfusion.html.markdown')
| -rw-r--r-- | coldfusion.html.markdown | 395 |
1 files changed, 394 insertions, 1 deletions
diff --git a/coldfusion.html.markdown b/coldfusion.html.markdown index 3c0b0b06..4c734920 100644 --- a/coldfusion.html.markdown +++ b/coldfusion.html.markdown @@ -1 +1,394 @@ -Coming soon +--- +language: ColdFusion +contributors: + - ["Wayne Boka", "http://wboka.github.io"] +filename: LearnColdFusion.cfm +--- + +ColdFusion is a scripting language for web development. +[Read more here.](http://www.adobe.com/products/coldfusion-family.html) + +```ColdFusion +<!--- Comments start with "<!---" and end with "--->" ---> +<!--- + Comments can + also + span + multiple lines +---> + +<!--- CFML tags have a similar format to HTML tags. ---> + +<!--- Variable Declaration: Variables are loosely typed, similar to javascript ---> +<cfset myVariable = "myValue" /> +<cfset myNumber = 3.14 /> + +<!--- Displaying simple data ---> +<!--- Use <cfoutput> for simple values such as strings, numbers, and expressions ---> +<cfoutput>#myVariable#</cfoutput> <!--- myValue ---> +<cfoutput>#myNumber#</cfoutput> <!--- myValue ---> + +<!--- Declaring complex variables ---> +<!--- Declaring an array of 1 dimension: literal or bracket notation ---> +<cfset myArray1 = [] /> +<!--- Declaring an array of 1 dimension: function notation ---> +<cfset myArray2 = ArrayNew(1) /> + +<!--- Outputting complex variables ---> +<cfdump var="#myArray1#" /> <!--- An empty array object ---> +<cfdump var="#myArray1#" /> <!--- An empty array object ---> + +<!--- Operators ---> +<!--- Arithmetic ---> +<cfoutput>#1 + 1#</cfoutput> = 2 +<cfoutput>#10 - 8#</cfoutput> = 2 +<cfoutput>#1 * 2#</cfoutput> = 2 +<cfoutput>#10 / 5#</cfoutput> = 2 +<cfoutput>#12 % 5#</cfoutput> = 0 + +<!--- Comparison ---> +<cfoutput>#1 eq 1#</cfoutput> <!--- TRUE ---> +<cfoutput>#15 neq 1#</cfoutput> <!--- TRUE ---> +<cfoutput>#10 gt 8#</cfoutput> <!--- TRUE ---> +<cfoutput>#1 lt 2#</cfoutput> <!--- TRUE ---> +<cfoutput>#10 gte 5#</cfoutput> <!--- TRUE ---> +<cfoutput>#1 lte 5#</cfoutput> <!--- TRUE ---> + +<!--- Control Structures ---> +<cfset myCondition = "Test" /> +<cfif myCondition eq "Test"> + <cfoutput>#myCondition#</cfoutput> +<cfelseif myCondition eq "Production"> + <cfoutput>#myCondition#. Proceed Carefully!!!</cfoutput> +<cfelse> + myCondition is unknown +</cfif> +``` +<!-- // While loop + int fooWhile = 0; + while(fooWhile < 100) { + System.out.println(fooWhile); + // Increment the counter + // Iterated 100 times, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("fooWhile Value: " + fooWhile); + + // Do While Loop + int fooDoWhile = 0; + do { + System.out.println(fooDoWhile); + // Increment the counter + // Iterated 99 times, fooDoWhile 0->99 + fooDoWhile++; + } while(fooDoWhile < 100); + System.out.println("fooDoWhile Value: " + fooDoWhile); + + // For Loop + int fooFor; + // for loop structure => for(<start_statement>; <conditional>; <step>) + for (fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // Iterated 10 times, fooFor 0->9 + } + System.out.println("fooFor Value: " + fooFor); + + // For Each Loop + // The for loop is also able to iterate over arrays as well as objects + // that implement the Iterable interface. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // for each loop structure => for (<object> : <iterable>) + // reads as: for each element in the iterable + // note: the object type must match the element type of the iterable. + + for (int bar : fooList) { + System.out.println(bar); + //Iterates 9 times and prints 1-9 on new lines + } + + // Switch Case + // A switch works with the byte, short, char, and int data types. + // It also works with enumerated types (discussed in Enum Types), the + // String class, and a few special classes that wrap primitive types: + // Character, Byte, Short, and Integer. + int month = 3; + String monthString; + switch (month) { + case 1: monthString = "January"; + break; + case 2: monthString = "February"; + break; + case 3: monthString = "March"; + break; + default: monthString = "Some other month"; + break; + } + System.out.println("Switch Case Result: " + monthString); + + // Conditional Shorthand + // You can use the '?' operator for quick assignments or logic forks. + // Reads as "If (statement) is true, use <first value>, otherwise, use + // <second value>" + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Prints A, because the statement is true + + + //////////////////////////////////////// + // Converting Data Types And Typecasting + //////////////////////////////////////// + + // Converting data + + // Convert String To Integer + Integer.parseInt("123");//returns an integer version of "123" + + // Convert Integer To String + Integer.toString(123);//returns a string version of 123 + + // For other conversions check out the following classes: + // Double + // Long + // String + + // Typecasting + // You can also cast Java objects, there's a lot of details and deals + // with some more intermediate concepts. Feel free to check it out here: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classes And Functions + /////////////////////////////////////// + + System.out.println("\n->Classes & Functions"); + + // (definition of the Bicycle class follows) + + // Use new to instantiate a class + Bicycle trek = new Bicycle(); + + // Call object methods + trek.speedUp(3); // You should always use setter and getter methods + trek.setCadence(100); + + // toString returns this Object's string representation. + System.out.println("trek info: " + trek.toString()); + + } // End main method +} // End LearnJava class + + +// You can include other, non-public outer-level classes in a .java file + + +// Class Declaration Syntax: +// <public/private/protected> class <class name> { +// // data fields, constructors, functions all inside. +// // functions are called as methods in Java. +// } + +class Bicycle { + + // Bicycle's Fields/Variables + public int cadence; // Public: Can be accessed from anywhere + private int speed; // Private: Only accessible from within the class + protected int gear; // Protected: Accessible from the class and subclasses + String name; // default: Only accessible from within this package + + // Constructors are a way of creating classes + // This is a constructor + public Bicycle() { + gear = 1; + cadence = 50; + speed = 5; + name = "Bontrager"; + } + + // This is a constructor that takes arguments + public Bicycle(int startCadence, int startSpeed, int startGear, + String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // Function Syntax: + // <public/private/protected> <return type> <function name>(<args>) + + // Java classes often implement getters and setters for their fields + + // Method declaration syntax: + // <scope> <return type> <method name>(<args>) + public int getCadence() { + return cadence; + } + + // void methods require no return statement + public void setCadence(int newValue) { + cadence = newValue; + } + + public void setGear(int newValue) { + gear = newValue; + } + + public void speedUp(int increment) { + speed += increment; + } + + public void slowDown(int decrement) { + speed -= decrement; + } + + public void setName(String newName) { + name = newName; + } + + public String getName() { + return name; + } + + //Method to display the attribute values of this Object. + @Override + public String toString() { + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + + " name: " + name; + } +} // end class Bicycle + +// PennyFarthing is a subclass of Bicycle +class PennyFarthing extends Bicycle { + // (Penny Farthings are those bicycles with the big front wheel. + // They have no gears.) + + public PennyFarthing(int startCadence, int startSpeed){ + // Call the parent constructor with super + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // You should mark a method you're overriding with an @annotation. + // To learn more about what annotations are and their purpose check this + // out: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } +} + +// Interfaces +// Interface declaration syntax +// <access-level> interface <interface-name> extends <super-interfaces> { +// // Constants +// // Method declarations +// } + +// Example - Food: +public interface Edible { + public void eat(); // Any class that implements this interface, must + // implement this method. +} + +public interface Digestible { + public void digest(); +} + + +// We can now create a class that implements both of these interfaces. +public class Fruit implements Edible, Digestible { + @Override + public void eat() { + // ... + } + + @Override + public void digest() { + // ... + } +} + +// In Java, you can extend only one class, but you can implement many +// interfaces. For example: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, + InterfaceTwo { + @Override + public void InterfaceOneMethod() { + } + + @Override + public void InterfaceTwoMethod() { + } +} + + +// Abstract Classes +// Abstract Class declaration syntax +// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> { +// // Constants and variables +// // Method declarations +// } + +// Methods can't have bodies in an interface, unless the method is +// static. Also variables are NOT final by default, unlike an interface. +// Also abstract classes CAN have the "main" method. +// Abstract classes solve these problems. + +public abstract class Animal +{ + public abstract void makeSound(); + + // Method can have a body + public void eat() + { + System.out.println("I am an animal and I am Eating."); + // Note: We can access private variable here. + age = 30; + } + + // No need to initialize, however in an interface + // a variable is implicitly final and hence has + // to be initialized. + private int age; + + public void printAge() + { + System.out.println(age); + } + + // Abstract classes can have main function. + public static void main(String[] args) + { + System.out.println("I am abstract"); + } +} + +class Dog extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Bark"); + // age = 30; ==> ERROR! age is private to Animal + } + + // NOTE: You will get an error if you used the + // @Override annotation here, since java doesn't allow + // overriding of static methods. + // What is happening here is called METHOD HIDING. + // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Dog pluto = new Dog(); + pluto.makeSound(); + pluto.eat(); + pluto.printAge(); + } +} +--> + +## Further Reading + +The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. |