āļāļēāļĢāđāļีāļĒāļ JavaScript āļāļ°āļ้āļāļāļĄีāļāļ§āļēāļĄāļĢู้āļāļēāļĢāđāļีāļĒāļ HTML āļāļāļāļ§āļĢ āđāļāļĢāļēāļ° JavaScript āļāļ°āļāļģāļāļēāļāļāļ§āļāļู่āļัāļ HTML āļัāļāļั้āļāļ่āļāļāļāļ°āđāļĢิ่āļĄāļ้āļāđāļĢีāļĒāļ JavaScript āļāļ§āļĢāļāļ°āļāļģāļāļ§āļēāļĄāđāļ้āļēāđāļāļัāļ HTML āļ่āļāļ
āļāļēāļĢāđāļีāļĒāļ JavaScript āļāļ°āđāļีāļĒāļāļ āļēāļĒāđāļ script tag āđāļāļĒāļāļ°āđāļีāļĒāļāļัāļāđāļ§้āđāļ HTML āđāļĨāļĒāļŦāļĢืāļāļāļģāđāļ้āļēāļāļēāļāđāļāļĨ์ .js āļ āļēāļĒāļāļāļāļ็āđāļ้ āļัāļ§āļāļĒ่āļēāļāļāļēāļĢāđāļีāļĒāļāļัāļāđāļ HTML
āļŠัāļāđāļāļāļี่ āļāļĢāļĢāļัāļ 6-8
āļāļĨāļĨัāļāļāļāļāļัāļ§āļāļĒ่āļēāļāļ้āļēāļāļāļ
āļัāļ§āļāļĒ่āļēāļāļāļēāļĢāđāļีāļĒāļāđāļāļĒāļāļģāđāļ้āļēāļāļēāļāđāļāļĨ์āļ āļēāļĒāļāļāļ
Script Example
<-- Example of inefficient script positioning -->
Hello world!
āļŠัāļāđāļāļāļี่ āļāļĢāļĢāļัāļ 5-6
āļŠัāļāđāļāļ script tag āļāļ°āļĄี type="text/javascript" āļึ่āļāđāļŠ่āļ็āđāļ้āđāļĄ่āđāļŠ่āļ็āđāļ้ āđāļāļĢāļēāļ°āļŠāļģāļŦāļĢัāļ HTML5 script tag āļāļ°āļูāļ Default āđāļ็āļ JavaScript āļāļĒู่āđāļĨ้āļ§
āļāļģāđāļāļ°āļāļģ
āļāļēāļ Script āļัāļ§āļāļĒ่āļēāļāļี่āļ่āļēāļāļĄāļē āļāļ°āđāļีāļĒāļ JavaScript āđāļ§้āđāļ head tag āļāļāļ HTML āļึ่āļāļāļēāļĢāļāļģāļāļēāļāļāļāļāđāļ§็āļāđāļāļ์āđāļĄื่āļāđāļāļ script tag āļŦāļēāļāļĄี src attribute āđāļāļĢāđāļāļĄāļāļ°āļŦāļĒุāļāļĢāļ āđāļĨ้āļ§āđāļŦāļĨāļāđāļāļĨ์āļāļēāļāļ āļēāļĒāļāļāļāđāļĨāļ°āļāļĢāļ°āļĄāļ§āļĨāļāļĨāļัāļāļีāđāļĨ้āļ§āļึāļāļāļ°āļāļģāļāļēāļāļ่āļāđāļ āļึāļāđāļĄ้āļ§่āļēāđāļāļĢāđāļāļĢāļĄāļāļ°āļāļģāļāļēāļāđāļ้āļāļĒ่āļēāļāļāļāļิ āđāļ่āļāļēāļĢāđāļีāļĒāļāļ§ิāļีāļี้āļāļ°āļāļģāđāļŦ้āđāļิāļāļัāļāļŦāļēāļāļēāļāļ้āļēāļāļāļ§āļēāļĄāđāļĢ็āļ§āļāļāļ website āđāļāļĢāļēāļ°āļ้āļāļāđāļŠีāļĒāđāļ§āļĨāļēāļŦāļĒุāļāļĢāļāđāļŦāļĨāļāđāļĨāļ°āļāļĢāļ°āļĄāļ§āļĨāļāļĨāđāļāļĨ์ JavaScript āđāļŠāļĢ็āļāļ่āļāļāļāļģāđāļŦ้āļŦāļ้āļēāđāļ§็āļāđāļ็āļāļŦāļ้āļēāļāļēāļ§āđ
āļัāļāļั้āļ āļŦāļēāļāđāļĄ่āļāļģāđāļ็āļāļ้āļāļāđāļŦ้ JavaScript āļāļĢāļ°āļĄāļ§āļĨāļāļĨāļ่āļāļ āļāļ§āļĢāđāļāļĢāļ script tag āđāļ§้āļ้āļēāļāļĨ่āļēāļāļŠุāļāļāļāļ body tag āļัāļāļัāļ§āļāļĒ่āļēāļāļ้āļēāļāļĨ่āļēāļāļāļĢāļĢāļัāļ 9-11 āđāļื่āļāđāļŦ้āđāļื้āļāļŦāļēāļāļāļāđāļ§็āļāđāļāļ์āđāļŦāļĨāļāđāļŠāļĢ็āļāļ่āļāļāđāļĨ้āļ§āđāļŦāļĨāļāđāļĨāļ°āļāļĢāļ°āļĄāļ§āļĨāļāļĨāđāļāļĨ์ JavaScript āļāļģāđāļŦ้āļāļĒ่āļēāļāļ้āļāļĒāļู้āđāļ้āđāļ้āđāļŦ็āļāļŦāļ้āļēāđāļ§็āļāđāļิāļāļāļēāļĢāđāļŦāļĨāļāđāļĄ่āđāļ่āļŦāļ้āļēāļāļēāļ§āđ āđāļāļĨ่āļēāđ
Script Example
Hello world!
<-- Example of recommended script positioning -->
āđāļ่āļēāļี้āđāļāļāļ็āđāļ้āļĢู้āļāļģāđāļŦāļ่āļāļāļāļāļāļēāļĢāđāļีāļĒāļ JavaScript āđāļĨ้āļ§āļāļāļัāļāđāļŦāļĄ่āđāļāļāļāļāļ§āļēāļĄāļัāļāđāļāđāļ้āļāļ ..
C# Operators, Types, and Variables
āļ§ัāļāļุāļāļĢāļ°āļŠāļāļ์āļāļāļāļāļāļāļ§āļēāļĄāļี้āļāļ°āļāļĢัāļ
āđāļ้āļēāđāļāļ§่āļēāļัāļ§āđāļāļĢāļืāļāļāļ°āđāļĢ
āļāļิāļāļāļāļāļัāļ§āđāļāļĢāļืāļāļāļ°āđāļĢ
āļัāļ§āļāļģāđāļิāļāļāļēāļĢāļืāļāļāļ°āđāļĢ
āļัāļ§āđāļāļĢāđāļĨāļ°āļāļิāļāļāļāļāļ้āļāļĄูāļĨ Variables and Types
āļัāļ§āđāļāļĢ āđāļ็āļāļ āļēāļāļāļ°āđāļ็āļāļ้āļāļĄูāļĨ āļุāļāļŠāļēāļĄāļēāļĢāļāđāļŠ่āļ้āļāļĄูāļĨāļĨāļāđāļāđāļāļัāļ§āđāļāļĢāđāļĨāļ°āļŠāļēāļĄāļēāļĢāļāđāļĢีāļĒāļāđāļ้āļ้āļāļĄูāļĨāļั้āļāļ่āļēāļāļัāļ§āđāļāļĢāđāļĄื่āļāļ้āļāļāļāļēāļĢ āļāļ§āļēāļĄāļŦāļĄāļēāļĒāļāļāļāļ้āļāļĄูāļĨāđāļāļัāļ§āđāļāļĢāļั้āļāļāļ°āļูāļāļĢāļ°āļุāđāļ้āļāļēāļ āļāļิāļāļ้āļāļĄูāļĨāļāļāļāļัāļ§āđāļāļĢ
1. āļ้āļāļĄูāļĨāļāļิāļāļāļĢāļĢāļāļ° The Boolean Type
āļāļēāļĢāļāļĢāļ°āļāļēāļĻāļัāļ§āđāļāļĢ boolean āļāļ°āđāļ้āļāļģāļ§่āļē bool āļึ่āļāļāļ°āđāļ็āļāļ่āļēāđāļีāļĒāļ 2 āļ่āļēāđāļ่āļēāļั้āļāļืāļ true , false āđāļāļ āļēāļĐāļēāļื่āļ āđāļ่āļ āļ āļēāļĐāļē C, C++ āļŠāļēāļĄāļēāļĢāļāđāļ้āđāļĨāļ 0 āđāļāļ false āđāļĨāļ°āđāļĨāļ 1 āđāļāļ true āđāļ้ āđāļāļ āļēāļĐāļē C# āļāļ°āđāļĄ่āđāļ้ āđāļāļัāļ§āļāļĒ่āļēāļāļี่ 1 āđāļ็āļāļāļēāļĢāļĒāļāļัāļ§āļāļĒ่āļēāļāļāļēāļĢāđāļ้āđāļีāļĒāļāđāļāļĢāđāļāļĢāļĄ
āļัāļ§āļāļĒ่āļēāļāļี่ 1 āđāļŠāļāļāļ่āļēāđāļ Boolean
using System ;
class Booleans
{
public static void Main ()
{
bool content = true ;
bool noContent = false ;
Console.WriteLine("It is {0} that C# Station provides C# programming language content." , content);
Console.WriteLine("The statement above is not {0}." , noContent);
}
}
āļāļĨāļĨัāļāļ์
It is True that C# Station provides C# programming language content.
The statement above is not False.
2. āļāļิāļāļ้āļāļĄูāļĨāļัāļ§āđāļĨāļ Integral Types
āđāļāļ āļēāļĐāļē C# Integral Types āđāļ็āļāļŦāļĄāļ§āļāļāļāļāļāļิāļāļ้āļāļĄูāļĨāļี่āđāļ็āļāļัāļ§āđāļĨāļāļāļģāļāļ§āļāđāļ็āļĄ āļั้āļ signed, unsigned, āđāļĨāļ°āļ้āļāļĄูāļĨāļัāļ§āļัāļāļĐāļĢ (char) āļึ่āļ char āđāļ็āļ Unicode character āļŦāļēāļ่āļēāļāđāļ้่āļี่ http://www.unicode.org/
Type Size (in bits) Range
sbyte 8 -128 to 127
byte 8 0 to 255
short 16 -32768 to 32767
ushort 16 0 to 65535
int 32 -2147483648 to 2147483647
uint 32 0 to 4294967295
long 64 -9223372036854775808 to 9223372036854775807
ulong 64 0 to 18446744073709551615
char 16 0 to 65535
āļāļิāļāļ้āļāļĄูāļĨāļัāļ§āđāļĨāļāļุāļāļี้āļŠāļēāļĄāļēāļĢāļāļāļģāļĄāļēāļāļģāļāļ§āļāļāļēāļāļāļิāļāļĻāļēāļŠāļāļĢ์ āļĒāļāđāļ§้āļ Char āļุāļāļŠāļēāļĄāļēāļĢāļāđāļĨืāļāļāđāļ้āļāļิāļāļ้āļāļĄูāļĨāļāļēāļāļāļēāļĢāļēāļāļ้āļēāļāļāļāļี้āļāļēāļĄāļāļ§āļēāļĄāđāļŦāļĄāļēāļ°āļŠāļĄāđāļāļĒāļิāļēāļĢāļāļēāļāļēāļāļ่āļē Range āđāļŦ้āđāļŦāļĄāļēāļ°āļŠāļĄāļัāļāđāļāļĢāđāļāļĢāļĄāļāļāļāļุāļ
āļัāļ§āļāļĒ่āļēāļāļี่ 2 āđāļāļĢāđāļāļĢāļĄāļāļ° number1 āđāļĨāļ° number2 āļĄāļēāļāļ§āļāļัāļ
using System ;
namespace ConsoleApplication1
{
class Program
{
static void Main (string [] args)
{
int number1, number2;
Console.WriteLine("Please enter a number:" );
number1 = int .Parse(Console.ReadLine());
Console.WriteLine("Thank you. One more:" );
number2 = int .Parse(Console.ReadLine());
Console.WriteLine("Adding the two numbers: " + (number1 + number2));
Console.ReadLine();
}
}
}
3.āļāļิāļāļ้āļāļĄูāļĨāđāļĨāļāļāļĻāļิāļĒāļĄ Floating Point and Decimal Types
āļāļิāļāļ้āļāļĄูāļĨāļāļĻāļิāļĒāļĄāļั้āļ float āđāļĨāļ° double āļāļ°āļูāļāđāļ้āđāļāļāļāļģāļāļ§āļāļāļĢิāļ āļŠ่āļ§āļ decimal āļŠ่āļ§āļāļĄāļēāļāđāļ้āđāļāļāļēāļ financial āļŦāļĢืāļ money values.
Type Size (in bits) precision Range
float 32 7 digits 1.5 x 10-45 to 3.4 x 1038
double 64 15-16 digits 5.0 x 10-324 to 1.7 x 10308
decimal 128 28-29 decimal places 1.0 x 10-28 to 7.9 x 1028
āļāļēāļĢāđāļ้āļāļิāļāļ้āļāļĄูāļĨāļāļĻāļิāļĒāļĄ ( Floating Point ) āđāļĢāļēāļĄัāļāđāļ้āđāļĄื่āļāļĄีāļāļēāļĢāļŦāļēāļĢāļŦāļĢืāļāļāļģāļāļ§āļāđāļĻāļĐāļŠ่āļ§āļāļี่āļ่āļēāđāļĄ่āļĨāļāļัāļ§ āļŠ่āļ§āļāļāļēāļĢāļāļģāļāļ§āļāļāļēāļāļāļēāļĢāđāļิāļ decimal āđāļ็āļāļāļēāļāđāļĨืāļāļāļี่āļีāļี่āļŠุāļ āđāļāļĢāļēāļ°āļ§่āļēāđāļĢāļēāļŠāļēāļĄāļēāļĢāļāļŦāļĨีāļāđāļĨี่āļĒāļāļัāļāļŦāļē rounding errors āđāļ้
4. āļ้āļāļāļ§āļēāļĄ The string Type
String āđāļ็āļāļāļĨุ่āļĄāļāļāļ
Char āļี่āđāļĢีāļĒāļāļ่āļāļัāļāđāļ็āļāļ้āļāļāļ§āļēāļĄ āļัāļ§āļัāļāļĐāļĢāļāļēāļāļัāļ§āļิāļĄāļ์āļāļāļāļŦāļ้āļēāļāļāđāļĄ่āđāļ้ āđāļ่āđāļĢāļēāļĒัāļāļ้āļāļāļāļēāļĢāđāļ้āļĄัāļ āđāļāļĢāļēāļ°āļāļ°āļั้āļāđāļāļ āļēāļĐāļē C# āļึāļāļĄีāļāļĢāļีāļิāđāļĻāļĐāđāļĄื่āļāļ้āļāļāļāļēāļĢāđāļ้āļัāļāļĐāļĢāđāļŦāļĨ่่āļēāļั้āļāđāļāļĒāļāļēāļĢāđāļ้āđāļāļĢื่āļāļāļŦāļĄāļēāļĒ '\'
Escape Sequence Meaning
\' Single Quote
\" Double Quote
\\ Backslash
\0 Null, not the same as the C# null value
\a Bell
\b Backspace
\f form Feed
\n Newline
\r Carriage Return
\t Horizontal Tab
\v Vertical Tab
āļัāļ§āļāļĒ่āļēāļāļี่ 3 āļāļēāļĢāļāļĢāļ°āļāļēāļĻāļัāļ§āđāļāļĢ string āđāļĨāļ°āļāļēāļĢāđāļ้āļāļēāļāđāļื้āļāļāļ้āļ
āđāļāļĢāđāļāļĢāļĄāļāļ°āđāļŠāļāļāļื่āļāđāļĨāļ°āļāļēāļĄāļŠāļุāļĨāļāļēāļĄāļี่āļāļĢāļ°āđāļ§้āđāļāļัāļ§āđāļāļĢāļื่āļ firstName āđāļĨāļ° lastName āļāļēāļāļั้āļāđāļāļĢāđāļāļĢāļĄāļāļ°āļĢัāļāļื่āļāđāļĨāļ°āļāļēāļĄāļŠāļุāļĨāđāļŦāļĄ่āļีāļāļāļĢั้āļāđāļĨāļ°āđāļŠāļāļāļื่āļāļāļēāļĄāļŠāļุāļĨāđāļŦāļĄ่
using System ;
namespace ConsoleApplication1
{
class Program
{
static void Main (string [] args)
{
string firstName = "John" ;
string lastName = "Doe" ;
Console.WriteLine("Name: " + firstName + " " + lastName);
Console.WriteLine("Please enter a new first name:" );
firstName = Console.ReadLine();
Console.WriteLine("New name: " + firstName + " " + lastName);
Console.ReadLine();
}
}
}
5. āļัāļ§āļāļģāđāļิāļāļāļēāļĢ C# Operators
āđāļāļĢื่āļāļāļŦāļĄāļēāļĒāđāļāļāļēāļĢāļāļģāļāļ§āļāļāļēāļāļāļิāļāļĻāļēāļŠāļāļĢ์āļ่āļēāļāđ āļั้āļāļāļ§āļ āļĨāļ āļูāļ āļŦāļēāļĢ āļāļĢāļĢāļāļ° āļึ่āļāļāļ°āļ้āļāļāđāļ้āļĢ่āļ§āļĄāļัāļāļัāļ§āđāļāļĢāđāļื่āļāļŦāļēāļāļĨāļĨัāļāļ์āļāļāļāļŠāļĄāļāļēāļĢāļึ่āļāđāļŠāļāļāļāļēāļĄāļāļēāļĢāļēāļāļ้āļēāļāļĨ่āļēāļāļี้āđāļĨ้āļ§
Category (by precedence) Operator(s) Associativity
Primary x.y f(x) a[x] x++ x-- new typeof default checked unchecked delegate left
Unary + - ! ~ ++x --x (T)x right
Multiplicative * / % left
Additive + - left
Shift << >> left
Relational < > <= >= is as left
Equality == != right
Logical AND & left
Logical XOR ^ left
Logical OR | left
Conditional AND && left
Conditional OR || left
Null Coalescing ?? left
Ternary ?: right
Assignment = *= /= %= += -= <<= >>= &= ^= |= => right
āļัāļ§āļāļĒ่āļēāļ āđāļāļĢāđāļāļĢāļĄāļāļēāļĢāđāļ้ operators āļ่āļēāļāđ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using System ;
class Unary
{
public static void Main ()
{
int unary = 0 ;
int preIncrement;
int preDecrement;
int postIncrement;
int postDecrement;
int positive;
int negative;
sbyte bitNot;
bool logNot;
preIncrement = ++unary;
Console.WriteLine("pre-Increment: {0}" , preIncrement);
preDecrement = --unary;
Console.WriteLine("pre-Decrement: {0}" , preDecrement);
postDecrement = unary--;
Console.WriteLine("Post-Decrement: {0}" , postDecrement);
postIncrement = unary++;
Console.WriteLine("Post-Increment: {0}" , postIncrement);
Console.WriteLine("Final Value of Unary: {0}" , unary);
positive = -postIncrement;
Console.WriteLine("Positive: {0}" , positive);
negative = +postIncrement;
Console.WriteLine("Negative: {0}" , negative);
bitNot = 0 ;
bitNot = (sbyte )(~bitNot);
Console.WriteLine("Bitwise Not: {0}" , bitNot);
logNot = false ;
logNot = !logNot;
Console.WriteLine("Logical Not: {0}" , logNot);
}
}
āļāļิāļāļēāļĒāđāļāļĢāđāļāļĢāļĄ
17 preIncrement = ++unary;
++unary āļŦāļĄāļēāļĒāļึāļ āđāļิ่āļĄāļ่āļēāđāļāļัāļ§ unary āļึ้āļ 1 āļ่āļāļ āđāļĨ้āļ§āļึāļāļāļ°āļŠ่āļāļ่āļēāđāļāđāļŦ้ preIncrement āļัāļāļั้āļ preIncrement = 1
20 preDecrement = --unary;
--unary āđāļŦāļĄืāļāļāļāļĢāļĢāļัāļāļี่ 17 āđāļ่āđāļ็āļāļāļēāļĢāļĨāļāļ่āļēāļĨāļ āļัāļāļั้āļ preDecrement āļึ่āļāđāļ่āļēāļัāļ 0
23 postDecrement = unary--;
unary-- āļืāļ āļŠ่āļāļ่āļēāđāļāļĒัāļ preIncrement āļ่āļāļ āđāļĨ้āļ§āļึāļāļĨāļāļ่āļēāļĨāļ 1 āļีāļŦāļĨัāļ āļัāļāļั้āļ preIncrement = 0
26 postIncrement = unary++;
unary++ āđāļŦāļĄืāļāļāļัāļāļāļĢāļĢāļัāļāļี่ 23 āđāļ่āđāļ็āļāļāļēāļĢāđāļิ่āļĄāļ่āļēāļึ้āļ 1
31 positive = -postIncrement;
32 Console.WriteLine("Positive: {0}" , positive);
33
34 negative = +postIncrement;
35 Console.WriteLine("Negative: {0}" , negative);
āļŠ่āļ§āļāļี้āđāļ็āļāđāļŦāļĄืāļāļāļัāļāļāļģāļāļ§āļāļāļēāļāļāļิāļāļĻāļēāļŠāļāļĢ์āļั้āļāļืāļ āļ่āļēāļĨāļ * āļĨāļ = āļ่āļēāļāļ§āļ, āļ่āļēāļāļ§āļ*āļĨāļ=āļĨāļ
āļึ่āļāđāļāļāļĢāļĢāļัāļ 31 postIncrement = -1 ; -(-1) = 1
āđāļĨāļ°āļāļĢāļĢāļัāļ 34 postIncrement = -1 ; +(-1) = -1
37 bitNot = 0 ;
38 bitNot = (sbyte )(~bitNot);
39 Console.WriteLine("Bitwise Not: {0}" , bitNot);
āļāļĢāļĢāļัāļāļี่ 38 (~bitNot ) āļืāļāļāļēāļĢāļāļĨัāļāļิāļ āļāļēāļ "00000000" = 0 āđāļ็āļ "111111111" = -1
41 logNot = false ;
42 logNot = !logNot;
43 Console.WriteLine("Logical Not: {0}" , logNot);
āļāļĢāļĢāļัāļāļี่ 42 !logNot āļืāļāļāļēāļĢ NOT āļāļēāļāļāļĢāļĢāļāļ°āļĻāļēāļŠāļāļĢ์ āļืāļāļāļēāļĢāđāļāļĨี่āļĒāļāđāļ็āļāļāļĢāļāļ้āļēāļĄāļืāļ false -> true
āļāļĨāļĨัāļāļ์āļี่āđāļ้
pre-Increment: 1
pre-Decrement 0
Post-Decrement: 0
Post-Increment: -1
Final Value of Unary: 0
Positive: 1
Negative: -1
Bitwise Not: -1
Logical Not: true
āļัāļ§āļāļĒ่āļēāļāļŠุāļāļ้āļēāļĒ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using System ;
class Binary
{
public static void Main ()
{
int x, y, result;
float floatresult;
x = 7 ;
y = 5 ;
result = x+y; // 7 + 5 = 12
Console.WriteLine("x+y: {0}" , result);
result = x-y; // 7 - 5 = 2
Console.WriteLine("x-y: {0}" , result);
result = x*y; // 7 * 5 = 35
Console.WriteLine("x*y: {0}" , result);
result = x/y; // 7 / 5 = 1 āđāļāļĢāļēāļ°āđāļ็āļāļāļģāļāļ§āļāđāļ็āļĄāļŦāļēāļĢāļāļģāļāļ§āļāđāļ็āļĄ = āļāļģāļāļ§āļāđāļ็āļĄ
Console.WriteLine("x/y: {0}" , result);
floatresult = (float )x/(float )y; // 7 / 5 = 1.4
Console.WriteLine("x/y: {0}" , floatresult);
result = x%y; // 7 % 5 = 2 āđāļ็āļāļāļēāļĢāļŦāļēāļĢāđāļĨ้āļ§āđāļāļēāđāļĻāļĐ 7 / 5 = 1 āđāļĻāļĐ 2
Console.WriteLine("x%y: {0}" , result);
result += x; //āļŦāļĄāļēāļĒāļึāļ result = result + x ;āļัāļāļั้āļāļāļ°āđāļ้ result = 2 + 7 = 9
Console.WriteLine("result+=x: {0}" , result);
}
}
āļāļĨāļĨัāļāļ์āļี่āđāļ้
x+y: 12
x-y: 2
x*y: 35
x/y: 1
x/y: 1.4
x%y: 2
result+=x: 9
C# Hello World Tutorial
āļ้āļēāļุāļāđāļāļĒāļĻึāļāļĐāļēāļ āļēāļĐāļēāļื่āļāđ āļĄāļēāļāļ°āļĢู้āļ§่āļēāđāļĢāļēāđāļĢิ่āļĄāļ้āļāđāļีāļĒāļāļ āļēāļĐāļēāđāļŦāļāļ็āļāļēāļĄāļ้āļāļāđāļĢิ่āļĄāđāļีāļĒāļāđāļāļĢāđāļāļĢāļĄ Hello World! āđāļ็āļāļัāļāļัāļāđāļĢāļ āđāļāļŠ่āļ§āļāļี้āđāļ็āļāļื้āļāļāļēāļāļŠุāļāđāļāļāļāļ āļēāļĐāļē C# āđāļĄ่āļ้āļāļāļŦ่āļ§āļāļāļĢัāļāđāļĢāļēāļāļ°āđāļĄ่āļāļĒู่āđāļāļŠ่āļ§āļāļี้āļāļēāļāļāļĢัāļ āđāļĨāļ°āļāļĄāļāļ°āđāļĄ่āļูāļāļึāļāļāļēāļĢāļิāļāļั้āļāđāļāļĢāđāļāļĢāļĄāļāļ°āļāļĢัāļ āļĄāļēāļูāļัāļ§āļāļĒ่āļēāļāļāļēāļĢāđāļีāļĒāļāđāļ้āļ Hello World āđāļāđāļāļāļ่āļēāļāđ āļัāļ
āļัāļ§āļāļĒ่āļēāļāļี่ 1
// Hello1.cs
public class Hello1
{
public static void Main ()
{
System.Console.WriteLine("Hello, World!" );
}
}
āļāļĨāļĨัāļāļ์
āļāļิāļāļēāļĒāđāļ้āļ
method āļŦāļĨัāļāļุāļāļัāļ§āļ้āļāļāļāļĒูāđāļāļāļĨāļēāļŠ
āđāļāļāļĨāļēāļŠ System.Console āļāļ°āļĄี method āļื่āļ WriteLine āļāļĒู่ āļĄีāļŠāļēāļĄāļēāļĢāļāđāļāļāļēāļĢāđāļŠāļāļāļ้āļāļāļ§āļēāļĄāļāļāļāļāļēāļāļāļāļāđāļāļĨāđāļ้
āļัāļ§āļāļĒ่āļēāļāļี่ 2
āđāļื่āļāļ่āļēāļĒāļ่āļāļāļēāļĢāđāļีāļĒāļāļāļģāļŠั่āļāđāļŠāļāļāļāļĨāļāļēāļāļŦāļ้āļēāļāļāđāļāļāļĢั้āļāļ่āļāđāļāđāļĢāļēāļŠāļēāļĄāļēāļĢāļāđāļĢีāļĒāļāđāļ้ System āđāļ้āļัāļāļี้
// Hello2.cs
using System ;
public class Hello2
{
public static void Main ()
{
Console.WriteLine("Hello, World!" );
}
}
āļัāļ§āļāļĒ่āļēāļāļี่ 3
āļ้āļēāļุāļāļ้āļāļāļāļēāļĢāļิāļĄāļ์āļ้āļāļĄูāļĨāđāļ้āļēāļ่āļēāļāļāļēāļ Command Line āđāļีāļĒāļāđāļ่āđāļāļĨี่āļĒāļāđāļิ่āļĄ Argument āđāļ method āļŦāļĨัāļāļāļēāļĄāļี่āđāļŠāļāļāļ้āļēāļāļĨ่āļēāļ āļึ่āļāđāļāļัāļ§āļāļĒ่āļēāļāļี้āļāļ°āļัāļāđāļĨāļ°āđāļŠāļāļāļāļĨ Argument āđāļ Command line
// Hello3.cs
// arguments: A B C D
using System ;
public class Hello3
{
public static void Main (string [] args)
{
Console.WriteLine("Hello, World!" );
Console.WriteLine("You entered the following {0} command line arguments:" ,
args.Length );
for (int i=0 ; i < args.Length; i++)
{
Console.WriteLine("{0}" , args[i]);
}
}
}
āļāļĨāļĨัāļāļ์
Hello, World!
You entered the following 4 command line arguments:
A
B
C
D
āļัāļ§āļāļĒ่āļēāļāļี่ 4
āļāļēāļĢāļืāļāļ่āļē return code āđāļāļĒāđāļิ่āļĄāļāļģāļŠั่āļāļāļēāļĄāļัāļ§āļāļĒ่āļēāļāļ้āļēāļāļĨ่āļēāļāļี้āđāļĨāļĒ
// Hello4.cs
using System ;
public class Hello4
{
public static int Main (string [] args)
{
Console.WriteLine("Hello, World!" );
return 0 ;
}
}
āļāļĨāļĨัāļāļ์
āļัāļ§āļāļĒ่āļēāļāļี่ 5
āļŦāļēāļāļุāļāļĢัāļāđāļāļĢāđāļāļĢāļĄāđāļĨ้āļ§āļŦāļ้āļēāļāļāļāđāļāļĨāļัāļāđāļāđāļĄ่āļัāļāļูāļāļĨāļĨัāļāļ์āļŠāļēāļĄāļēāļĢāļāđāļิ่āļĄāđāļ้āļāđāļ้āļัāļāļี้
using System ;
class HelloWorld
{
static void Main (string [] args)
{
Console.WriteLine("Hello World" );
Console.ReadKey();
}
}
Compiling and Running with Arguments
āđāļāļŠ่āļ§āļāļี้āđāļ็āļāļāļēāļĢāļูāļāļึāļāđāļĄื่āļāđāļĢāļēāļ้āļāļāļāļēāļĢāļิāļĄāļ์āļāļēāļāļāļĒ่āļēāļāļāļāļāļāļēāļāļŦāļ้āļēāļāļ āđāļĢāļēāļ้āļāļāļāļāļĄāđāļāļĨ์āđāļ้āļāļāļāļāļุāļāđāļĨāļ°āļĢัāļāļĄัāļ āļึ่āļāđāļĢāļēāļ้āļāļāđāļ้āļāļģāļŠั่āļāđāļื่āļāđāļŦ้āļĄัāļāļāļģāļāļēāļāļั่āļāļืāļ
java (or java.exe)
javac (or javac.exe)
āļั่āļāļāļģāđāļŦ้āļุāļāļ้āļāļāđāļāļŦāļēāđāļŦāļĨāļāđāļĨāļ°āļิāļāļั้āļāļัāļ§ JDK (Java Development Kit)
āļ้āļēāđāļĢāļēāļāļģ code āļāļēāļāļāļāļāļ§āļēāļĄāļ่āļāļāļŦāļ้āļēāļี้āļĄāļēāđāļŠ่āļĄัāļāļĨāļāđāļāđāļŦ้āđāļāļĨ์ MyFirstClass.java āđāļĢāļēāļāļ°āļ้āļāļāļāļāļĄāđāļāļĨ์āđāļĨāļ°āļĢัāļ :
āļĄัāļāļāļ°āļŠāļĢ้āļēāļāđāļāļĨ์ MyFirstClass.class āđāļĨ้āļ§āļāļģāļĄāļēāļāļāļĄāđāļāļĨ์āđāļ็āļ Java code āđāļื่āļāļĢัāļāļĄัāļ āđāļĢāļēāļ้āļāļāļāļēāļĢāļĢัāļ Java āđāļĢāļēāđāļ้āđāļ่āļื่āļāļāļāļ Class āđāļ่āļ
āđāļāļāļี้āļิāļ
āđāļāļāļี้āļูāļāļ้āļāļ
Arguments
āļ āļēāļĐāļē Java āđāļ method āļŦāļĨัāļāđāļĢāļēāđāļĢีāļĒāļāđāļ้ Array of String āđāļ็āļ argument āļึ่āļāđāļ็āļāļ่āļāļāļāļēāļāđāļāļāļģāļ่āļēāļ่āļēāļāđ āļāļēāļ Command Line āļĄāļēāļŠู่āđāļāļĢāđāļāļĢāļĄāļāļāļāđāļĢāļē āđāļĨāļ°āļุāļ Arrays āđāļāļ āļēāļĐāļē java āļāļ°āļĄีāļัāļ§āđāļāļĢ lenght āđāļ็āļāļัāļ§āļัāļāļāļ§āļēāļĄāļĒāļēāļ§āļāļāļ Array āđāļĢāļēāļŠāļēāļĄāļēāļĢāļāđāļ้āļēāļึāļ Array āđāļāļāļ่āļēāļĒāđ āđāļāļĒ for
public class Arguments {
public static void main ( String[] args) {
for ( int i = 0; i < args. length ; i++) {
System. out . println ( args[ i]);
}
}
}
āļāļēāļāļั้āļāļĨāļāļāļāļāļĄāđāļāļĨ์āđāļĨ้āļ§āļĢัāļ
javac Arguments. java
java Arguments arg0 arg1 arg2
Objects
āļุāļāļŠิ่āļāđāļāļ āļēāļĐāļē Java āļāļ°āļāļĒู่āđāļ Classes āđāļĨāļ° Objects
class Point {
int x;
int y;
}
āđāļ class point āļĄีāļāļēāļĢāļāļĢāļ°āļāļēāļĻāļัāļ§āđāļāļĢ x , y āđāļĢāļēāļŠāļĢ้āļēāļ object āļื่āļ p āđāļāļĒāļ้āļāļāđāļ้āļāļģāļŠั่āļ new
āđāļāļāļĢāļีāļี้āđāļĢāļēāļāļĢāļ°āļāļēāļĻāđāļāļĒāđāļ้ default constructor āļืāļāđāļĄ่āļĄีāļāļēāļĢāđāļŦ้āļ่āļēāđāļĢิ่āļĄāļ้āļ āļŦāļĢืāļāđāļĢāļēāļŠāļēāļĄāļēāļĢāļ constructor āđāļāļāđāļ้ āđāļāļĒ
class Point {
int x;
int y;
Point( int x, int y) {
this . x = x;
this . y = y;
}
āļāļāļāļี้āđāļĢāļēāļŠāļēāļĄāļēāļĢāļāļāļģāļŦāļāļāļ่āļēāđāļĢิ่āļĄāļ้āļāđāļŦ้āļัāļ Object āđāļ้āđāļĨ้āļ§āđāļ่āļ
new Point(4, 1)
.
āđāļĢāļēāļŠāļēāļĄāļēāļĢāļāļŠāļĢ้āļēāļāđāļ้āļĄāļēāļāļāļ§่āļē 1 constuctor āļัāļāļั้āļ
Point
āļŠāļēāļĄāļēāļĢāļāļŠāļĢ้āļēāļāđāļ้āļŦāļĨāļēāļĒāđāļāļ āļĨāļāļāļŠāļĢ้āļēāļāļีāļāļāļĢั้āļ
class Point {
int x;
int y;
Point() {
this (0, 0);
}
Point( int x, int y) {
this . x = x;
this . y = y;
}
āļ้āļāļŠัāļāđāļāļāđāļāļāļēāļĢāđāļ้
this
āļี้ āđāļĢāļēāļŠāļēāļĄāļēāļĢāļāđāļ้āļĄัāļāđāļ constuctor āđāļāļāļēāļĢāđāļĢีāļĒāļ constuctor āļื่āļ āđāļ class āļāļāļāđāļĢāļēāđāļāļ
āļŦāļĨัāļāļāļēāļāđāļĢāļēāļāļĢāļ°āļāļēāļĻ p āđāļĨ้āļ§āļŠāļēāļĄāļēāļĢāļāđāļ้āļēāļึāļāļัāļ§āđāļāļĢāļ āļēāļĒāđāļ Object āđāļ้āđāļĨāļĒ
Methods
āđāļĢāļēāļŠāļēāļĄāļēāļĢāļāļāļĢāļ°āļāļēāļĻ method āļāļāļ point āđāļ้āđāļĨ้āļ§
class Point {
... // code āļāļāļāđāļĢāļēāļ่āļāļāļŦāļ้āļēāļี้
void printPoint () {
System. out . println ( "(" + x + "," + y + ")" );
}
Point center ( Point other) {
// āđāļĢāļēāļืāļāļ่āļēāļุāļāļĻูāļāļĒ์āļāļĨāļēāļāļāļāļāļุāļāļี้āđāļĨāļ°āļุāļāļื่āļ
return new Point (( x + other. x ) / 2, ( y + other. y ) / 2);
}
Public and Private
āđāļĄื่āļāđāļĢāļēāđāļ้ private
āļ่āļāļāļัāļ§āđāļāļĢāļŦāļĢืāļ method āđāļāļāļĨāļēāļŠāļั้āļ āļั่āļāļŦāļĄāļēāļĒāļึāļāļāļĨāļēāļŠāļื่āļāļāļ°āđāļĄ่āļŠāļēāļĄāļēāļĢāļāđāļ้āļัāļ§āđāļāļĢāļี้āđāļ้ āđāļĨāļ°āđāļĄื่āļāđāļĢāļēāđāļ้ public
āļŦāļĄāļēāļĒāļึāļāļāļĨāļēāļŠāđāļŦāļāļ็āļĄāļēāđāļ้āđāļ้ āļāļāļิāđāļĢāļēāļāļ°āđāļŦ็āļ Constuctor āđāļ้ public
āđāļāļāļึāļāļŦัāļ
āļŠāļĢ้āļēāļ method āđāļŦāļĄ่āļื่āļ scale
, āļāļ°āļŠāļĢ้āļēāļāļุāļāļี่āđāļāļĨ้āļุāļ (0,0) āļี่āļŠุāļ āđāļāļĒāļĨāļāļ่āļēāļี่āļĨāļ°āļāļĢึ่āļāđāļ่āļ (8 , 4) āļŦāļĨัāļāļāļēāļāļั้āļāļāļ°āđāļ็āļ (4 , 2) , (1, 1)
class Point
private double x;
private double y;
public Point ( double x, double y) {
this . x = x;
this . y = y;
}
public void print () {
System. out . println ( "(" + x + "," + y + ")" );
}
// āļŠāļĢ้āļēāļāļāļĢāļāļี้
}
public class Main {
public static void main ( String[] args) {
Point p = new Point(32, 32);
for ( int i = 0; i < 5; i++) {
p. scale ();
p. print ();
}
}
}
class Point {
private double x;
private double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public void print() {
System.out.println("(" + x + "," + y + ")");
}
public void scale(){
x = x/2;
y = y/2;
}
}
public class Main {
public static void main(String[] args) {
Point p = new Point(32, 32);
for (int i = 0; i < 5; i++) {
p.scale();
p.print();
}
}
}