TIPOVI VARIJABLA
int - stores integers (whole numbers), without decimals, such as 123 or -123
double - stores floating point numbers, with decimals, such as 19.99 or -19.99
char - stores single characters, such as 'a' or 'B'. Char values are surrounded by
single quotes
string - stores text, such as "Hello World". String values are surrounded by double
quotes
bool - stores values with two states: true or false
KONSTANTA
const int = nyMun = 15;
Display variables:
Console.WriteLine(„Hello“ + name);
Spajanje/dodavanje varijabla
string c = a + b
Indentifier = ime od varijable
Još tipova varijabli
long myNum = 15000000000000000000L;
Koristi se kad int nemože pohranit vrjednost (ako je prevelika), broj mora završavat s L
(sintaksa)
S float ili double moraš završiti broj s F ili D
Booleans se pišu s prvim malim slovom
CASTING VARIJABLA
Implicit Casting (automatically) - converting a smaller type to a larger type size
char -> int -> long -> float -> double
Explicit Casting (manually) - converting a larger type to a smaller size type
double -> float -> long -> int -> char
Type conversion methods:
built in metode:
Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (int)
and Convert.ToInt64 (long):
GET USER INPUT
Console.ReadLine()
// Type your username and press enter
Console.WriteLine("Enter username:");
// Create a string variable and get user input from the keyboard and store it in the
variable
string userName = Console.ReadLine();
// Print the value of the variable (userName), which will display the input value
Console.WriteLine("Username is: " + userName);
S KONVERTIRANJEM
Console.WriteLine("Enter your age:");
int age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Your age is: " + age);
MATH FUNKCIJE
Math.Max(a, b);
Math.Min(a, b);
Math.Sqrt(64);
Math.Abs(-5,4);
Math.Round(9.99); - rounda na cijeli broj
STRING LENGTH
string txt = „ABDASDFŠVDI“
txt.Length
OTHER METHODS
string txt = "Hello World";
Console.WriteLine(txt.ToUpper()); // Outputs "HELLO WORLD"
Console.WriteLine(txt.ToLower()); // Outputs "hello world"
SPAJANJE STRINGOVA
string c = a + b
ili
string c =string.Concat(a, b);
ili
string name = $My full name is: {a} {b}“;
Uzimanje slova iz stringova
string myString = "Hello";
Console.WriteLine(myString[0]); // Outputs "H"
string myString = "Hello";
Console.WriteLine(myString.IndexOf("e")); // Outputs "1"
Substring()
extracts the characters from a string, starting from the specified character position/index,
and returns a new string
IF STATEMENT
if (a == b)
Console.WriteLine(„a = b“);
else
Console.WriteLine(„a is not b“);
TERNARY OPERATOR
shorthand if-else
variable = (condition) ? expressionTrue : expressionFalse;
Instead of writing:
int time = 20;
if (time < 18)
Console.WriteLine("Good day.");
else
Console.WriteLine("Good evening.");
Write:
int time = 20;
string result = (time < 18) ? "Good day." : "Good evening.";
Console.WriteLine(result);
SWITCH
int day = 4;
switch (day)
case 1:
Console.WriteLine("Monday");
break;
case 2:
Console.WriteLine("Tuesday");
break;
case 3:
Console.WriteLine("Wednesday");
break;
case 4:
Console.WriteLine("Thursday");
break;
case 5:
Console.WriteLine("Friday");
break;
case 6:
Console.WriteLine("Saturday");
break;
case 7:
Console.WriteLine("Sunday");
break;
// Outputs "Thursday" (day 4)
Ako želimo imati case gdje ništa od navedenog se ne desi koristi: „default“
int day = 4;
switch (day)
case 6:
Console.WriteLine("Today is Saturday.");
break;
case 7:
Console.WriteLine("Today is Sunday.");
break;
default:
Console.WriteLine("Looking forward to the Weekend.");
break;
WHILE LOOP
int i = 0;
while (i < 5)
Console.WriteLine(i);
i++;
}
DO/WHILE LOOP
Prvo se pokrene jednom bez obzira na to je li statement istinit, nakon toga se
ponaša kao običan while loop
do
// code block to be executed
while (condition);
PRIMJER
int i = 0;
do
Console.WriteLine(i);
i++;
while (i < 5);
NPR
int i = 0;
do
Console.WriteLine(i);
i++;
while (i < 5 && i > 2);
isprinta samo i jednom
FOR LOOP
for (int i = 0; i < 5; i++)
Console.WriteLine(i);
ZA LISTE:
foreach (type variableName in arrayName)
{
// code block to be executed
FOR LISTS CONTINUE
for (int i = 0; i < 10; i++)
if (i == 4)
{
continue;
}
Console.WriteLine(i);
Kada i bude 4, interacija će se preskočit, nakon toga se opet sve obavlja
normalno
ARRAYS
Da definiramo array samo stavimo [] ispred željene varijable npr
string[] cars;
int[] myNum = {10, 20, 30, 40};
Console.WriteLine(myNum[0]);
myNum[1] = 15
myNum.Length;
Loopaj index kroz array
string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (int i = 0; i < cars.Length; i++)
Console.WriteLine(cars[i]);
}
Foreach
string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
foreach (string i in cars)
Console.WriteLine(i);
Sort arrays
// Sort a string
string[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
Array.Sort(cars);
foreach (string i in cars)
Console.WriteLine(i);
// Sort an int
int[] myNumbers = {5, 1, 8, 9};
Array.Sort(myNumbers);
foreach (int i in myNumbers)
Console.WriteLine(i);
}
System.Linq NAMESPACE
using System;
using System.Linq;
namespace MyApplication
class Program
{
static void Main(string[] args)
{
int[] myNumbers = {5, 1, 8, 9};
Console.WriteLine(myNumbers.Max()); // returns the largest value
Console.WriteLine(myNumbers.Min()); // returns the smallest value
Console.WriteLine(myNumbers.Sum()); // returns the sum of elements
}
}
METODE
class Program
static void MyMethod()
{
// code to be executed
}
MyMethod() is the name of the method
static means that the method belongs to the Program class and not an object of
the Program class. You will learn more about objects and how to access
methods through objects later in this tutorial.
void means that this method does not have a return value. You will learn more
about return values later in this chapter
ZOVI METODU
static void MyMethod()
Console.WriteLine("I just got executed!");
static void Main(string[] args)
MyMethod();
// Outputs "I just got executed!"
PARAMETRI I ARGUMENTI METODE
static void MyMethod(string fname)
Console.WriteLine(fname + " Refsnes");
static void Main(string[] args)
MyMethod("Liam");
MyMethod("Jenny");
MyMethod("Anja");
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes
DEFAULT VALUE
static void MyMethod(string country = "Norway")
Console.WriteLine(country);
static int MyMethod(int x)
return 5 + x;
static void Main(string[] args)
Console.WriteLine(MyMethod(3));
}
// Outputs 8 (5 + 3)
MOŽE SE METODA SPREMITI U VARIJABLU
int z = MyMethod(5, 3);
MOŽE SE DATI ARGUMENTI U BILO KOJEM REDOSLJEDU AKO SE NAPIŠU
IMENA
static void MyMethod(string child1, string child2, string child3)
Console.WriteLine("The youngest child is: " + child3);
static void Main(string[] args)
MyMethod(child3: "John", child1: "Liam", child2: "Liam");
// The youngest child is: John
METHOD OVERLOADING
S method overloadingom, više metoda mogu imati isto ime s različitim
parametrima
int MyMethod(int x)
float MyMethod(float x)
double MyMethod(double x, double y)
static int PlusMethodInt(int x, int y)
{
return x + y;
static double PlusMethodDouble(double x, double y)
return x + y;
static void Main(string[] args)
int myNum1 = PlusMethodInt(8, 5);
double myNum2 = PlusMethodDouble(4.3, 6.26);
Console.WriteLine("Int: " + myNum1);
Console.WriteLine("Double: " + myNum2);
OOP
Creating a class
class Car
string color = "red";
Creating object
class Car
string color = "red";
static void Main(string[] args)
{
Car myObj = new Car(); // new keyword is used to create object
Console.WriteLine(myObj.color);
}
Moguće je stvoriti objekt klase i pristupiti njemu iz druge klase
class Car
public string color = "red";
class Program
static void Main(string[] args)
{
Car myObj = new Car();
Console.WriteLine(myObj.color);
}
FIELDS AND METHODS = CLASS MEMBERS
Stvorimo klasu Car s dva fields i jednom method
// The class
class MyClass
// Class members
string color = "red"; // field
int maxSpeed = 200; // field
public void fullThrottle() // method
{
Console.WriteLine("The car is going as fast as it can!");
}
OSTAVLJANJE FIELDOVE PRAZNIM I DODAVANJE IH KADA STVARAMO OBJEKT
class Car
string color;
int maxSpeed;
static void Main(string[] args)
{
Car myObj = new Car();
myObj.color = "red";
myObj.maxSpeed = 200;
Console.WriteLine(myObj.color);
Console.WriteLine(myObj.maxSpeed);
}
METODE
METODA MORA BITI PUBLIC
class Car
string color; // field
int maxSpeed; // field
public void fullThrottle() // method
{
Console.WriteLine("The car is going as fast as it can!");
}
static void Main(string[] args)
{
Car myObj = new Car();
myObj.fullThrottle(); // Call the method
}
KONSTRUKTORI
A constructor is a special method that is used to initialize objects. The
advantage of a constructor, is that it is called when an object of a class is
created. It can be used to set initial values for fields:
// Create a Car class
class Car
public string model; // Create a field
// Create a class constructor for the Car class
public Car()
{
model = "Mustang"; // Set the initial value for model
}
static void Main(string[] args)
{
Car Ford = new Car(); // Create an object of the Car Class (this will call
the constructor)
Console.WriteLine(Ford.model); // Print the value of model
}
// Outputs "Mustang"
CONSTRUCTOR PARAMETERS
class Car
{
public string model;
// Create a class constructor with a parameter
public Car(string modelName)
{
model = modelName;
}
static void Main(string[] args)
{
Car Ford = new Car("Mustang");
Console.WriteLine(Ford.model);
}
// Outputs "Mustang"
ACCESS MODIFIERS
The public keyword is an access modifier, which is used to set the access
level/visibility for classes, fields, methods and properties.
PROPERTIES
To get private variabls outside of class we need to use properties: get, set
class Person
private string name; // field
public string Name // property
{
get { return name; } // get method
set { name = value; } // set method
}
GET metoda vrati vrijednost varijable name
SET metoda daje vrijednost „value“ „name“ varijabli.
class Person
{
private string name; // field
public string Name // property
{
get { return name; }
set { name = value; }
}
class Program
static void Main(string[] args)
{
Person myObj = new Person();
myObj.Name = "Liam";
Console.WriteLine(myObj.Name);
}
OUTPUT: Liam
Automatic properties:
class Person
public string Name // property
{ get; set; }
class Program
static void Main(string[] args)
{
Person myObj = new Person();
myObj.Name = "Liam";
Console.WriteLine(myObj.Name);
}
BRŽI NAČIN ZA RAĐENJA PROPERTIA
INHERITANCE
To inherit from a class, use the : symbol.
In the example below, the Car class (child) inherits the fields and methods from
the Vehicle class (parent):
class Vehicle // base class (parent)
public string brand = "Ford"; // Vehicle field
public void honk() // Vehicle method
{
Console.WriteLine("Tuut, tuut!");
}
class Car : Vehicle // derived class (child)
public string modelName = "Mustang"; // Car field
}
class Program
static void Main(string[] args)
{
// Create a myCar object
Car myCar = new Car();
// Call the honk() method (From the Vehicle class) on the myCar object
myCar.honk();
// Display the value of the brand field (from the Vehicle class) and the value of the
modelName from the Car class
Console.WriteLine(myCar.brand + " " + myCar.modelName);
}
If you don't want other classes to inherit you can use „sealed“ keyword
class Car : Vehicle
...
}
POLYMORPHISM
For example, think of a base class called Animal that has a method called animalSound().
Derived classes of Animals could be Pigs, Cats, Dogs, Birds - And they also have their own
implementation of an animal sound (the pig oinks, and the cat meows, etc.):
class Animal // Base class (parent)
public void animalSound()
{
Console.WriteLine("The animal makes a sound");
}
class Pig : Animal // Derived class (child)
public void animalSound()
{
Console.WriteLine("The pig says: wee wee");
}
class Dog : Animal // Derived class (child)
public void animalSound()
{
Console.WriteLine("The dog says: bow wow");
}
}
Now we can create Pig and Dog objects and call the animalSound() method on both of them
OUTPUT će biti
The animal makes a sound
The animal makes a sound
The animal makes a sound
To je jer parent klasa overrieda metode istim imenom
C# daje način da maknemo taj override s „virutal“ keywordom unutar parent klase i
koristimo „override“ keyword za svaku metodu koju ne želimo da parent kalsa overridea
Data abstraction is the process of hiding certain details and showing only essential
information to the user.
Abstraction can be achieved with either abstract classes or interfaces (which you will learn
more about in the next chapter).
The abstract keyword is used for classes and methods:
Abstract class: is a restricted class that cannot be used to create objects (to access it, it
must be inherited from another class).
Abstract method: can only be used in an abstract class, and it does not have a body. The
body is provided by the derived class (inherited from).
INTERFACES
Interface je „abstract class“ koji može samo imati apstraktne metode i propertie (s praznim
tjelima)
By default, members of an interface are abstract and public.
To access the interface methods, the interface must be "implemented" (kinda
like inherited) by another class. To implement an interface, use the : symbol
(just like with inheritance). The body of the interface method is provided by the
"implement" class. Note that you do not have to use the override keyword when
implementing an interface:
Također je moguće imati više interfacea u jednoj klasi
An enum is a special "class" that represents a group
of constants (unchangeable/read-only variables).
To create an enum, use the enum keyword (instead of class or interface), and
separate the enum items with a comma:
By default, the first item of an enum has the value 0. The second has the value
1, and so on.
To get the integer value from an item, you must explicitly convert the item to
an int:
Također je mgouće dati broj nekom podatku u Enumu, i drugi će se podatci
sami poravnati (nakon tog podatka)
Enums are often used in switch statements to check for corresponding values:
