一个项目里面只有一个Main函数类

class1:

namespace ConsoleApp1012night
{
    internal class Class1
    {
        public class Person
        {
            public string name = "小明";
            public void Show()
            {
                Console.WriteLine("我叫{0}", name);
            }
        }
    }
}

using System.IO.Pipes;
using static ConsoleApp1012night.Class1;

namespace ConsoleApp1012night
{
    internal class Program
    {
        static void Main(string[] args)//一个项目里面只有一个Main函数类
        {
            Person xiaoming = new Person();
            xiaoming.Show();
        }
    }
}

怎么能够给父类的构造方法传值

创建一个子类

base可以帮助我们使用父类中的方法和属性

base关键字

●当我们使用继承的时候，可能子类中也会有相同的属性和方法,但是有的时候我们就想使父类中的属性和方法，这时候我们可以使用base关键字，base表示的就是父类，我们可以通过base.父类中的属性名来获取父类中的属性

using System.Diagnostics;
using System.IO.Pipes;
using static ConsoleApp1012night.Class1;

namespace ConsoleApp1012night
{
    //创建一个子类
    class Student : Person//怎么能够给父类的构造方法传值 base
    {
        public Student(string name1, int num1) : base(name1)
        {
            num = num1;
            play();
        }
        public int num;
        public string name = "小明";
        public void play()
        {
            name = base.name;//base可以帮助我们使用父类中的方法和属性
        }
        internal class Program
        {
            static void Main(string[] args)//一个项目里面只有一个Main函数类
            {
                Person xiaoming = new Person("小黑");
                xiaoming.Show();
                xiaoming.num = 5;
                Student student = new Student("小黑", 18);
                Console.WriteLine(student.name);
                Console.WriteLine(xiaoming.num);
            }
        }
    }
}

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

namespace ConsoleApp1012night
{
    //创建一个子类

    public class Person
    {

        public Person(string name1)
        {
            this.name = name1;
        }
        public string name = "小明";
        private int num1 = 2;
        public int num
        {
            get
            {
                if (num1 == 5) num1 = 1;
                return num1;
            }
            set
            {
                num1 = value * 2;
            }
        }
        public void Show()
        {
            Console.WriteLine("我叫{0}", name);
        }
    }
    internal class Class1
    {
    }
}

namespace Monster
{
    //怪物抽象类
    abstract class Monster
    {
        abstract public void attack1();//抽象方法
        public void getNum()
        {
            Console.WriteLine("老朋友");
        }
        
    }
    class Lianpo : Monster
    {
        public override void attack1()
        {
            Console.WriteLine("廉颇向前冲撞");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            //Monster monster1 = new Monster();//抽象类无法生成实例，只能被继承
            Lianpo Lianpo = new Lianpo();
            Lianpo.attack1();
        }
    }
}

sealed密封类

当我们创建的类不想被继承的时候，我们可以在类前面加sealed修饰符表示该类无法被继承

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

namespace Monster
{
    internal sealed class Sx//sealed密封类  当我们创建的类不想被继承的时候，我们可以在类前面加sealed修饰符表示该类无法被继承

    {
        protected string id = "1234";
        
        public void Show()
        {
            Console.WriteLine(id);
        }
    }
    class Banxian : Sx
    {
        public void fly()
        {
            Console.WriteLine(id);
        }
    }
    internal class Class1
    {
    }
}

静态类和非静态类

namespace 静态类和非静态类
{
    //创建一个静态类
    //静态类中只允许有静态成员（加了static修饰符的）和实例成员（非静态成员）
    public static class Fruit
    {
        public static int num;
        public static void Show()
        {
            Console.WriteLine("我是静态类方法");
        }
    }
    //创建一个非静态类   非静态类可以有静态成员或者实例成员
    public class Water
    {
        public static int num;
        public int num2;
        public void Show()
        {
            Console.WriteLine("我是非静态类方法");
        }
        public static void drink()
        {
            Console.WriteLine("我被喝了");
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            Fruit.Show();//静态方法直接用类名.方法名()来调用
            Water.drink();
            Water yibao = new Water();
            yibao.Show();
        }
    }
}

静态方法只能使用静态成员的数据

 public class Water
    {
        public static int num=1;
        public int num2=2;
        public void Show()
        {
            Console.WriteLine(num);
            Console.WriteLine(num2);//这里不会报错
            Console.WriteLine("我是非静态类方法");
        }
        public static void drink()//静态方法只能使用静态成员的数据
        {
            Console.WriteLine(num);
            Console.WriteLine(num2);//这里会报错
            Console.WriteLine("我被喝了");
        }
    }

readonly修饰符

只能在声明和构造函数中初始化赋值，在其他地方不能修改其值，只能被读取，不能被修改

    public class Water
    {
        public Water(int id)
        {
            this.id = id;

        }
        public readonly int id;
        public static int num=1;
        public int num2=2;
        public void Show()
        {
            Console.WriteLine(num);
            Console.WriteLine(num2);
            Console.WriteLine("我是非静态类方法");
        }
        public static void drink()//静态方法只能使用静态成员的数据
        {
            Console.WriteLine(num);
            /*Console.WriteLine(num2);*///会报错
            Console.WriteLine("我被喝了");
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            Fruit.Show();//静态方法直接用类名.方法名()来调用
            Water.drink();
            Water yibao = new Water(12345);
            yibao.Show();
            Console.WriteLine(yibao.id);
            yibao.id = 135;
        }
    }
}