C#定义方法 等

jiaming50

1.实现方法.

       
        1.1 定义虚方法

               
                        用 virtual 修饰的方法

                        有方法体

                        除了密封类都可以写

                语法:

                [访问修饰符]  virtual 返回值类型 方法名([参数数据类型 参数名][...]])
       
                {

                }

                class Person

                {
                        姓名

                public string name;

                        年龄

                public int age;

                问好方法    虚方法

                public virtual coid SayHi()
                {
                        Console.WriteLine
                                ("大家好,我叫{0},今年{1}岁了",name,age);

                }

        }

        1.2使用虚方法

                虚方法具有自己的方法体

                虚方法可以被子类 override, 一可以不被子类override

               
        1.3 重写虚方法

                重写虚方法     使用 override 关键字

                方法重写 : 发生在两个类中,并且是子类和父类的关系.

                        子类与父类方法签名相同, 子类方法使用 override  关键字 修饰即为重写
                                是多态的一种表现.

        方法签名: 方法的识别关键字

                        方法签名 = 方法名 + 参数类型列表

        语法:

                public override 返回值类型 方法名 ([参数数据类型 参数名 [,...]])

                {

                }

                        学生类

        class Student : persong

        {
                班级名称

                public string className;

                public Student()

                public Student (string name, int age, string className)
                        :base(name, age)

                        问好方法  重写虚方法

                public override void SayHi()
                {
                        Console.WriteLine("大家好,我叫{0},今年{1}岁了,所在班级是{2}")
                                base.name , base . age className);
                }
        }
       

                例:

        #region 重写虚方法
       
        //生命基类对象
        Person ts = new Person("唐僧",35);
        //问好
        ts.SayHi();

        //声明派生类对象
        Student zs = new Student("张三", 25,"MSD1102")
        //问好
        zs.SayHi();

        //声明基类对象指向派生类对象
        Person ls = new Student("李四",26,"MSD1102");
        //问好
        ls.SayHi();

        #endregion

方法隐藏: 隐藏基类的方法

实现步骤:
                1) 在派生类中生命相同签名的新方法

                2)在改方法名称前添加 new 关键字

语法:
        public new 返回值类型 方法名 ([参数数据类型] 参数名[,...]])

        {
       
        }

                老师类    派生类

        class Teacher : Person
        {
                public int salary;
       
                public Teacher()

                public Teacher(string name, inte age , int salary)
                : base(name,age)

        问好方法    虚方法

        public new void SayHi()

        {
                Console.WriteLine
                ("大家好,我叫{0},今年{1}岁了,工资是{2}",
                        name,age , salary);
        }
        }

        多态:不同对象对于同一个方法(Cut)调用不同行为.

        C#中的多态性: 即多种形态.

                1) 通过集成,一个类可以用作多种类型(自己的类型,任何基类类型,
                        实现接口时用作任何借口的类型)

                2) C#中的每种类型都是多态的(任何类型都是自动将 object 当作基类型)

                3) 多态性主要是靠重写和隐藏来实现(还包括前面讲过的重载)

                        重写,  隐藏,  重载,





1.6 Protected 关键字

                Protected 访问修饰符,  只在本类及子类中可以访问

         //父类

                class Foo

                {
                        //公有成员

                public int m;

                        //私有成员

                private int n;

                        //受保护成员

                proctected int o;

                        //测试方法

                public void TestMethod()

                {
                        //本类可以访问任何类型成员
       
                        Console.WriteLine(m + ",,," + n + ",,," + o);
               
                }
        }

               
                实验: // 声明对象

                Foo foo = new Foo();
               
                //测试方法
       
                foo.TestMethod();



例2:

        子类
                class Aoo : Foo
                {
                        //方法
                        public void TestMethod()
                        {
                        //访问公共成员
                        Console.WriteLine("public:"+ m );
                        //访问受保护成员
                        Console.WriteLine("protected:"+ o);
                        //访问私有成员
                        Console.WriteLine("private:" + n);

                        }
                }
       
测试:
                //声明子类对象
                Aoo aoo = new Aoo();
                //测试
                aoo.TestMethod();
               
        说明:因为 Aoo 继承自 Foo , 即 Aoo 为 Foo 的子类, 所以可以访问 protected 成员输出:

       
例3:
                protected 修饰在非本类,非子类中不可访问

                //普通类

                class Boo
        {
                        //方法
                public void TestMethod()
        {
                //因Boo不是Foo子类,所以想访问成员,
                //应先声明Foo类对象
                Foo foo = new Foo();
               
                //访问公共成员

                Console.WriteLine("public:"+ foo.m);
               
                //访问受保护成员

                Console.WrtieLine("protected:" + foo.o);
       
                //访问私有成员

                Console.WriteLine("private:" + foo.n);

       
        }
                }

                第71 73 编译错误

               
        测试:
               
                //声明类对象
               
                Boo boo = new Boo();
               
                //测试
               
                boo.TestMethod();

        说明:只能访问Foo 类的 public 成员

多态很多时候是需要有继承关系时实现 , 当一个类不想被继承时如何发现?
               
        密封类

                2.1 什么是密封类

        在C#中, 为了确保其它类不可以派生于某一类,可以姜该类设计为密封类

        如果所有类都可以被继承, 则类的层次结构将变得比较复杂, 从而加重理解类的难度

        此时, 可以使用"sealed" 关键字来密封该类, 这样,可以放着被其他类继承

        密封类可以继承自其它类, 但不可以被类继承

        在 C# 中,String 类为密封类

2.2 Sealed 关键字

       
        用于定义密封类, 使用"sealed" 关键字修饰的类, 不可以被其它类继承

        用于定义密封方法, 可以防止方法在类的派生类中对该方法进行重写.

       
2.3 定义密封类

        语法: [访问修饰符] sealed class 类名

        {
               
        }

演示:

        密封类
       
        sealed class SealedDemo
       
        {
                成员变量

         public int num = 55;

                成员方法

        public void Show()
       
        {
                Console.WeiteLine("我是密封类");
        }

        }



说明:

        1)  密封类可以被实例化

                //声明密封类对象

                SealedDemo demo = new SealedDemo();

                //访问成员变量

                Console.writeLine(demo.num);

                //访问成员方法

                demo.show();

                输出:

        2) 密封类不可以被继承

                派生自密封类   错误

        class Test : SealedDemo

        {

        }

       
        3) 密封类中不能包含虚方法

       
                密封类

        sealed class SealedDemo
        {
                public int num = 55;

                public void Show()


        虚方法

        public virtual void Say()

        {
                Console.WriteLine("我是虚方法");


        }
}
        有错误圆脸:  密封类不能被继承  , 所以米饭呢更累中不能包含虚方法, 因为没有被派生类重写的机会


        4) 密封类中不能包含抽象方法

        密封类

        sealed class SealedDemo

        {
                public int num = 55;

                public void Show()

                //抽象方法

                public abstract void SayHi();


        }

                36行编译有错误

错误原因:   密封类不能被继承, 所以密封类中不能包含抽象方法,
因为没有被派生类重写的机会,

        同样抽象方法也只能包含在抽象类或接口中


2.4 定义密封方法

        密封方法:  是为了防止方法在类的派生类中对该方法进行重写.

        不是类每个成员都可以作为密封方法, 密封方法 必须对基类的虚方法进行重写

        所以, sealed 总是与 override 修饰符同时使用

        简而言之: 密封方法不可再被重写

        语法:

                [访问修饰符] sealed override 方法名 ([参数数据类型 参数名[,...]])

                {

                }

演示:

        sAoo 类:

                基类

        class SAoo

        {
                虚方法
        public virtual void M()

        {
                Console.WriteLine("Aoo.M");
        }

                //虚方法

        public virtual void N()

        {
                Console.WriteLine("Aoo.N");
        }
}

        SBoo类

                派生于 SAoo
        class SBoo: SAoo

        {
                密封方法

        public sealed override void M()

        {
                Console.WriteLine("Boo.M");
        }

                重写方法

        public override void N ()
        {
                Console.WriteLine("Boo.N");
        }
}

SCoo 类:

        派生于SBoo

        class SCoo : SBoo

        {
                重写方法
        public override void M()
        {
                Console.WriteLine("Coo.M");
        }

                重写方法

        public override void N()

        {
                Console.WriteLine("Coo.N");
        }
}
                第105行编译错误,密封方法不能被重写

        注意:密封方法必须与 override 一起使用 ,

        测试类

        class Demo
        {
                密封方法

        public sealed void Show()
        {
                Console.WriteLine("Show");

        }
}

第127有错误

        因为密封类必须与 override 一起使用.

龟宝宝

话说这些概念还搞不懂。。不知道从何理解