// See https://aka.ms/new-console-template for more information
using System;
namespace HelloWorldApplication
{
/*
* 虚方法：
* 声明为virtral的就是虚方法。基类的虚方法可以在派生类中使用override进行重写。
* 重写虚方法必须具有相同的可访问性，且基类方法不能是private
* 不能重写static方法或非虚方法
* 方法，属性，索引器，事件，都可以声明为virtral或override
*
* 多态：
* 通过指向派生类的基类调用，调用虚方法，会根据引用所指向派生类的实际类型，调用派生类中同名重写的函数，即是多态。
*
* 抽象方法：
* 必须是方法，属性，事件，索引
* 必须用abstract修饰符标记
* 不能有实现代码块
*
* 抽象类：
* 抽象类的存在目的是被继承
* 不能实例化，用abstract修饰
* 可以包含抽象成员和普通成员，以及任意组合
* 抽象类的抽象成员在派生类中需要用override关键字实现
*
* 密闭类：
* 声明为sealed的类
* 有些类不希望被其他人通过继承来修改
*
* 密闭方法：
* 声明为sealed的方法
* 不希望其他人来重写该方法
* 如果一个基类方法不希望子类对其重写，就可以不声明为virtual
* 如果是某个派生类方法不希望子类对其重写，同时是override重写,就可以使用sealed机制
*
* 接口：
* 指定一组函数成员，而不实现他们的引用类型
* 定义接口不能写public，但默认是public类型
*
* 结构和类：
* 结构是值类型（栈中），类是引用类型（堆中）
* 结构不支持继承，类支持继承
* 结构不能定义默认构造函数，编译器会定义
* 适用场合：
* 结构：由于分配内存快，作用域结束即被删除，不需要垃圾回收机制，用于小型数据结构。
* 但传递过程中会复制，应该使用ref提高效率。
* 类：用于其他的需要继承体系的场合
*
* 静态成员：标识为static的字段，方法，属性，构造函数，事件。
* 被类的所有实例共享，所有实例访问同一个内存地址
* 生存期：独立于任何实例，没有实例也可以访问。
* 其初始化语句在任何静态成员使用之前调用
*
* 静态函数成员：
* 独立于任何实例，没有实例也可以调用
* 不能访问实例成员，只能访问其他静态成员
*
* 静态构造函数：
* 可用于初始化静态字段
* 在引用任何静态成员之前，和创建任何实例之前调用
* 与类同名，使用static，无参数，无访问修饰符
*
* 静态类：
* 类只包含了静态的方法和属性，并标识为static
* 不能创建实例，不能被继承
* 可以为静态类定义一个静态构造函数
* 用于基础类库（如数学库）或扩展方法
*
* 扩展方法的要求
* 扩展方法所属的类必须是static类
* 扩展方法本身必须是static方法
* 扩展方法的第一个参数类型，必须是this+类名
*
* 装箱：浅拷贝
* 根据值类型的值，在堆上创建一个完整的引用类型对象，并返回对象的引用，是一种隐式转换
* 有时候需要将值类型转化为引用类型（例如object)来进行统一的操作（例如作为函数的参数）和统一的存储（例object[])
* 在堆上创建引用类型的副本，新创建的引用类型和原本的值类型相互独立
*
* 拆箱：
* 将装箱后的对象转换成值类型的过程，是一种显示转换
*
* 自定义转换：
* 为自己的结构或类定义显示和隐式转换
* 隐式转换：public static implicit operator Dog(Cat cat) 目标类型（原类型）
* 显示转换：public static explicit operatir Dog(Cat cat)
*
* 重载运算符：
* 利用现有的某种运算符，针对自定义类或结构，定义某种运算符
*
* 泛型类：class Cage
* 就是一个模子，装入类型的材料，可以塑造想要的产品
* 易于维护，修改模板，所有的实例都会被改变
* 只有需要的类型才会被实例化
*
* 泛型方法：
* 就是方法的模型，给定具体的类型，就可以实例化出一个操作该类型的具体方法
*
* 泛型接口：
* 允许我们将接口成员的参数和返回类型设置成为泛型参数的接口
*
* 约束：
* 缩小泛型参数的范围
* 只有添加了约束，才能调用泛型参数中(比如T)的方法
*
* 集合：
* 动态数组：ArrayList 列表：List 字典：Dictionary
* 队列：Queue 栈：Stack
*
* 动态数组 ArrayList：
* 初始化可以不指定大小
* 获取长度，使用Count属性
* 添加Add，删除Remove,RemoveAt，访问[index]
* 类型不安全，有装箱拆箱的性能问题，于是出现了List
*
* 字典 Dictionary：
* 存储的是一系列的键值对
* 数量 Count 添加 Add(key,value) 删除 Remove 访问 [key]
*
* 栈 Stack：
* 出栈 Pop 入栈 Push 获取栈顶元素 Peek
*
* 队列 Queue：
* 出队 Dequeue 入队 enqueue
*
* 委托：
* 持有一个或者多个方法的对象，并且该方法可以执行，传递
*
* 声明委托方法：
* 可以声明，是一种引用类型 delegate void ActCute();
*
* Lambda 表达式
* del = delegate(){} del = ()=>{}
*
* 事件：
* 发布者：通知事件发生的
* 订阅者：对某件事情关注的
* 事件触发：事件发生时，会通知所有关注该事件的订阅者
* 注册：想要在事件发生时被通知，必须注册以表示关注
*/
/*
struct fish
{
int weight;
int size;
int type;
}
*/
interface ICatchMice
{
void CatchMice();
}
interface ICimbTree
{
void CimbTree();
}
abstract public class Pet
{
public Pet(string name)
{
_name = name;
_age = 0;
}
// 受保护 让派生类可以访问
protected string _name;
protected int _age;
public void PrintName()
{
Console.WriteLine("宠物的名字是："+_name);
}
abstract public void Speak();
public void ShowAge()
{
Console.WriteLine(_name + "年龄是："+ _age);
}
public static Pet operator ++(Pet pet)
{
++pet._age;
return pet;
}
}
public class Cage
{
T[] array;
readonly int Size;
int num;
public Cage(int n)
{
Size = n;
array = new T[Size];
num = 0;
}
public void Putin(T pet)
{
if (num < Size)
{
array[num++] = pet;
}
else
{
Console.WriteLine("笼子已经装满了...");
}
}
public T TakeOut()
{
if (num > 0)
{
return array[--num];
}
else
{
Console.WriteLine("笼子是空的...");
return default(T);
}
}
}
public class Dog : Pet
{
static int Num;
// 委托
public delegate void Hander();
// 事件
public static event Hander NewDog;
static Dog()
{
Num = 0;
}
public Dog(string name) : base(name)
{
++Num;
if (NewDog != null)
{
NewDog();
}
}
// 隐藏基类方法
new public void PrintName()
{
Console.WriteLine("狗的名字是：" + _name);
}
sealed override public void Speak()
{
Console.WriteLine(_name + "在说话：汪汪");
}
static public void ShowNum()
{
Console.WriteLine("一共有" + Num + "只狗");
}
// 隐式转换
public static implicit operator Cat(Dog dog)
{
return new Cat(dog._name);
}
// 泛型方法
public void IsHappy(T target) where T : Pet
{
Console.WriteLine("很开心看到");
target.PrintName();
}
public void WagTail()
{
Console.WriteLine(_name + "摇尾巴");
}
}
public abstract class DogCmd
{
public abstract string GetCmd();
}
public class SitDogCmd : DogCmd
{
public override string GetCmd()
{
return "坐下";
}
}
public interface IDogLearn where C : DogCmd
{
void Act(C cmd);
}
public class Labrador : Dog, IDogLearn
{
public Labrador(string name):base(name)
{
}
public void Act(SitDogCmd cmd)
{
Console.WriteLine(cmd.GetCmd());
}
}
static class PetGuide
{
static public void HowToFeedDog(this Dog dog)
{
Console.WriteLine("喂养一条狗");
}
}
public class Cat : Pet, ICatchMice, ICimbTree
{
public Cat(string name) : base (name)
{
}
public override void Speak()
{
Console.WriteLine(_name + "在说话：喵喵");
}
public void CatchMice()
{
Console.WriteLine(_name + "在抓老鼠");
}
public void CimbTree()
{
Console.WriteLine(_name + "在爬树");
}
public static explicit operator Dog(Cat cat)
{
return new Dog(cat._name);
}
public void InnocentLook()
{
Console.WriteLine(_name + "看着你");
}
}
class Person
{
}
class Client
{
public void WantDog()
{
Console.WriteLine("有一条新的狗...");
}
}
class HelloWorld
{
// 委托
delegate void ActCute();
static void Main(string[] args)
{
ActCute del = null;
Dog d1 = new Dog("d1");
Cat c1 = new Cat("C1");
del = d1.WagTail;
del += c1.InnocentLook;
del += () =>
{
Console.WriteLine("Lambda表达式");
};
del();
Pet[] pets = new Pet[] {new Dog("小狗"),new Cat("小猫"),new Dog("小白狗")};
for(int k=0;k(1);
dogCage.Putin(new Dog("小狗一号"));
dogCage.Putin(new Dog("小狗二号"));
var dogC = dogCage.TakeOut();
dogC.PrintName();
Dog dog3 = new Dog("哈士奇");
//dog3.IsHappy(2);
dog3.IsHappy(new Cat("英短"));
Labrador labrador = new Labrador("拉不拉多");
labrador.Act(new SitDogCmd());
List list = new List();
list.Add(new Dog("小黑"));
list.Add(new Dog("小花"));
list.Add(new Dog("小白"));
list.RemoveAt(1);
for (int p = 0; p < list.Count; p++)
{
list[p].PrintName();
}
Dictionary dic = new Dictionary();
dic.Add("A",new Dog("A1"));
dic["A"].PrintName();
Stack st = new Stack();
st.Push(new Dog("a"));
st.Push(new Dog("b"));
st.Peek().PrintName();
Queue qu = new Queue();
qu.Enqueue(new Dog("q1"));
qu.Enqueue(new Dog("q2"));
Pet pe = null;
pe = qu.Dequeue();
pe.PrintName();
Client cl1 = new Client();
Client cl2 = new Client();
Dog.NewDog += cl1.WantDog;
Dog.NewDog += cl2.WantDog;
Dog dogs = new Dog("大狗");
/*
Pet dog = new Dog();
dog._name = "小狗";
dog.PrintName();
dog.Speak();
Pet cat = new Cat();
cat._name = "小猫";
cat.PrintName();
cat.Speak();
*/
}
}
}
运行结果
d1摇尾巴
C1看着你
Lambda表达式
小狗在说话：汪汪
小狗年龄是：1
小猫在说话：喵喵
小猫年龄是：1
小白狗在说话：汪汪
小白狗年龄是：1
小白猫在抓老鼠
小白猫在抓老鼠
小白猫在爬树
小白猫在爬树
一共有3只狗
喂养一条狗
i=3 ob=3
i=5 ob=6
j=6
比格在说话：汪汪
比格在说话：喵喵
宠物的名字是：比格
比格在说话：汪汪
笼子已经装满了...
狗的名字是：小狗一号
很开心看到
宠物的名字是：英短
坐下
狗的名字是：小黑
狗的名字是：小白
狗的名字是：A1
宠物的名字是：b
宠物的名字是：q1
有一条新的狗...
有一条新的狗...