C#三大特性的理解和使用

 

1.封装

 

Why：防止类中的数据被恶意修改

封装（what）：将类的某些信息隐藏在类内部(private)，不允许外部程序直接访问，而是通过该类提供的公共属性(public）来实现对隐藏信息的操作和访问

How：

快捷键：prop+TAB   propfull+TAB

//这种封装不能修改属性的限制  prop+TAB

2、案例

     出生年龄必须大于0

  //public int Age { get; set; }

        //这种封装可以修改属性的限制 propfull+TAB

        private int age;//private：私有  成员变量

        public int Age  //public：公共  属性

        {

            get { return age; }

            set {

                if (value> 0)

                {

                    age = value;

                }

                else

                {

                    Console.WriteLine("年龄必须大于等于0");

                }

            }

        }

When：当别人想恶意修改数据时

3、封装的好处

1、隐藏类的实现细节

2、只能通过规定属性访问数据

3、方便加入控制语句

4、方便修改实现

2.继承

1. 定义

Why：加减   加除    乘除 减乘计算器  

解决功能重复问题

继承：一个类具有另一个类的属性和方法，这个类叫子类（派生类），另一个类叫父类（基类、超类）

继承的关键符号   ：（冒号）

    class Father

    {

        public string nose = "大鼻子";

        public void Smoking()

        {

            Console.WriteLine("烟鬼");

        }

public Father()

        {

            Console.WriteLine("我是父类");

}

}

class Son:Father

    {

        void Get()

        {

            Console.WriteLine(nose);

            Smoking();

           Console.WriteLine(base.nose);

base.Smoking();

        }

public Son(): base()//调用父类构造方法

        {

            Console.WriteLine("我是子类");

        }

}

特征：

    1、子类继承了父类的属性和方法（public、protected），但是构造方法不能被继承

    2、子类使用构造方法调用父类构造方法用 base()

    3、创建子类对象时，系统默认先调用父类构造方法，然后再调用子类构造方法

4、子类使用父类的属性和方法用  base 关键字（public、protected）

注意：

当父类有有参构造方法时，如果子类有构造方法（无参或有参），要求父类必须有一个无参构造方法。

如果子类没有构造方法，父类也需要提供一个无参构造方法。

如果不提供，子类构造方法会报错！

1. 重写(override)：

重写：在子类和父类中，子类中的方法名称和父类方法名称相同，参数相同

重载（overload）：在同一个类中，方法名称相同，参数不同（个数、类型），与返回值无关

public virtual void Eat()//虚方法

        {

            Console.WriteLine("吃白萝卜");

        }

public override void Eat()//重写方法

        {

            Console.WriteLine("吃肉");

        }

3、修饰符（访问权限）：

public（本类、外部类） private（本类） protected（本类 子类）    internal（本类 子类）

4、虚方法：virtual

在某基类中声明 virtual 并在一个或多个派生类中被重新定义的成员方法称为虚方法。

虚方法的作用就是实现多态性(Polymorphism)，多态性是将接口与实现进行分离。

在基类的函数中声明关键字virtual，就可以在其派生类中通过关键字override重写该方法。重写后的virtual方法依旧是virtual方法。

当有一个定义在类中的方法需要在继承类中实现时，可以使用虚方法。

运行结果：

Fun In A

Fun In B

Fun In B

Fun In A

Fun In D

面试题：

class Program

{

    class A

    {

        public A()

        {

            PrintFields();

        }

        public virtual void PrintFields() { }

    }

    class B : A

    {

        int x = 1;

        int y;

 

        public B()

        {

            y = -1;

        }

 

        public override void PrintFields()

        {

            Console.WriteLine("x={0},y={1}", x, y);

        }

    }

 

    static void Main(string[] args)

    {

        new B().PrintFields();             

    }

}

运行结果：

x=1，y=0

创建B的实例，先隐式调用父类A的无参构造方法，执行PrintFields()方法，检查到是虚方法，转去检查实例类B，有重写方法，执行重写方法，输出x=1,y=0

5、虚方法与一般方法的区别

1、写法不同

2、一般方法在编译时就静态地编译到了执行文件中，其相对地址在程序运行期间是不发生变化的，也就是写死的！而虚方法在编译期间是不被静态编译的，它的相对地址是不确定的，它会根据运行时期对象实例来动态判断要调用的方法。

6、sealed关键字

C#提供了一个sealed 修饰符，此修饰符会阻止其他类从该类继承。

7、使用继承的好处

（1）继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。（拓展新功能）

（2）继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。

（3）继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

（4）继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。

3.多态

1. 定义

Why：

对重复代码频繁修改，代码可扩展性、可维护性差，如何优化？

多态（what）：多态是同一个行为具有多个不同表现形式或形态的能力。

多人做一件事情，结果不一样

多态性可以是静态的或动态的。在静态多态性中，方法的响应是在编译时发生的。在动态多态性中，方法的响应是在运行时发生的。

静态多态性：在编译时，方法和对象的连接机制被称为早期绑定，也被称为静态绑定。C# 提供了两种技术来实现静态多态性。分别为：方法重载、运算符重载

动态多态性是通过 抽象类 和 虚方法 实现的。

1. 实现多态的两个要素（how）：

1）子类重写父类方法

2）使用父类的类型（子类转换为父类：向上转型）

class Animal

{

        public virtual void call() {

Console.WriteLine("无声的叫唤");

}

}

class Dog : Animal

 {

        // new的作用是隐藏父类的同名方法

        //public new void call() {

//Console.WriteLine("叫声：汪～汪～汪～");

//}         

        public override  void call() {

Console.WriteLine("叫声：汪～汪～汪～");

}

        public void smell() {

Console.WriteLine("嗅觉相当不错！");

}

 }

Animal animal = new Dog(); //向上转型

animal.call();

 向上转型：将子类对象转为父类对象。此处父类对象可以是接口或抽象类。

转化后的父类对象具有父类所有方法，若方法被子类重写override，那么实际调用时，调用的是重写后的实现。

    int a=(int)3.5;

Dog dog = (Dog)animal;//向下转型

dog.call();                

dog.smell();

 向下转型：把父类对象转为子类对象。

    转化后的子类对象，跟一般的继承子类对象一样。具有子类所有方法(包括重写方法)+父类所有方法(被重写的方法，按重写的算。)

3、案例

public class Shape

{

    public int X { get; private set; }

    public int Y { get; private set; }

    public int Height { get; set; }

    public int Width { get; set; }

   

    // 虚方法

    public virtual void Draw()

    {

        Console.WriteLine("执行基类的画图任务");

    }

}

​

class Circle : Shape

{

    public override void Draw()

    {

        base.Draw();

        Console.WriteLine("画一个圆形");

    }

}

class Rectangle : Shape

{

    public override void Draw()

    {

        base.Draw();

        Console.WriteLine("画一个长方形");

    }

}

class Triangle : Shape

{

    public override void Draw()

    {

        base.Draw();

        Console.WriteLine("画一个三角形");

    }

}

​

class Program

{

    static void Main(string[] args)

    {

        Shape circle=new Circle();

        circle.Draw();

        Shape rectangle=new Rectangle();

        rectangle.Draw();

        Shape triangle=new Triangle();

        triangle.Draw();

    }

}

父类做返回值

class Person

    {

        public virtual void Eat()

        {

        }

}

class WhitePerson:Person

    {

        public override void Eat()

        {

            Console.WriteLine("热狗");

        }

 }

class YellowPerson:Person

    {

        public override void Eat()

        {

            Console.WriteLine("饺子");

        }

        //写一个GetPerson方法，返回值为父类，

        //根据传入的不同人种来确定吃什么

       Person GetPerson(string s)

        {

            Person p=null;

            if (s.Equals("中国人"))

            {

                p = new YellowPerson();

            }

            else if (s.Equals("外国人"))

            {

                p= new WhitePerson();

            }

            else

            {

                return p;

            }

            p.Eat();

            return p;

        }

}

父类做参数

class Animal

    {

        public virtual void Swimming()

        {

            Console.WriteLine("动物游泳");

        }

}

class Cat:Animal

    {

        public override void Swimming()

        {

            Console.WriteLine("猫挠");

        }

        //写一个方法，完成动物游泳（对象做参数）

        void GetSwimming(Animal a)//a是引用

        {

            if (a is Cat)

            {

                Cat c = (Cat)a;//向下转型

                c.Swimming();

            }

        }

        static void Main(string[] args)

        {

            Cat c = new Cat();

            Dog d = new Dog();

            Animal a = c;

           // Animal a = d;

            c.GetSwimming(a);

        }

    }

4、使用多态的好处

1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的

可复用性。//继承 
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护

性。 //多态的真正作用

5、string类

==和Equals的区别

1、值类型

==和Equals比较的内容都是一致的，都是比较内容

string a = "123";//值

            Console.WriteLine(a=="123");

            Console.WriteLine(a.Equals("123"));

2、引用类型

==：  比较首地址是否相等  Equals：比较的是值是否相等

char[] x={'1','2','3'};

            string b = new string(x);//引用

            Console.WriteLine(b=="123");

   Console.WriteLine(b.Equals("123"));

1）字符串的比较

Compare(str1, str2)

str1.CompareTo(str2)

string a = "hello",b="Hello",c="hello";

            Console.WriteLine(a.CompareTo(b));//-1

            Console.WriteLine(string.Compare(a,b));//-1

   Console.WriteLine(a.CompareTo(c));//0

1. 字符串的查找

(1)Contains(Findstr)：找指定字符串是否包含一个字串Findstr，返回值的bool类型，即只有

true和false。

(2)、IndexOf(Findstr)：查找FindStr在字符串中第一次出现的位置，返回值为第一次出现

的下标，没有找到则返回-1.

(3)、LastIndexOf(FindStr)：查找FindStr在字符串中最后一次出现的位置，返回值为最后

一次出现的下标，没有找到则返回-1。

Console.WriteLine(a.Contains("lo"));//true

            Console.WriteLine(a.IndexOf('e'));//1

    Console.WriteLine(a.LastIndexOf('l'));//3

1. 字符串的截取

SubString(StartIndex)：字符串中下标从StartIndex开始后面的全部字符串。

SubString(StartIndex, Len)：字符串中下标从StartIndex开始后面的Len个长度的字符串。

Console.WriteLine(a.Substring(1));//ello

         Console.WriteLine(a.Substring(1,3));//ell

1. 字符串的分割

Split(SplitCh)：将字符串按SplitCh进行分割，它的返回值是一个字符串数组。

string d="锄禾日当午#汗滴禾下土#谁知盘中餐#粒粒皆辛苦";

            string[] e = d.Split('#');

            for (int i = 0; i < e.Length; i++)

            {

                Console.WriteLine(e[i]);

    }

1. 字符串的合并

string.Concat(str1, str2, …., strn)：将n个字符串连接，中间没有连接符

“+”连接符号

string f = "world";

            Console.WriteLine(a+f);

            Console.WriteLine(1+2+3+a);//6hello

            Console.WriteLine(a+1+2+3);//hello123

   Console.WriteLine(string.Concat(a,f));//helloworld

1. 字符串的替换

Replace(oldStr, newStr)：用newStr来替换字符串中的oldStr

Console.WriteLine(a.Replace("he","HE"));//HEllo

1. 字符串的插入

Insert(index, str)：index是需要插入的位置，str是要插入的字符

Console.WriteLine(a.Insert(1,"ww"));//hwwello

1. 字符串的删除

Trim()：删除字符串中开始和结尾处的空格

Remove(Start)：Start为需要删除的起始位置，该方法是将位置后的所有字符全部删除
         Remove(Start, Len)：Len是指需要删除的长度，与上面格式不同的是它是从起始位置开始

删除Len个字符

string s = " aaa bbb ccc ";

            Console.WriteLine(s.Trim());//aaa bbb ccc

            Console.WriteLine(s.Remove(6));// aaa b

   Console.WriteLine(s.Remove(2,7));// aaccc

9）字符串的大小写转换
                  ToLower()：将字符串转化为小写形式
                  ToUpper()：将字符串转换威大写形式

10）string.Format()

string.Format("{0:d}",System.DateTime.Now) //结果为：2021-3-23 （月份位置不是03）

string.Format("{0:D}",System.DateTime.Now) //结果为：2021年3月23日

string.Format("{0:f}",System.DateTime.Now) //结果为：2021年3月23日 15:37

string.Format("{0:F}",System.DateTime.Now) //结果为：2021年3月23日 15:37:52

string.Format("{0:g}",System.DateTime.Now) //结果为：2021-3-23 15:38

string.Format("{0:G}",System.DateTime.Now) //结果为：2021-3-23 15:39:27

string.Format("{0:m}",System.DateTime.Now) //结果为：3月23日

string.Format("{0:t}",System.DateTime.Now) //结果为：15:41

string.Format("{0:T}",System.DateTime.Now) //结果为：15:41:50