CSharp OOP.pdf

[email protected] Trang 1

NGÔN NGỮ

LẬP TRÌNH C#

-------------------------@&?-------------------------

MỤC LỤC Chương 1: Microsoft .NET .............................................................................................................................2 Chương 2: Giới thiệu ngôn ngữ C# ................................................................................................................3 Chương 3: Nền tảng ngôn ngữ C#..................................................................................................................4

Kiểu dữ liệu ...................................................................................................................................................4 Biến và hằng ..................................................................................................................................................5 Câu lệnh .........................................................................................................................................................5 Namespace .....................................................................................................................................................6

Chương 4: Lập trình hướng đối tượng ..........................................................................................................7 Mục tiêu của việc thiết kế 1 phần mềm .........................................................................................................7 Quá trình thiết kế phần mềm..........................................................................................................................7 Các cách tiếp cận trong thiết kế .....................................................................................................................7 Trừu tượng hóa ..............................................................................................................................................7 Đối tượng trong LTHĐT ...............................................................................................................................8 Tạo và sử dụng đối tượng ..............................................................................................................................8 Tính đóng gói – Encapsulation ....................................................................................................................10 Tính kế thừa - Inheritance, Tính đa hình - Polymorphism ........................................................................11 Tính trừu tượng - abstract classes ................................................................................................................13 Giao diện – Interfaces ..................................................................................................................................16 Delegate .......................................................................................................................................................17 Event: ...........................................................................................................................................................18


Chương 1: Microsoft .NET Microsoft .NET gồm 2 phần chính : Framework và Integrated Development Environment (IDE)

o Framework cung cấp những gì cần thiết và căn bản, chữ Framework có nghĩa là khung hay khung cảnh trong đó ta dùng những hạ tầng cơ sở theo một qui ước nhất định để công việc được trôi chảy.

o IDE thì cung cấp một môi trường giúp chúng ta triển khai dễ dàng, và nhanh chóng các ứng dụng

dựa trên nền tảng .NET. Nếu không có IDE chúng ta cũng có thể dùng một trình soạn thảo ví như Notepad hay bất cứ trình soạn thảo văn bản nào và sử dụng command line để biên dịch và thực thi, tuy nhiên việc này mất nhiều thời gian.


Chương 2: Giới thiệu ngôn ngữ C# C# là ngôn ngữ đơn giản: C# loại bỏ một vài sự phức tạp và rối rắm của những ngôn ngữ như Java và c++, bao gồm việc loại bỏ những macro, những template, đa kế thừa, và lớp cơ sở ảo (virtual base class). Chúng là những nguyên nhân gây ra sự nhầm lẫn hay dẫn đến những vấn đề cho các người phát triển. C# là ngôn ngữ hiện đại: Điều gì làm cho một ngôn ngữ hiện đại? Những đặc tính như là xử lý ngoại lệ, thu gom bộ nhớ tự động, những kiểu dữ liệu mở rộng, và bảo mật mã nguồn là những đặc tính được mong đợi trong một ngôn ngữ hiện đại. C# chứa tất cả những đặc tính trên. C# là ngôn ngữ hướng đối tượng: Những đặc điểm chính của ngôn ngữ hướng đối tượng (Object-oriented language) là sự đóng gói (encapsulation), sự kế thừa (inheritance), và đa hình (polymorphism). C# hỗ trợ tất cả các đặc tính trên. C# là ngôn ngữ mạnh mẽ và cũng mềm dẻo: C# được sử dụng cho nhiều các dự án khác nhau như là tạo ra ứng dụng xử lý văn bản, ứng dụng đồ họa, bản tính … C# là ngôn ngữ ít từ khóa:

C# là ngôn ngữ hướng module: Mã nguồn C# có thể được viết trong những phần được gọi là những lớp, những lớp này chứa các phương thức thành viên của nó. Những lớp và những phương thức có thể được sử dụng lại trong ứng dụng hay các chương trình khác.


Chương 3: Nền tảng ngôn ngữ C#

Kiểu dữ liệu C# là ngôn ngữ lập trình mạnh về kiểu dữ liệu, một ngôn ngữ mạnh về kiểu dữ liệu là phải khai báo kiểu của mỗi đối tượng khi tạo (kiểu số nguyên, số thực, kiểu chuỗi, kiểu điều khiển...) và trình biên dịch sẽ giúp cho người lập trình không bị lỗi khi chỉ cho phép một loại kiểu dữ liệu có thể được gán cho các kiểu dữ liệu khác. Kiểu dữ liệu của một đối tượng là một tín hiệu để trình biên dịch nhận biết kích thước và khả năng của một đối tượng. C# phân tập hợp kiểu dữ liệu này thành hai loại: Kiểu dữ liệu giá trị (value) và kiểu dữ liệu tham chiếu (reference). Đối với một kiểu dữ liệu giá trị thì sẽ được lưu giữ kích thước thật trong bộ nhớ đã cấp phát là stack. Trong khi đó thì địa chỉ của kiểu dữ liệu tham chiếu thì được lưu trong stack nhưng đối tượng thật sự thì lưu trong bộ nhớ heap. Ghi chú: Tất cả các kiểu dữ liệu xây dựng sẵn là kiểu dữ liệu giá trị ngoại trừ các đối tượng và chuỗi. Và tất cả các kiểu do người dùng định nghĩa ngoại trừ kiểu cấu trúc đều là kiểu dữ liệu tham chiếu.


Biến và hằng Gán giá trị xác định cho biến: <kiểu> <tên biến> = <giá trị>; Hằng: const <kiểu> <tên hằng> = <giá trị>; Kiểu liệt kê: class ViDuKieuLietKe {

// Khai báo kiểu liệt kê enum NhietDoNuoc {

DoDong = 0, DoNguoi = 20, DoAm = 40, DoNong = 60, DoSoi = 100,

} static void Main() {

System.Console.WriteLine( “Nhiet do dong: {0}”, NhietDoNuoc.DoDong); System.Console.WriteLine( “Nhiet do nguoi: {0}”, NhietDoNuoc.DoNguoi); System.Console.WriteLine( “Nhiet do am: {0}”, NhietDoNuoc.DoAm); System.Console.WriteLine( “Nhiet do nong: {0}”, NhietDoNuoc.DoNong); System.Console.WriteLine( “Nhiet do soi: {0}”, NhietDoNuoc.DoSoi);

} }

Câu lệnh Phân nhánh không có điều kiện: gọi một trong các từ khóa sau: goto, break, continue, return, statementthrow. Phân nhánh có điều kiện:

if (biểu thức điều kiện) {

<lệnh 1> <lệnh 2> ....

} else {

<lệnh 1> <lệnh 2> ...

}


switch (biểu thức điều kiện) {

case <giá trị>: <Các câu lệnh thực hiện> <lệnh nhảy> [default: <Các câu lệnh thực hiện mặc định>]

}

Câu lệnh lặp: while (Biểu thức)

<Câu lệnh thực hiện> do

<Câu lệnh thực hiện> while ( điều kiện ) for ([ phần khởi tạo] ; [biểu thức điều kiện]; [bước lặp])

<Câu lệnh thực hiện> foreach ( <kiểu tập hợp> <tên truy cập thành phần > in < tên tập hợp>)

<Các câu lệnh thực hiện>

Namespace Giả sử có một người nói Phúc là một kỹ sư, từ kỹ sư phải đi kèm với một lĩnh vực nhất định nào đó, vì nếu không thì chúng ta sẽ không biết được là anh ta là kỹ sư cầu đường, cơ khí hay phần mềm. Khi đó một lập trình viên C# sẽ bảo rằng Phúc là CauDuong.KySu phân biệt với CoKhi.KySu hay PhanMem.KySu. Namespace trong trường hợp này là CauDuong, CoKhi, PhanMem sẽ hạn chế phạm vi của những từ theo sau. Nó tạo ra một vùng không gian để tên sau đó có nghĩa. Tương tự như vậy ta cứ tạo các namespace để phân thành các vùng cho các lớp trùng tên không tranh chấp với nhau. C# đưa ra từ khóa using đề khai báo sử dụng namespace trong chương trình:

using < Tên namespace > Để tạo một namespace dùng cú pháp sau: namespace <Tên namespace> {

< Định nghĩa lớp A> < Định nghĩa lớp B > .....

}


Chương 4: Lập trình hướng đối tượng

Mục tiêu của việc thiết kế 1 phần mềm: · Tính tái sử dụng (reusability): thiết kế các thành phần có thể được sử dụng trong nhiều phần mềm

khác nhau · Tính mở rộng (extensibility): hỗ trợ các plug-ins. · Tính mềm dẻo (flexibility):

o Có thể dễ dàng thay đổi khi thêm mới dữ liệu hay tính năng. o Các thay đổi không làm ảnh hưởng nhiều đến toàn bộ hệ thống

Quá trình thiết kế phần mềm: · Quá trình thiết kế: chia phần mềm và thiết kế theo từng phần, từng component · Trừu tượng hóa: rất cần thiết trong thiết kế. Cụ thể: bỏ qua những chi tiết của component, quan tâm

các thành phần ở mức trừu tượng. · Xác định các component: top-down · Tích hợp: bottom-up. Gắn kết các components nhỏ lại với nhau.

Các cách tiếp cận trong thiết kế · Thiết kế theo hàm/thủ tục:

o Tìm ra các hàm/thủ tục để hoàn tất các yêu cầu o Kết quả là hệ thống cấu trúc và mối quan hệ giữa các hàm/thủ tục

· Thiết kế theo module: o Phân tích và tìm ra các module bao gồm thành phần dữ liệu và các hàm/thủ tục liên quan o Cách thực hiện dựa vào việc gom nhóm các thành phần tương tự nhau về ý nghĩa, phạm vi…

· Thiết kế theo hướng đối tượng o Trừu tượng hóa dữ liệu và các hàm/thủ tục liên quan o Chia hệ thống ra thành các lớp/đối tượng o Mỗi lớp/đối tượng có các tính năng và hành động chuyên biệt o Các lớp có thể được sử dụng để tạo ra nhiều đối tượng cụ thể

Trừu tượng hóa


Đối tượng trong LTHĐT · Đối tượng là 1 thực thể phần mềm bao bọc các thuộc tính mô tả trạng thái và các phương thức liên

quan. · Kiểu dữ liệu lớp đối tượng: class · Class có các tính chất sau:

o Đóng gói: chứa đựng dữ liệu và các hàm/thủ tục liên quan o Che giấu dữ liệu: các thực thể phần mềm khác không can thiệp trực tiếp vào dữ liệu bên trong

được mà phải thông qua các phương thức cho phép

Tạo và sử dụng đối tượng: Ví dụ: Lớp Phân Số namespace Phan1_PhanSo { class PhanSo { private int _TuSo; private int _MauSo; private static int Dem = 0;//Bien dem so luong phan so da duoc tao //Properties------------------------------------------------------ public int TuSo { get { return _TuSo; } set { _TuSo = value; } } public int MauSo { get { return _MauSo; } set { if (value == 0) _MauSo = 1; else _MauSo = value; } } //Constructors----------------------------------------------------- public PhanSo() { _TuSo = 1; _MauSo = 1; Dem++; } public PhanSo(int So) { _TuSo = So; _MauSo = 1; Dem++; }


public PhanSo(int Tu, int Mau) { _TuSo = Tu; //Neu mau so = 0 thi nem loi ra if (Mau == 0) throw new Exception("Khong khoi tao duoc phan so,

mau so phai khac 0."); else _MauSo = Mau; Dem++; } //Methods---------------------------------------------------------- //Xuat phan so public string Xuat() { return _TuSo.ToString() + "/" + _MauSo.ToString(); } //Su dung static public static int XuatSoLuongPhanSo() { return Dem; } //Su dung operator public static PhanSo operator +(PhanSo a, PhanSo b) { PhanSo KetQua = new PhanSo(); KetQua.TuSo = a.TuSo * b.MauSo + b.TuSo * a.MauSo; KetQua.MauSo = a.MauSo * b.MauSo; return KetQua; } }//End Class PhanSo class Program { static void Main(string[] args) { try { //Tao cac doi tuong cua lop phan so PhanSo PhanSo1 = new PhanSo(1, 2); PhanSo PhanSo2 = new PhanSo(3, 2); PhanSo PhanSo3 = new PhanSo(5); //Xuat cac phan so Console.WriteLine("Phan so thu nhat la: " + PhanSo1.Xuat()); Console.WriteLine("Phan so thu hai la: " + PhanSo2.Xuat()); Console.WriteLine("Phan so thu ba la: " + PhanSo3.Xuat()); //Xuat so luong cac phan so da tao //Luu y: Khong can khoi tao doi tuong khi truy cap phuong thuc static int SoLuongPhanSo = PhanSo.XuatSoLuongPhanSo(); Console.WriteLine("So luong phan so da tao: {0}", SoLuongPhanSo); //Tinh tong 2 phan so, su dung operator PhanSo Tong = PhanSo1 + PhanSo2; Console.WriteLine(PhanSo1.Xuat() + " + " + PhanSo2.Xuat() + "=" + Tong.Xuat()); }


catch (Exception ex) { Console.WriteLine("Loi! " + ex.Message); } } } }//End

Tính đóng gói – Encapsulation: The process of hiding all the internal details of an object from the outside world. namespace Phan2_TinhDongGoi { class A { private int MyPrivate = 0; protected int MyProtected = 0; public int MyPublic = 0; public void MyMethodA() { MyPrivate = 10;//OK! (1) MyProtected = 10;//OK!(2) MyPublic = 10;//OK!(3) } } class B : A { public void MyMethodB() { //MyPrivate = 100;//Error! (4) MyProtected = 100;//OK! (5) MyPublic = 100;//OK! (6) } } class Program { static void Main(string[] args) { A a = new A(); //a.MyPrivate = 10;//Error (7) //a.MyProtected = 10;//Error (8) a.MyPublic = 10;//OK! (9) } } } Kết luận:

o Từ (1)(4)(7) => Private chỉ trong nội bộ class A. o Từ (2)(5)(8) => Protected chỉ trong nội bộ class A và các class kế thừa nó. o Từ (3)(6)(9) => Public truy xuất bất kì nơi đâu đều được. o Internal chỉ được truy xuất trong phạm vi file DLL o Protected Internal được truy xuất trong phạm vi file DLL và lớp kế thừa.


Tính kế thừa - Inheritance, Tính đa hình - Polymorphism

namespace Phan3_KeThua2 { class Shape { protected string _Name; //Properties public string Name { get { return _Name; } set { _Name = value; } } //Methods public virtual float Area() { return 0; } } class Rectangle : Shape { protected float _Width; protected float _Height; //Properties public float Width { get { return _Width; } set { _Width = value; } } public float Height { get { return _Height; } set { _Height = value; } } //Constructors public Rectangle() { _Width = _Height = 0; }


public Rectangle(string name, int width, int height) { _Name = name; _Width = width; _Height = height; } //Methods public override float Area() { return Width * Height; } } class Square : Rectangle { //Properties public float Side { get { return _Width; } set { _Width = _Height = value; } } //Constructors public Square(string name, float side) { _Name = name; Side = side; } } class Circle : Shape { protected float _R; //Properties public float R { get { return _R; } set { _R = value; } } //Constructors public Circle(string name, float r) { _Name = name; _R = r; } //Methods public override float Area() { return (float)Math.PI * R * R; } }


class Program { static void Main(string[] args) { Shape[] MyShapes = new Shape[] {new Rectangle("Rectangle",50,20), new Square("Square",50), new Circle("Circle",20)}; foreach (Shape s in MyShapes) { Console.WriteLine("Name: " + s.Name); Console.WriteLine("Area: " + s.Area().ToString()); } } } }

Tính trừu tượng - abstract classes Following are features of a abstract class :

o You can not create a object of abstract class o Abstract class is designed to act as a base class (to be inherited by other classes). o Abstract class is a design concept in program development and provides a base upon which other

classes are built. o Abstract classes are similar to interfaces: After declaring an abstract class, it can not be instantiated

on it's own, it must be inherited. o Abstract classes are different to interfaces: Abstract classes can have implementation or pure abstract

methods which should be implemented in the child class. namespace Phan4_TinhTruuTuong { class Point { //Fields private int _X; private int _Y; //Properties public int X { get { return _X; } set { _X = value; } } public int Y { get { return _Y; } set { _Y = value; } } //Constructors public Point(int x, int y) { _X = x; _Y = y; } //Methods public string Output() { return "(" + _X.ToString() + "," + _Y.ToString() + ")"; } }


abstract class AShape { //Properties public abstract Point Center { get; set; } //MeThods

//This method must be implemented at child class public abstract float Area(); //Abstract class: This method can be used by child class object //But Interface class can not

//because all method at Interface must be implemented public void WriteAString() { Console.WriteLine("Hello! this is a method at abstract class"); } } class Rectangle : AShape { private Point _TopLeft; private int _Width; private int _Height; //Constructors public Rectangle(Point topLeft, int width, int height) { _TopLeft = topLeft; _Width = width; _Height = height; } //Properties public Point TopLeft { get { return _TopLeft; } set { _TopLeft = value; } } public int Width { get { return _Width; } set { _Width = value; } } public int Height { get { return _Height; } set { _Height = value; } } //This property is override the Center property at abstract class AShape public override Point Center { get { return new Point(TopLeft.X + Width / 2, TopLeft.Y + Height / 2); } set{} }


//Methods-This method is override the Area method at abstract class AShape public override float Area() { return Width * Height; } } class Circle : AShape { private Point _Center; private float _R; //Properties public float R { get { return _R; } set {_R = value;} } public override Point Center { get { return _Center; } set { _Center = value; } } //Constructors public Circle(Point center, float r) { _Center = center; _R = r; } //Mehthods public override float Area() { return (float) (Math.PI * R * R); } } class Program { static void Main(string[] args) { Point MyPoint = new Point(0,0); Rectangle R = new Rectangle(MyPoint,50,30); Circle C = new Circle(MyPoint, 40); Console.WriteLine("Center of the rectangle: " + R.Center.Output()); Console.WriteLine("Center of the circle: " + C.Center.Output()); Console.WriteLine("Area of the rectangle: " + R.Area()); Console.WriteLine("Area of the circle: " + C.Area()); R.WriteAString(); C.WriteAString(); } } }


Giao diện – Interfaces Following are features of a abstract class :

o Single Class can implement multiple interfaces. o If a class implements a interface then it has to provide implementation to all its methods.

namespace Phan5_GiaoDien { interface IMyInterface { void WriteName(); } class Person : IMyInterface { private string Name; public Person(string name) { Name = name; } public void WriteName() { Console.WriteLine(Name); } } class Building : IMyInterface { private string Name; public Building(string name) { Name = name; } public void WriteName() { Console.WriteLine(Name); } } class Program { static void Main(string[] args) { IMyInterface[] School = new IMyInterface[]

{ new Person("Phuc"), new Building("I Buiding") }; foreach (IMyInterface I in School) { Console.Write(I.GetType().Name.ToString() + ": "); I.WriteName(); } } } }


Delegate: Delegate is a class that can hold a reference to a method or a function.Delegate class has a signature and it can only reference those methods whose signature is compliant with the class.Delegates are type-safe functions pointers or callbacks. namespace Phan6_Delegate { //Khai bao delegate delegate int pFunction(int a, int b); class TestDelegate { public int Add(int a, int b) { return a + b; } public int Mul(int a, int b) { return a * b; } } class Program { static void Main(string[] args) { int a = 10; int b = 20; pFunction p;// Tao bien delegate TestDelegate t = new TestDelegate(); //Su dung delegate p = new pFunction(t.Add); Console.WriteLine(p(a,b).ToString()); p = new pFunction(t.Mul); Console.WriteLine(p(a,b).ToString()); //Kết luận: //Khái niệm delegate tương tự như con trỏ hàm. //Ưu điểm của Delegate đó là tính khả biến của nó. //Có thể gọi bất cứ phương thức nào có 2 đối số int và trả về trị int. } } }


Event: As compares to delegates events works with source and listener methodology . So listener’s who are interested in receiving some events they subscribe to the source.Once this subscription is done the source raises events to all of it’s listener when needed.One source can have multiple listeners. namespace Tuan8_Event { class MyClass { //Khai bao delegate public delegate void MyDelegate(string Message); //Khai bao su kien public event MyDelegate MyEvent; public void RaiseEvent(string Message) { if(MyEvent!=null) MyEvent(Message); } } class Program { static void Main(string[] args) { //Tao the hien cua class MyClass ShowMessage = new MyClass(); //Goi su kien cho doi tuong ShowMessage ShowMessage.MyEvent += new MyClass.MyDelegate(ShowMessage_MyEvent); string Message = Console.ReadLine(); ShowMessage.RaiseEvent(Message); } //Ham duoc delegate static void ShowMessage_MyEvent(string Message) { Console.WriteLine("Your message is: {0}",Message); } } }

Documents

CSharp OOP.pdf