Abstract class và Interface (1)

We all know the pillars for object-oriented programming are: abstraction, inheritance, encapsulation, polymorphism. The motto is like that, but in an old programming language like C#, how do you apply it to a real problem. Bờm researched and learned, today he understood two keywords: abstraction and inheritance. In this "Hoa Son commentary on the code", Bờm presented: What is an abstract class? What are interfaces?

1. Abstract class. So we can say that an abstract class cannot have an instance (a concrete object, an instance). Abstract classes are often used to define base classes in inheritance.

In an abstract class, we can define abstract methods or non-abstract methods.

A small example will make it easier to understand:

We define 2 classes: Dog and Cat

We see that both the Dog and Cat classes share the same properties and methods. We wonder if there is a way to collect common properties and methods? OOP shows that: we can apply abstraction, and inheritance in this case. We abstract the two classes Dog and Cat into an Animal class with common properties and methods, using the abstract keyword to do this.

The Animal class will be declared as follows

Refactor Dog and Cat class by using inheritance.

Through this example, we need to remember:

- Use abstract class to achieve abstraction, inheritance in object-oriented programming

- Use the abstract keyword to declare a class or a method as abstract.

- To implement abstract members of an abstract class, we use the keyword "override" in a subclass.

2. Interface. We all know C# supports inheritance, but a class can only inherit from one superclass (single inheritance). It does not support multiple inheritances. To solve this problem, we can use an interface. 

In the subclass, we implement the interface. A subclass can implement many different interfaces. So what is an interface?

The interface is like a class, can contain methods, properties ... interface contains only declarations (declaration). The classes implement the interface, which will specify the methods and properties of that interface.

Going back to the above example, we analyze that between the two classes Dog and Cat have their own actions, for example, dogs can bite (bite)... if we declare a common method (Bite) in the abstract class: animal, then we must apply this method to the Cat class (which is not reasonable).

We could also define a Bite method for the Dog class only, but think further... some other animals have the ability to "bite" too, and we want to abstract this method so we can use it in subclasses (if necessary), in this case, we use interface.

We can declare an interface like this: We all know C# supports inheritance, but a class can only inherit from one superclass (single inheritance). It does not support multiple inheritances. To solve this problem, we can use an interface. In the subclass, we implement the interface. A subclass can implement many different interfaces. So what is an interface?

We can declare an interface like this:

The Dog class implements the interface, here we also see that: by using the interface, the Dog class can realize the dream of multiple inheritances.

So:

- Use interfaces for multiple inheritances.

- Use interfaces to achieve abstraction in OOP.

- In addition, the use of interfaces also reduces dependencies between classes. Applied to achieve at a theory called "Solid" that you study about programming principles, the design pattern has probably been heard.

In this article, Mr. Bom only introduces abstract classes and interfaces, the simplest way to achieve two pillars in object-oriented programming is abstraction and inheritance. The problem about using the interface in a more advanced form, to reach the solid programming principle, it lies in another realm... see you in the next "Hoa Son discussion of code".

Read More

Data type 3 - string type

In any programming language, to represent the value of a variable, we need to declare the data type of that variable. 

In previous lessons, Bờm reviewed value types and reference types. Following that series, Bờm wrote something about a data type that we also use a lot to process strings, which is String. So what do we know about string type in C# language? With limited knowledge, I will only point out a few basic points about strings as a way to review.

Yeah, let's go:

1. What is String? string and System.String are the same or different?

For string processing .Net framework provides us with a class: System.String (fields, methods, constructor...). A String in C# is an object of type String, its value is text. This means that if you want to store information of a string, a text, you can completely use string type to store. 

            // String of characters 
            System.String nickName = "Victor";

            // String made of an Integer 
            System.String age = "28";

Many of you also asked if string and System.String is different or the same, oh good question... When I was a student, I used to ask the same question... And the answer is: in In C#, the keyword string is an alias of String, so the two notes string and String are basically the same. In programming you want to use string or String keyword, it's up to you!!!

2. String is an immutable.

This means you can't change the string once it's created.

For example:

          string string1 = "Hello World!!";

It will occupy a memory area on the heap to store this string.

If you want to change the value of string1 by adding to string1 the value "from Tutorials teacher". You think: the system just needs to change the value of string1 by adding the value "from Tutorials teacher" and it's ok...

Oh No, because of its immutable nature, it will create a new string "Hello!! from tutorials teacher" and assign this value to string1.

(image: string_memory; source: tutorialteacher.com)

Unprecedented magic and this magic brings a disadvantage that if we modify the string1 many times, it also creates many new strings, result in reduced program performance.

To solve this problem, C# martial arts secrets give us a spell String "Biu Do".

3. String Builder
String builder helps to increase performance when working with string type when we need to edit, delete, or any operation on string. It increases performance because each time it manipulates a string, it doesn't create any new strings, simply manipulates the string itself.

(image: stringbuilder_memory; source: tutorialteacher.com)

Let see the below example:

Yup!! Here's the result, surprise!!!

In short, string builder is useful when working with string concatenation and string operations, it can increase performance when manipulating strings.

When working on strings, we need to call methods or apply operations on them. So what happens when our string variable has a value of null.

4. Null string in C#

A null string is a variable of type string but it is uninitialized or has a value of null.

If we call a property or a method on a null string, boom.... an exception will be thrown... This makes us think, to get the best handling code. A small note, but martial.

use the method: IsNullOrEmpty

The above is just a little basic theory about string so that we have the concept of null string, what is an immutable string? how to solve performance problems when working with strings... There are many things about strings, such as helper methods, properties, fields... I think the basic knowledge of what string is, string is immutable it needs to be stored in our memory before we find a way to apply it to real string processing problems.

Related Posts:

Part 1: Value Type

Part 2: Reference type.

Reference:
      - https://www.tutorialsteacher.com/csharp/csharp-string

Read More

Lập trình hướng đối tượng – OOP (2)

In my previous article, I shared some of its basic concepts: what is an object? What are classes? How is the constructor defined and used?

Next, in this article, I will present the basic features of object-oriented programming. Everyone knows when it comes to object-oriented programming, any coder, from amateur to professional, must master these characteristics. It's like the inner gong of a sect. Referring to that type of martial arts, one must immediately remember its inner gong and know how to use it. So what is the inner work of the mind of OPP? These are Abstraction, Inheritance, Encapsulation, Polymorphism.

Here we go.

First, Abstraction: It is a feature, an object-oriented principle, used to describe and display the necessary features of an object for other objects. This feature allows hiding the details of the object. It focuses on what the object does rather than how the object does it.

You can picture it like this: We have a dog, it is an object. It has action: go and eat. Dogs also have a way of walking, a dog's way of eating is different from a cat's. Abstraction, describing to the surrounding, the dog has the act of eating and walking. But how to eat, how to walk it is the dog's business, not to be described to the surroundings.

See the following code for more clarity.

Second, Encapsulation.

This means that the details of an object are restricted from being accessed by other objects, or hidden from view by other objects.

Speaking of closures, we need to know a concept called access modifier. It controls access to member data in a class. We have access modifiers: private, public, internal, protected, protected internal.

- Private: only members of the same class can access it.

- Public: unlimited access.

- Protected: only members of the class and the derived class have access.

- Internal: only members in the same assembly.

- Protected internal: members in the same assembly or inherited class are accessible.

Next, let's learn the third, Inheritance.

Defining inheritance in the object-oriented direction is the same as in social inheritance. Everyone must know who inherits, inherits from whom, and inherits what characteristics?

In object-oriented, the class to be inherited is called “superclass” or “base class”, in this class we define common features that will be inherited from subclasses. Subclasses that inherit from the parent class are called "derived classes".

The benefit of inheritance is that it can reuse code, increase system maintainability, as well as reduce the cost of system development. C# does not support multiple inheritances, to do that, we can use an interface.

An example of inheritance: We have a superclass animal: has a name property, a constructor, a move and eat method. Subclasses: dog, cat inherit from an animal class.

Implement base class

Implement derived class: Dog

Use derived class:

                

Finally Polymorphism.

Polymorphism means many forms. When a problem is handled in different ways, we call it polymorphism. We have two types of polymorphism: Compile polymorphism, or overloading, and run-time polymorphism, or overriding.

-  Overloading: a method has many different forms based on its own parameters.

- Overriding by using the keyword: virtual and override

-        

Above, you and I have gone through the 4 main slogans in object-oriented programming. Hopefully, we will memorize and use it in the best way in the Kung-fu code.

Related posts:

Part 1: OOP -1

Read More

Lập trình hướng đối tượng - OOP 1

If you are a student or a professional coder, you must have heard many times about OPP or object-oriented programming.

In my series of 2 articles, I will review the basic concepts of object-oriented programming. What is it? What are its characteristics?

OPP stands for Object oriented programming. It is a programming paradigm that is based on objects. It models real-world objects into programming objects. Those objects have the same properties and actions as in the real world. 

For example, A student is a real-world object. Student attributes height, weight, age, name... Actions: eat, sleep, walk, study. When modeled in programming, we also have an object that holds the data of student information and actions.

So each student object we create a student object in programming? It's not like that: We have concepts: object and class

What are classes?

It is a prototype of objects. It has variables that store data as well as methods of an object

We have a student class as follows

Object là gì?

Object là một thể hiện cụ thể của một đối tượng thực tế thông qua bản mẫu là một class. Khi một object được tạo thì nó sẽ được cấp phát một vùng nhớ trên heap để lưu trữ thông tin của nó.

Ví dụ: Ta có đối tượng sinh viên 1 là một thể hiện cụ thể của một sinh viên trong thực tế, qua bản mẫu là class sinh viên ta vừa tạo ở trên.

What are Objects?

The object is a concrete instance of an actual object through the template is a class. When an object is created, it will be allocated a memory area on the heap to store its information.

For example, We have student object 1 which is a specific instance of a student in reality, through the template is the student class we just created above.

Here we create a constructor with 2 variables passed in, name and age. This constructor will assign values to the member variables of the class.

When we initialize the student object with this constructor, we will pass the value of name, age.

Example: 

Using the student class creates a student object, and calls the object's self-introduction function.

Results: Just like in the real world, students use their own information to introduce others, in programming when abstracting an object, it also has the same behavior: using the information to self-identify. introduce yourself

Through this example, we can better understand: what is a class? What is an object? What is Constructor? And how to use them. In the following article, I will present the basic properties of OPP.

Related posts:

Part 2: OOP - 2

Read More

CÁC CẤU TRÚC LẶP - Repetition structures

    Hoang Phi Hong, you must have heard a lot about this name, especially those who have a bit of blood in fighting and kicking will know very well. This master has a technique called Shadowless Kick. Roughly it is a series of consecutive kicks. It is repetition. In programming we also have a similar technique, also performing the repetition of a certain piece of code. That's the charge loop, oh my…the loop structures.

In C#, we have loop types like while loop, do-while loop, for loop, and foreach loop. Within the scope of this article, I only present the concept, structure, block diagram, and usage (just at a simple level) of each of the above iterations.

First, we need to understand iteration constructs that will allow us to execute a statement or group of statements n times when the loop condition is true.

1. While loop

    Is a simple loop structure, allowing statements to be executed until the value of the conditional expression is still true (condition expression = true).

Syntax:

      While (condition)

     {

            Statement(s);

     }

For example:

Run the above code, will print the screen values the values of n from 0 -> 6.

We see the structure of the while loop that will consider the value of n before executing the code inside the loop. With the while loop structure, we do not specify the number of iterations, the number of iterations depends on the value of the conditional expression. So it is very likely that the statements inside the loop will not be executed at all.

The flowchart diagram, which can be represented as follows:

       2. Do-while loop

     The do-while construct is similar to the while construct. It allows executing statements when the value of the conditional expression is true. It also cannot know the exact number of iterations in advance, it depends on the value of the conditional expression. But the difference from the while structure is that the conditional expression is placed at the bottom of the loop. This means that even if the conditional expression is false, the loop will be executed at least once. You can think of it as something like Better a glorious minute than a hundred years.

The structure of do-while is as simple as while:

      do

     {

            Statement(s);  

     }

     while(condition)

Let see the below code:

Here's the result

   Even though the conditional expression is false, the loop's code is still executed once. It is a remarkable feature when we use the do-while structure.

When studying the two structures above, we see that they are both structures with an indefinite number of iterations. Next, we will learn two iterative constructs, which we can predetermine the number of iterations.

       3. For loop

   This structure, allows statements to be executed when the value of the conditional expression is still true.

The difference with the above two structures is that the for loop has 3 components: the initialization expression for the loop, the conditional expression, and the counter variable. This helps fraternal coders completely determine the exact number of iterations they want.

Its structure is as follows

     for(init-expr; cond-expr; count-expr)

    {

            Statement(s);

    }

Example: 

Here's what we got

Here's the flowchart:

                 

The for construct is very useful in case we need to iterate a certain number of times.

       4. Foreach loop:

We have a collection of type arrays or any kind of collection. The usual way we use for traverses from 0 -> array.length; There is nothing wrong with this, but in C# there is a loop type that helps us iterate through the elements of an array or any type of collection. It's foreach.

We have a syntax:

   foreach(elementtype element in collection)

  {

            Statement(s);  

  }

   For example, we have an array of list of courses, we want to go through this list and print the name of each element in the list, we can use this trick as follows:

Here we got

      

   One thing worth noting about foreach is that we traverse the array sequentially, using only the element in question, and don't care about the number of elements currently in the array. In contrast, with for, we can do random access while traversing the array, but need to know the number of elements in the array.

      Each iterative structure has its own advantages and disadvantages, and how to use it to achieve the desired results is up to each coder. But first, having a good understanding of iterative constructs, and practicing it in specific situations over and over again, will help us to use them more effectively.

Read More

CẤU TRÚC RẼ NHÁNH - Decision structures

In this section, I will review with you the basics of branching. It is a fundamental part of any programming language. It is similar to the basic martial arts in Kung-fu.

What is a branching structure? Attack or defend, attack, wait, no no… defend. The boxer is wondering whether to attack or defend in this case. Don't worry, the branching structure will help the boxer decide which option. I've rambled on about fighting again. But hopefully easy to understand branching structure. The branching structure helps to make a decision, no matter what the situation, fighting or coding. I will go deeper into the field of coding. J)

In C# we have branching structures: If, If-else, switch.

1. If, If - else

Form: If(Boolean expression)

            {

                        //Code

    }

Code is executed only when the Boolean expression is true.

For example

Here is the result:

If the statement flow chart

Here, the resulting output to the screen will be executed, when the condition i < j is true.

Try to guess the result of the following code:

Let see the if-else construct. The if-else construct will allow the program to execute a piece of code when the Boolean expression is false.

For instance:

In this case, it is easy to see that i is not greater than j. So the code in the else part will be executed and output to the output screen:

2. Switch 

It allows multiple branches like if-else, in which there must be one or more cases and a default case is required. 

Form:

Switch(expression)

Case1: Code block 1

Case2: Code block 2

…

Default:

Let see the below example

Result is:

The above constructs all help the program to make a decision about which code to execute. The question is when to use which structure? This requires each coder to practice a lot, and accumulate more experience for themselves. Personally, when deciding to branch based on a constant value, I would use a switch, it makes the code easy to read, and easy to debug.

Read More

DATA TYPE 2: Reference type

In the previous post, I introduced the basics of value types. In today's post, I continue to introduce you to reference types. What is a reference type? What types are there? Is it possible to convert from a reference type to a value type?

As we know the value type will store the value of a variable directly, and that value is stored on the stack. Unlike the value type, the reference type does not store the value directly, but it does contain a pointer to the memory area where the value is stored. The value of the reference type is stored on the heap.

To understand better, we can consider the following illustrative example:

In the above example, I create a variable name with a data type string and do not initialize it. I then assign a value to the variable name. The name variable will store in allocated memory "M100" and the M100 will point to the actual value I assigned to the variable name = “Victor”.

Could I convert a value from Reference type to Value type??

  

Definitely yes, and that conversion technique in the coding world they call "boxing and unboxing".

Boxing is a conversion from a value type to a reference type. Boxing is also known as implicit conversion. During conversion, the CLR will convert the value type to System. Object and store it on the Heap.

Let check this example:

In the above example, the CLR will create a variable int i = 10 and store it on the stack. Then will create a variable "o" on the heap and copy its value to the corresponding allocated memory for the object "o".

Unboxing will convert from a reference type to a value type. Unboxing is also understood as converting the data type explicitly.

In the first two lines, the CLR will convert from value type to reference type. The next line will perform the conversion from a reference type to a value type, which also includes checking if object o is holding a value of type int?

Let see this example:

Here is the result:

The reason, during unboxing, the CLR will perform checks to make sure the boxed object is of the correct type given.

Thus, we have understood the basic concept of value types and reference types, as well as understand their conversion using boxing and unboxing techniques.

Related Posts:

Part 1: Value type.

Part 3: String type in C#.

Read More