mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-10-05 00:58:17 +03:00
Update coldfusion.html.markdown
Adds variable declaration, comparison operators, and if/else control structures
This commit is contained in:
wboka
parent
1d43bd50c3
commit
9d33f09170
@ -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.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user