C#学习笔记

————Lesson1————
访问修饰符：
public
internal——只有同一namespace的才能访问
protected——只有继承于它的才能访问
private

————Lesson2————
1 结构和类的实例化
struct Person和class Person都可以用new Person()建立实例化对象

2 静态方法/静态成员
调用Person类的static方法getAge的方式为Person.getAge()，不用通过Person的一个实例化对象，static成员变量也是直接通过类而非实例化对象来调用

3 属性
Person类里的int属性Age最简单的创建方法：

public int Age{
	get;
	set;
}

person是Person的一个实例化对象，可以直接person.Age=10这样用，也可以直接Console.WriteLine(persin.Age)
也可以对属性Age的get、set方法做一些操作：

public int Age{
	get{
		return age+10;//age是Person的另一个成员变量
	}
	set{
		age=value-10;//value是用来赋值的值
	}
}

相比较成员变量而言，属性更加方便，因为直接写get、set，不用再写两个get和set方法

————Lesson3————
1 interface
只用写方法声明，不用写方法定义，方法的访问修饰符也不用写，实现它的类的对应的方法写就可以了。

2 抽象类
抽象类和接口一样，都不能被实例化，抽象类的作用是给其他类继承它。
抽象类里可以有成员变量、抽象或不抽象的方法，其中抽象方法写声明就可以

3 继承抽象类/接口的注意事项
可以继承多个类，但只能实现一个接口
某个类可以同时继承类与实现接口，并且必须写完整它继承的抽象类的抽象方法、接口的方法的定义

4 抽象类和接口的区别和联系

• 类a实现了接口A，则a必须补全A的所有方法的定义；类b继承了抽象类B，则b也必须补全B的所有抽象方法的定义
• 接口里有方法、属性、索引、事件，但不能有成员变量，抽象类里可以有类里有的所有东西
• 接口里的方法不需要abstract修饰符且不能有定义，抽象类的方法可以抽象也可以不抽象，其中抽象方法只有声明没有定义
• 某个类可以继承多个类，但只能实现一个接口

————Lesson4————
访问修饰符：
public——外部都能访问
internal——只有同一namespace的才能访问
protected——只有继承于它的才能访问
protected internal：只有继承于它的或同一个namespace的才能访问
private——外部都不能访问

————Lesson5————
1 sealed修饰符
应用于某个类时，sealed 修饰符可阻止其他类继承自该类。 在下面的示例中，类 B 继承自类 A，但没有类可以继承自类 B。

class A {}
sealed class B : A {}

2 子类new 和override方法的区别
如下，Dog是子类，Animal是父类，Dog里的Bite是override方法，BiteMan是new方法，Animal的Bite被override了，BiteMan就没有被override，Dog里的BiteMan是一个新的。
所以Animal dog3=new Dog();
dog3.Bite()调用Dog的
dog3.BiteMan()调用Animal的

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

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=====第一个 dog=====");
            Dog dog = new Dog();//调用顺序：先调用Animal的默认构造函数，再调用Dog的默认构造函数
            dog.Age = 10;
            dog.Bite();//输出dog bite
            dog.GetAge();//输出Animal age: 10
            dog.BiteMan();//输出dog bite man

            Console.WriteLine("=====第二个 dog=====");
            Dog dog2 = new Dog(10);//调用顺序：1.如果Dog的具体构造函数是a那样写——先调用Animal的默认构造函数，再调用Dog的具体构造函数；
                                     //2.如果Dog的具体构造函数是b那样写——先调用Animal的具体构造函数，再调用Dog的具体构造函数
                                     //3.如果Dog的具体构造函数是c那样写——先调用Animal的默认构造函数，再调用Dog的默认构造函数，再调用Dog的具体构造函数

            Console.WriteLine("=====第三个 dog=====");
            Animal dog3 = new Dog();//调用顺序：先调用Animal的默认构造函数，再调用Dog的默认构造函数
            dog3.Bite();//输出dog bite
            dog3.BiteMan();//输出Animal bite man，原因是Animal的BiteMan就没有被override，Dog里的BiteMan是一个新的
            ((Dog)dog3).BiteMan();//强制类型转换了，输出dog bite man

          
        }
    }

    class Animal
    {
        public int Age
        {
            get;
            set;
        }
        public Animal()
        {
            Console.WriteLine("Animal constructor");
        }
        public Animal(int age)
        {
            Console.WriteLine("Old animal");
            this.Age = age;
        }
        public virtual void Bite() { Console.WriteLine("Animal bite"); }
        public virtual void GetAge() { Console.WriteLine("Animal age: "+Age); }
        public void BiteMan() { Console.WriteLine("Animal bite man"); }
    }

    sealed class Dog : Animal
    {
        public Dog()
        {
            Console.WriteLine("Dog constructor");
        }
        //a.
        //public Dog(int age)
        //{
        //    Console.WriteLine("Old dog");
        //    this.Age = age;
        //}
        //b.
        //public Dog(int age):base(age)
        //{
        //    Console.WriteLine("Old dog");
        //    this.Age = age;
        //}
        //c.
        public Dog(int age) : this()
        {
            Console.WriteLine("Old dog");
            this.Age = age;
        }
        public override void Bite()
        {
            Console.WriteLine("dog bite");
        }
        public new void BiteMan() { Console.WriteLine("dog bite man"); }
    }
}