zoukankan      html  css  js  c++  java
  • 03---Net基础加强

    多态---虚方法    (子类可以选择重写或者不重写) 

      class Program
        {
            static void Main(string[] args)
            {
                Chinese cn1 = new Chinese("叶长种");
                Chinese cn2 = new Chinese("王少伟");
                Japanese jp1 = new Japanese("小野妹子");
                American us = new American("勒布朗");
                Person[] pers = { 
                                    cn1, cn2,jp1,us
                                };
                for (int i = 0; i < pers.Length; i++)
                {
                    Console.Write(pers[i].Name);
                    pers[i].ShowNationality();
                }
                Console.ReadKey();
            }
        }
    
        public class Person
        {
    
            public string Name
            {
                get;
                set;
            }
            public int Age
            {
                get;
                set;
            }
            public string Email
            {
                get;
                set;
            }
    
            public virtual void ShowNationality() //虚方法virtual
            {
                Console.WriteLine("........");
            }
        }
    
        public class Chinese : Person
        {
            public Chinese(string name)
            {
                this.Name = name;
            }
            public override void ShowNationality() // 子类重写父类方法时,使用的关键字是overrider
            {
                Console.WriteLine("【中国】");
            }
        }
    
        public class Japanese : Person
        {
            public Japanese(string name)
            {
                this.Name = name;
            }
            public override void ShowNationality()
            {
                Console.WriteLine("【日本】");
            }
    
        }
    
        public class American : Person
        {
            public American(string name)
            {
                this.Name = name;
            }
            public override void ShowNationality()
            {
                Console.WriteLine("【美国】");
            }
        }

    举例:

     class Program
        {
            static void Main(string[] args)
            {
                Employee emp = new Employee();
                emp.DaKa();
                Manager man = new Manager();
                man.DaKa();
                Console.ReadKey();
            }
        }
    
        public class Employee
        {
    
            public virtual void DaKa() //虚方法virtual
            {
                Console.WriteLine("员工8:30打卡。");
            }
        }
    
        public class Manager : Employee
        {
    
            public override void DaKa() // 子类重写父类方法时,使用的关键字是overrider
            {
                Console.WriteLine("经理9:00打卡");
            }
        }

    虚方法特点总结:

    1.在父类中把需要设置为虚方法的方法前加Virtual标记

    2.虚方法在父类中必须有实现

    3.子类继续父类后可以选择重写也可以选择不重写

    4.当子类重写父类中的方法的时候,必须保证重写后的方法与原方法的访问修饰符,返回值类型,方法名,参数列表完全一致

    5.当方法的标记是virtual或者override的时候都可以重写

    静态

      class Program
        {
            static void Main(string[] args)
            {
                Myclass mc = new Myclass();
    
                //类中的静态成员不能通过对象来访问,只能通过“类名”来访问
                //Myclass.name = "aaaa";
                //Myclass.Say();
    
                //静态成员在整个程序中是共享的,一个地方改变后,所有使用到的地方都发生改变
                //静态成员直到程序退出时才会释放,在静态成员中不能使用this
                //M1();
                //Console.WriteLine(Myclass.name);
                //Console.ReadKey();
    
                MyTool.age = 100;
                MyTool.Show();
                Console.ReadKey();
    
            }
    
            static void M1()
            {
                Myclass.name = "aaaa";
            }
    
        }
    
        //实例类(普通类)
        class Myclass
        {
            //静态成员  
            public static void Say()
            {
                Console.WriteLine("hello");
            }
    
            //静态成员
            public static string name;
    
            //实例成员
            public int Age
            {
                get;
                set;
            }
        }
    
    
        static class MyTool
        {
            //静态构造函数,在第一次使用该类前调用(并且只调用一次)
            //静态构造函数不能有修饰符
            //静态构造函数不能有参数(所以也不能重载)
            //主要是因为静态构造函数是系统调用的
            static MyTool()
            {
                Console.WriteLine("第一次调用");
            }
            public static void Show()
            {
                Console.WriteLine("show");
            }
            public static int age;
        }

    系统中 Math、Console、Convert等都是静态类!

    静态类不能被其它类继承,静态成员亦不能被继承(访问的是同一个)

    静态类只能继承Object类。(静态类不能继承自其它类)

    继承(多态),静态本身就是相反的。

    静态类不能实现任何接口,(因为接口中的成员都是实例成员) 

     sealed 密封类,不能被继承。 sealed是关键字!

    静态类的本质就是abstract+sealed !

    静态类,静态类成员:

    1.静态成员在整个应用中共享同一个值。

    2.只有当程序退出后,才释放静态资源的内存

    3.静态成员只能通过类名来访问,不能通过对象名访问。

    4.静态类不能被实例化

    在实例类中使用静态成员:当该类需要被实例化时,并且该类中有某个成员是大家都共享的,此时,可以将该成员标记为static静态的。

    静态类:当使用一些工具类的时候(都是一些工具方法),可以使用静态类来把相关的方法都封装到一个类中,方便调用。

     class Program
        {
            static void Main(string[] args)
            {
                //1.将一个类标记为“密封类”
                //2.用在方法重写
            }
        }
    
        //public sealed class Person
        //{
    
        //}
    
        //public class Chinese : Person  //不能继承    string是个密封类,是引用类型,滥用继承,会使系统崩溃!
        //{
    
        //}
        public class Person
        {
            public string Name
            {
                get;
                set;
            }
            public int Age
            {
                get;
                set;
            }
            public string Email
            {
                get;
                set;
            }
            public virtual void Say()
            {
                Console.WriteLine("say.....");
            }
        }
    
        public class Chinese : Person
        {
    
            public override void Say()
            {
                Console.WriteLine("Chinese中的Say");
            }
        }
    
        public class HeiBeiRen : Chinese
        {
            //终止继续重写
            public sealed override void Say()
            {
                Console.WriteLine("河北人。。");
            }
        }
    
    
        public class ShiJiaZhuang : HeiBeiRen
        {
            //不能再重写方法Say()
        }

    多态:为了把程序的可扩展性,把不同的子类对象都当做父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化!

    多态就是指不同对象收到不同消息时,会产生不同的行为,同一个类在不同的场合下表现出不同的行为特征!

    开放封闭原则(对修改封闭,对扩展开放)

    ToString()方法

       class Program
        {
            static void Main(string[] args)
            {
                string s = "aaaa";
                Console.WriteLine(s.ToString());
                int n = 132;
                Console.WriteLine(n.ToString());
                Console.ReadKey();
            }
        }

    里氏替换原则:

        1.父类引用指向子类对象Person p=new Chinese();(隐式类型转换)

        2.父类对象不能够替换子类Chinese c=(Chinese)new Person();(X)

     is-a:可以用来验证继承关系是否合理(can-do验证实现接口是否合理)

    if(obj is 类型A) //obj是父类类型对象,“类型A” 是子类类型

    使用as进行类型转换,如果转换成功则返回成功后的对象,如果转换失败就返回NULL;

     class Program
        {
            static void Main(string[] args)
            {
    
                Person p = new American("叶长种");
                Chinese cn = p as Chinese;
                //使用as进行类型转换,如果转换成功则返回成功后的对象,如果转换失败就返回NULL;
                if (cn != null)
                {
                    Console.WriteLine(cn.Name);
                }
    
                Console.ReadKey();
            }
        }
    
        public class Person
        {
            public Person(string name)
            {
                this.Name = name;
            }
    
            public string Name
            {
                get;
                set;
            }
            public int Age
            {
                get;
                set;
            }
            public string Email
            {
                get;
                set;
            }
        }
        public class Chinese : Person
        {
            public Chinese(string name)
                : base(name)
            { }
        }
    
        public class American : Person
        {
            public American(string name)
                : base(name)
            { }
        }

    实现多态的方法

    1.虚方法Virtual,子类重写父类中的方法。

    2.抽象类abstract,子类重写父类中的方法。

    3.接口,实现接口的类,将接口中的方法实现。

    使用虚方法:

      class Program
        {
            static void Main(string[] args)
            {
    
                Person p = new Chinese();
                p.Say();
                Console.ReadKey();
            }
        }
    
        public class Person
        {
    
            public string Name
            {
                get;
                set;
            }
            public int Age
            {
                get;
                set;
            }
            public string Email
            {
                get;
                set;
            }
            public virtual void Say()
            {
                Console.WriteLine("Person类中的Say");
            }
        }
        public class Chinese : Person
        {
            public override void Say()
            {
                Console.WriteLine("Chinese中的Say()");
            }
        }
    
        public class American : Person
        {
            public override void Say()
            {
                Console.WriteLine("American中的Say()");
            }
        }

    使用抽象

      class Program
        {
            static void Main(string[] args)
            {
    
                Person p = new Chinese();
                p.Say();
                Console.ReadKey();
            }
        }
        //抽象类的特点:
        //1.抽象类不能被实例化。
        //2.抽象类中可以有实例成员,也可以有抽象成员
        public abstract class Person  //抽象成员只能出现在抽象类中。所以要把当前类也变为抽象的
        {
    
            public string Name
            {
                get;
                set;
            }
            public int Age
            {
                get;
                set;
            }
            public string Email
            {
                get;
                set;
            }
            //1. 关键字abstract  
            //2.抽象成员不能有任何实现代码
            //3.抽象成员只能出现在抽象类中。所以要把当前类也变为抽象的
            //4.与虚方法不同,抽象方法子类必须重写(除非子类也是抽象的)
            public abstract void Say();
        }
        public class Chinese : Person
        {
            public override void Say()
            {
                Console.WriteLine("Chinese中的Say()");
            }
    
        }
    
        public class American : Person
        {
            public override void Say()
            {
                Console.WriteLine("American中的Say()");
            }
        }
    
        //public class Japanese : Person   //与虚方法不同,抽象方法子类必须重写
        //{
    
        //}

    抽象类案例1

     class Program
        {
            static void Main(string[] args)
            {
    
                Dog a = new Dog();
                a.Eat();
                a.Bark();
                Console.ReadKey();
            }
        }
    
        public abstract class Animal
        {
            public abstract void Eat();
            public abstract void Bark();
        }
        public class Dog : Animal
        {
            public override void Eat()
            {
                Console.WriteLine("我吃骨头");
            }
            public override void Bark()
            {
                Console.WriteLine("汪汪汪");
            }
    
        }
    
        public class Cat : Animal
        {
            public override void Eat()
            {
                Console.WriteLine("我吃鱼");
            }
            public override void Bark()
            {
                Console.WriteLine("喵喵喵");
            }
        }

    抽象案例2:

     class Program
        {
            static void Main(string[] args)
            {
    
                Teacher teacher = new Teacher();
                Student student = new Student();
                student.StandUp();
                teacher.SayHello();
                student.SayHello();
                teacher.StandUp();
                Console.ReadKey();
            }
        }
    
        public abstract class Person
        {
            public abstract void SayHello();
            public abstract void StandUp();
        }
        public class Teacher : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("同学们好");
            }
            public override void StandUp()
            {
                Console.WriteLine("请坐");
            }
    
        }
    
        public class Student : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("老师好");
            }
            public override void StandUp()
            {
                Console.WriteLine("起立");
            }
        }

    抽象案例3:

     class Program
        {
            static void Main(string[] args)
            {
                Shape shape = new Circle(20);
                Console.WriteLine(shape.GetArea());
                Console.WriteLine(shape.GetZhouChang());
                Shape shape1 = new ChangFangXing(3, 4);
                Console.WriteLine(shape1.GetArea());
                Console.WriteLine(shape1.GetZhouChang());
                Console.ReadKey();
            }
        }
    
        public abstract class Shape
        {
            public abstract double GetArea();
            public abstract double GetZhouChang();
        }
        public class Circle : Shape
        {
            //扩展属性 半径
            public double R
            {
                get;
                set;
            }
            public Circle(double r)
            {
                this.R = r;
            }
            public override double GetArea()
            {
                return Math.PI * this.R * this.R;
            }
            public override double GetZhouChang()
            {
                return 2 * Math.PI * this.R;
            }
        }
        public class ChangFangXing : Shape
        {
    
            public double Width
            {
                get;
                set;
            }
    
            public double Heigh
            {
                get;
                set;
            }
            public ChangFangXing(double w, double h)
            {
                this.Width = w;
                this.Heigh = h;
            }
            public override double GetArea()
            {
                return this.Width * this.Heigh;
            }
            public override double GetZhouChang()
            {
                return 2 * (this.Width + this.Heigh);
            }
        }

    抽象类练习:(U盘,MP3播放器,移动硬盘三种移动设备)

    可移动设备类

     //可移动存储设备
        public abstract class MobileDisk
        {
            public abstract void Read();
    
            public abstract void Write();
        }

    MP3类

        public class MP3 : MobileDisk
        {
            public override void Read()
            {
                Console.WriteLine("MP3读取数据...");
            }
            public override void Write()
            {
                Console.WriteLine("MP3写数据...");
            }
            public void PlayMusic()
            {
                Console.WriteLine("音乐播放中...");
            }
        }

    U盘类

       public class UDisk : MobileDisk
        {
            public override void Read()
            {
                Console.WriteLine("U盘读取数据...");
            }
            public override void Write()
            {
                Console.WriteLine("U盘写数据....");
            }
        }

    硬盘类

     public class HardDisk : MobileDisk
        {
            public override void Read()
            {
                Console.WriteLine("硬盘读取数据...");
            }
            public override void Write()
            {
                Console.WriteLine("硬盘写数据....");
            }
        }

    计算机类

      public class Computer
        {
            public MobileDisk Disk
            {
                get;
                set;
            }
    
            public void Read()
            {
                Disk.Read();
            }
            public void Write()
            {
                Disk.Write();
            }
        }

    主程序

      class Program
        {
            static void Main(string[] args)
            {
                Computer computer = new Computer();
    
                //UDisk u1 = new UDisk();
                //computer.Disk = u1;
    
                MP3 mp3 = new MP3();
                computer.Disk = mp3;
                computer.Read();
                computer.Write();
                Console.ReadKey();
            }
        }

    抽象类练习:(橡皮鸭子,真实鸭子)

    class Program
        {
            static void Main(string[] args)
            {
    
            }
        }
    
        public abstract class Duck
        {
            public void swim()
            {
                Console.WriteLine("鸭子在水上漂...");
            }
    
            public abstract void Bark();
        }
    
        public class RealDuck : Duck
        {
    
            public override void Bark()
            {
                Console.WriteLine("嘎嘎......");
            }
        }
    
        public class RubberDuck : Duck
        {
    
            public override void Bark()
            {
                Console.WriteLine("唧唧......");
            }
        }
  • 相关阅读:
    C# 调用c++ 生成的dll
    【转】Unity3D的主要类图
    【转】Unity3D开发七惑
    Unity3D 3.5 之windows平台coding及debug环境小结
    __FILE__ __LINE__ C++ 宏定义 调试
    代码换行格式(inconsistent line endings) Windows(CR LF) 修改
    【转】 QGLWidget类
    帧缓冲区对象
    【转】kd树
    【转】unity Mathf 数学运算(C#)
  • 原文地址:https://www.cnblogs.com/yechangzhong-826217795/p/4056827.html
Copyright © 2011-2022 走看看