C# 面向对象基础&封装&继承&多态&加深一下冒泡排序写法

（一）面向对象是什么?

面向对象是一种编程思想

（二）为什么要用面向对象?

1、结构清晰

2、易于维护

3、方便扩展

（三）new一个对象是什么过程？

实例化
构造函数

创建对象的过程就是将类实例化的过程
实例化的过程就是执行构造函数的过程
构造函数的执行一定是在创建类的第一步完成

（四）访问修饰符有哪些？

pubilc        公共的，可以在任何位置使用

private      私有的，只有内部才可以使用

internal     默认的，同一个命名空间可以使用

protected  被保护的，同一个继承关系下才可以使用

（五）命名空间  程序集

namespace   加名字（如果继承必须起同一个名或者在上面调用using+空间名字）

（六）封装

类与Main函数

在同一个命名空间下，新建一个类

可以直接在新建类里面写入大框架，调用的时候直接在Main函数里面调用即可（除了private不能被调用以外其他的可以被调用）

比如：

  class Student
    {
        private string _Name;//成员变量姓名
        public string Name//属性
        {
            get{ return _Name; }//获取
            set { _Name = value; }//接收
        }
        private bool _Sex;
        public bool Sex
        {
            get { return _Sex; }
            set { _Sex = value; }
        }

        public string Sexs
        {
            get { return _Sex ? "男" : "女"; }
            set
            {
                if (value == "男")
                    _Sex = true;
                else
                    _Sex = false;
            }
        }
        private int _Chengji;
        public int Chengji
        {
            get { return _Chengji; }
            set { _Chengji = value; }
        }
    }

调用方法

class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student();
            s.Name = "张三";
            s.Sexs = "男";
            s.Chengji = ;
            Console.WriteLine(s.Name+s.Sexs+s.Chengji);
            Console.ReadKey();
        }
    }

（七）继承

类名：父类名

子类可以继承父类所有的公共方法和属性

一个子类只能有一个亲父类

一个父类可以有无数个后辈类

有多种叫法

父类、基类

子类、派生类、超类

基本格式

父类

  class Student
    {
        private string _Name;//成员变量姓名
        public string Name//属性
        {
            get{ return _Name; }//获取
            set { _Name = value; }//接收
        }
        private bool _Sex;
        public bool Sex
        {
            get { return _Sex; }
            set { _Sex = value; }
        }

        public string Sexs
        {
            get { return _Sex ? "男" : "女"; }
            set
            {
                if (value == "男")
                    _Sex = true;
                else
                    _Sex = false;
            }
        }
        private int _Chengji;
        public int Chengji
        {
            get { return _Chengji; }
            set { _Chengji = value; }
        }
    }

那么子类就可以

 class Fly:Student
    {
    }

（八）多态

比如父类里面有

 public class Fly
    {
        public  virtual string Flying()//virtual为虚方法
        {
            return "正在飞行";
        }
    }

子类可以修改里面内容

 public class Bird : Fly
    {
        public override string Flying()//override为重写
        {
            return "我飞的很高!!";
        }
    }

//一共有三种方法 , 父类里面virtual虚写后才可以用override重写
//当然还有overload重写

(九) 写一下冒泡排序加深一下印象

int[] a = new int[] { , , , ,  };
            for (int i = ; i < a.Length; i++)
            {
                for (int j = ; j < a.Length; j++)
                {
                    if (a[i] > a[j])
                    {
                        int tamp = a[i];
                        a[i] = a[j];
                        a[j] = tamp;
                    }
                }
            }
            foreach (int b in a)
            {
                Console.WriteLine(b);
            }
            Console.Read();