C#基础-类

1.C#的是单继承，接口可以多继承（这是两个概念）。当定义的类没有被 Extends 指定父类，默认从 Object 类继承而来。

#基本类
class Posen
{
    //默认构造函数和析构函数，编译器都有默认的.当类被实例话，先执行构造函数，释放时执行析构函数，当实例化时，先执行父类构造函数->子类构造函数，当释放时：子类析构函数->父类析构函数。
    //Posen(); 默认构造函数，初始化变量
    //~Posen();析构函数，释放内存
    private int len = 10;   // 成员变量
    
    pubile int readLen()    // 成员方法
    {
        return len;
    }
    
    // 虚函数 virtual 关键字不能修饰使用 static 修饰的成员
    pubilc virtual doubel Are()
    {
        return 2*len
    }
    
}


class Techno: Posen
{
    pubilc int num = 20;
    // pubile int readLen() 从父类集成方法
    
//静态方法（Static Method）与静态成员变量一样，属于类本身，在类装载的时候被装载到内存（Memory），不自动进行销毁，会一直存在于内存中，直到JVM关闭，因此不用对象实例可以直接被调用
//又叫实例化方法，属于实例对象，实例化后才会分配内存，必须通过类的实例来引用。不会常驻内存，当实例对象被JVM回收之后，也跟着消失
    public static string str = "hello"; // 静态成员变量
    public static string Speak () // 静态方法
    {
        // this->num = 1; err 不能访问成员变量
        return str;
    }

    pubile int readNum(int n)    // 成员方法
    {
        this->num = 2* this->num;
        return num;
    }

    // 重写父类方法
    pubilc override doubel Are()
    {
        return num*len
    }
}

static void Main(string[] args)
{
    Posen.str = "hi"; // 不用实例化 可以直接被当前类访问
    Poson poson = new Poson();
    Techno techno = new techno();
    poson.readLen();    // 10
    techno.readLen();    // 10 调用父类 也就是base,但是重写了父类方法 可以用base.方法()调用父类，this是当前类指针，也可以认为是单独实例化对象
    techno.readNum(2);    // 20
}

#abstract 抽象类 只提供接口声明，实现由子类实现
#sealed 密封方法不能被继承，密封方法不能被重写,密封方法必须出现在子类中，并且是子类重写的父类方法，即 sealed 关键字必须与 override 关键字一起使用

public abstract class people
{    
    public void eat();
    public void speak();
    public abstract void pick();
}

public class man: people
{
    public void eat();
    {
        return "man eat";
    }
    
    public void speak()
    {
         return "man speak";
    }
    
    public sealed override void pick()
    {
        return "man pick";
    }
}

public class woman: people
{
    public void eat();
    {
        return "woman eat";
    }
    
    public void speak()
    {
         return "woman speak";
    }

    public sealed void pick()
    {
        return "woman pick";
    }
}

#多态
// 使用继承实现多态必须满足以下两个条件。
//1. 子类在继承父类时必须有重写的父类的方法。
//2. 在调用重写的方法时，必须创建父类的对象指向子类(即子类转换成父类)。

class Program
{
    static void Main(string[] args)
    {
        Major major1 = new Undergraduate();
        major1.Id = 1;
        major1.Name = "张晓";
        Console.WriteLine("本科生信息：");
        Console.WriteLine("学号：" + major1.Id + "姓名：" + major1.Name);
        major1.Requirement();
        Major major2 = new Graduate();
        major2.Id = 2;
        major2.Name = "李明";
        Console.WriteLine("研究生信息：");
        Console.WriteLine("学号：" + major2.Id + "姓名：" + major2.Name);
        major2.Requirement();
    }
}
abstract class Major
{
    public int Id { get; set; }
    public string Name { get; set; }
    public abstract void Requirement();
}
class Undergraduate: Major
{
    public override void Requirement()
    {
        Console.WriteLine("本科生学制4年，必须修满48学分");
    }
}
class Graduate: Major
{
    public override void Requirement()
    {
        Console.WriteLine("研究生学制3年，必须修满32学分");
    }
}

#接口
1.C#的接口是可以多继承
2.用interface声明，常用I开头

interface IName
{
    void setName();
}
interface IAge
{
    void setAge();
}

class xiaoming: name
{
    void Sex()
    void setName()
    {
        Console.WriteLine("wo shi xiao ming");
    }

    void setAge()
    {
        Console.WriteLine("wo shi 6 sui");
    }
}

class xiaohua: IName,IAge
{
    void Sex();
    void setName()
    {
        Console.WriteLine("wo shi xiao hua");
    }
    void setAge()
    {
        Console.WriteLine("wo shi 8 sui");
    }
}