c#入门基础之面向对象

 C# 中常见的访问权限修饰符：

1. public：最高级别的访问权限修饰符，表示成员对所有代码都可见，无限制地访问。

2. private：最低级别的访问权限修饰符，表示成员只能在声明它的类内部访问，对于类的外部代码是不可见的。

3. protected：表示成员对于声明它的类以及该类的派生类可见。它只能在继承体系内部访问。

4. internal：表示成员对于同一程序集中的所有代码可见。这个修饰符通常用于库或模块内部，对于外部程序集是不可见的。

5. protected internal：表示成员对于同一程序集内的所有代码以及派生类可见。这是 protected 和 internal 的组合，允许在继承体系内和程序集内访问。

6. private protected：表示成员对于同一程序集内的派生类可见，但对于其他程序集或非派生类是不可见的。这是 C# 7.2 引入的修饰符。

C#的默认权限为internal，如果没有权限修饰符则默认的为整个项目可见

值类型默认值为0，引用类型默认值为null

var 匿名类型定义，在定义时必须赋值，它会根据你的值自动推断出类型

一般方法的关键词定义

[public/private/protected/internal] + [virtual/static/override/new] + 返回值类型

c#里面的javabean类定义

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1.dao
{
    public class Student
    {
        private string name="C#";//设置name为只读
        private string sex;

        public string Name
        {
            get { return name; }
            private set { name = value; }
        }
        public string Sex//包含一个隐藏的参数value，用于传值
        {
            get { return sex; }
            set { sex = value; }
        }
        public int Age
        {
            get;
            set;
        }


    }
}

using ConsoleApp1.dao;
using System;

namespace ConsoleApp1
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var stu = new Student();
            stu.Sex = "男";
            stu.Age = 11;
            Console.WriteLine(stu.Name+" "+stu.Sex+" "+stu.Age);
  
        }

    }
}

程序内存区域

栈:基本数据类型的数据，以及指向其余储存内数据的地址

堆:引用类型，数组里的数据

静态储存区:static描述的数据和字符串常量

总而言之就是栈保存除字符串外的普通数据值和堆以及静态储存区里储存值的地址

继承

子类:父类

this和base

this指向本类对象

base指向直辖父类对象

构造函数和析构函数:用于记载该类对象的生产和终结

和java一样无法继承多个类，但可以继承多个接口

虚方法

定义:

简单的说，虚方法就是可以被子类重写的方法，如果子类重写了虚方法，那么运行时将使用重写后的逻辑，如果没有重写，则使用父类中虚方法的逻辑。

定义关键字：virtual

重写关键字：override

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

代码示例

using System;

namespace ConsoleApp1
{
    internal class Program
    {
        public static void Main(string[] args)
        {
           Student stu = new StudentDao();
            stu.eat();
            stu.sport();

        }

    }
}
public class Student
{
    ~Student() { Console.WriteLine(this.GetType() + "已经删除"); }

    public virtual void eat()
    {
        Console.WriteLine("我要吃东西");
    }
    public virtual void sport()
    {
        Console.WriteLine("我要做运动");
    }

}
public class StudentDao : Student
{
    ~StudentDao() { Console.WriteLine(this.GetType() + "已经删除"); }
    public void eat()
    {
        Console.WriteLine("我要吃疯狂星期四");
    }
    public override void sport()
    {
        Console.WriteLine("我要去跑步");
    }
}

根据结果我们可以发现，如果没有重写方法则调用原来的父类的方法而重写完则调用子类的方法

new关键字表示隐藏父类的同名方法

抽象修饰符abstract

抽象类可以有普通方法但是普通类不能有抽象方法，抽象方法没有方法体

readonly用来描述只读属性

接口关键字和java一样为interface定义

泛型编程

在java利用像List,Map等类都是泛型类，而c++中stl库里面如vector,queue,stack等也是泛型编程

using System;


namespace ConsoleApp1
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            People<int> a = new People<int>();

            People<double> s = new People<double>();
            a.show();
            s.show();
        }

    }
    public class People<T>
    {
        private T people;
        public void show()
        {
            Console.WriteLine(people.GetType());
        }
    }
}