面向对象基础加强二

最新推荐文章于 2024-03-04 20:29:58 发布

瑾abbyone

最新推荐文章于 2024-03-04 20:29:58 发布

阅读量230

点赞数

1.自动属性

“属性和行为分离”。通过get/set可以设置某属性只读，

也可以控制到某一层可读/可写，也可以通过设置条件使数据合法等。

>>本质：

 public class Person
    {

string name;//字段
        public string Name//属性
        {
            get读取器，set读取器
            get { return name; }
            set { name = value; }
        }
 
     }

简式： public int Age { get;private set; }加了private后，可打印，不可赋值

Person person = new Person();
Console.WriteLine(person.Age；

2.继承

 class MyBase
    {
        public virtual void Func() { Console.WriteLine("MyBase"); }
    }

 class MyClass:MyBase
     {
         //不允许被子类重写了
         public sealed override void Func() { Console.WriteLine("MyClass"); }
     }
 class MySub : MyClass
     {
         public new virtual void Func() { Console.WriteLine("MySub"); }//隐藏了基类的方法
     }

 class MySubSub : MySub
     {
         public override void Func() { Console.WriteLine("MySubSub"); }
     }

            //new(v)为隐藏 over重写，隐藏看类型，重写只管新
            //MySubSub s = new MySubSub();
            //s.Func();//MySubSub    override重写只管新，输出MySubSub
            
            //MySub s = new MySub();
            //s.Func();//MySubSub    new隐藏MySub方法，被MySubSub类继承，输出MySubSub

            //MyClass s = new MyClass();
            //s.Func();//MyClass  重写MyBase方法，输出MyClass

            //里氏转换时对内存没有任何变化
            //MyBase s = new MyClass();
            //s.Func();//Myclass

3.ref与out

>>来源于C语言中的指针

>>扩展（摘自百度）

（1）指针是一个地址，指向的是个类型：

我们知道，c语言中的类型有int，char，bool（这个不常用），一般我们使用int，char就可以满足一般的类型需求的，如果对于变量的长度过大，就是用long ，float，double，关于各个类型使用的的长度问题，可以使用sizeof（int）或者sizeof（long）来查看各个类型，在系统中的小。

而指针就是一个8个字节（64系统）。

（2）：指针指向的是地址，地址指向的是内容：

我们需要一个变量，来存储地址，这个变量的值是地址，但是我们可以通过修改变量的值，来不断的改变地址，但是，我们如果需要改变该个地址的值的话，就需要，对地址的值进行修改，而不改变地址。

int a = 10；

int *p ；

p = &a；

*p =11；

a=？

这里我们看到，p 是一个变量，我们使用p来存储变量a的地址，这是，我们使用*p对于这个变量进行赋值，那么a的值最后，是多少呢，结果是11，因为我们使用*p赋值，就相当于a=11，赋值效果一样的。

（3）：指针的指针，是面对于指针的变量：

我们说，指针的指针的时候，就有点不清楚了，到底怎么区分指针和指针的指针呢。

char *p；

char **pr；

pr = &p；

我们这样看就清楚了一点，char *（*pr）； *pr是一个存储的值为指针的变量，pr就是存储上个变量地址的变量。整合起来就是，pr是一个存储的值为指针的地址的变量。

方法的调用原则就是将变量中储存的值复制一份，传递给这个方法由这个方法中

的局部变量接收使用。方法内外变量不同，值同。如果方法内外变量相同就解决了

 static void Main(string[] args)
        {
            int num1 = 5;
            int num2 = 10;
            Func(ref num1, ref num2);
            //使用ref必须在使用前赋值，方法中可以改变这个变量的值，如果改变相当于返回多个值
            //out参数，语法虽然与ref一样，但是与ref的区别：ref先赋值再使用（传入用的），out必须在方法中赋值使用（传出用的）。

            Console.WriteLine("num1={0},num2={1}",num1,num2);
            Console.ReadKey();
        }
        public static void Func(ref int n1, ref int n2)
        {
            int t = n1;
            n1 = n2;
            n2 = t;
        }

4.数据绑定与属性的关系

winform窗体上丢一个datagridview控件，编写一个person类，load事件绑定数据

  class Person
    {
        public int Age{get;set;}
        public string Name { get; set; }
        public char Sex { get; set; }
    }

  private void Form1_Load(object sender, EventArgs e)
        {
            //创建一个对象，将对象绑定到控件中
            List<Person> list = new List<Person>();
            list.Add(new Person() { Name = "zhao", Age = 19, Sex = '男' });
            dataGridView1.DataSource = list;//绑定list数据
        }

5.cmd控制台模拟

    主程序
     用户输入
    >_
    string输入结果交给工厂，让工厂提供应用程序进行打开文件
    交给工厂，工厂类似于注册表，工厂分析后缀名，打开文件夹，
    注册表Regedit存储用户的所有信息配置

编写PE抽象类

abstract class PE//抽象类
    {
        public abstract void Open();
    }

添加子类JKPlayer，继承PE

class JKPlayer:PE
    {
        string fileName;
        public JKPlayer(string n)
        {
            fileName = n;
        }
        public override void Open()//重写抽象方法
        {
            Console.WriteLine("【{0}】是媒体文件，播放媒体文件",fileName);
        }
    }

添加新类OS

class OS
    {
        //创建一个实例
        public static PE CreateInstance(string file)
        {
            //解析文件,获得文件扩展名
            string exet = Path.GetExtension(file);
            switch(exet.ToLower())//文件后缀名转换为小写字母
            {
                case ".mp3":
                 case ".avi":
                 case ".rm":
                 case ".rmvb":return new JKPlayer(Path.GetFileName(file));//后缀名符合就返回PE的open方法
                default:return null;

            }
        }
    }

主程序代码

class Program
    {
        static void Main(string[] args)
        {
            Console.Title = "命令提示符";
            Console.WriteLine(@"Microsoft Windows [版本 6.3.9600]
          (c) 2013 Microsoft Corporation。保留所有权利."+"\r\n");
            while (true)
            {
                Console.Write(@"C:\User\余瑾>");
                string str = Console.ReadLine();//用户输入地址
                if (str.ToLower() == "exit")//exit为OS类里面的文件后缀名
                {
                    break;
                }
                PE pe = OS.CreateInstance(str);
                if (pe==null)
                {
                    //Console.WriteLine("没有安装指定应用程序");
                    //附赠好玩的东西
                    if (File.Exists(str))
                    {
                        //进程文件开启
                        System.Diagnostics.Process.Start(str);
                    }
                   
                }
                else
	             {
                    pe.Open();
	             }
            }
        }
    }

6.接口多态

参考资料：http://www.cnblogs.com/if404/archive/2011/10/28/2227197.html

namespace _04抽象类与接口
{
   abstract class CC1:IInterface
    {
       public abstract void Func();
    }
}

namespace _04抽象类与接口
{
    class CC2:CC1
    {
        public override void Func()
        {
            Console.WriteLine("CC2");
        }
    }
}

namespace _04抽象类与接口
{
    class CC3 : IInterface, II
    {
        void IInterface.Func()
        {
            Console.WriteLine("Iinterface");
        }
        void II.Func()
        {
            Console.WriteLine("II");
        }
    }
}

namespace _04抽象类与接口
{
    public interface II
    {
        void Func();
    }
}

namespace _04抽象类与接口
{
    public interface IInterface
    {
        void Func();
    }
}

namespace _04抽象类与接口
{
    class Program
    {
        static void Main(string[] args)
        {
            //IInterface i = new CC2();
            //i.Func();
            //Console.ReadKey();
            CC3 c = new CC3();
            II i1 = c;//转换为接口
            i1.Func();
            IInterface i2 = c;
            i2.Func();
            Console.ReadKey();

       }
    }
}

            抽象成员：方法，属性，索引，事件，非抽象成员
            抽象类使用abstract修饰，override重写
            抽象成员只允许在抽象类中，必须被实现
            抽象构造方法是为了初始化，无法实例化

            接口成员：方法，属性，索引，事件
            接口一事物的具体描述，成员没有修饰符，实现就像没有一样，
            接口就是为了实现多态，无法实例化
            接口对于抽象的优势：不限制类型的继承关系
            接口语法
            [访问修饰符] interface 接口名
            {
                接口成员
            }

        }
        public interface Idable
        {
            void Da();
        }
        实现接口
        class CCC : Idable//继承自接口，实现接口
        {
     //假定没有接口存在，但是需要一个名字为Da，没有返回值，没有参数的方法

}

7.静态

常用静态类：Console，Convert类，Math类
静态和实例区别：（文字整理参考于百度）

静态方法的调用，是类名后直接加静态方法即可。实例方法必须将类实例化后，用实例调用该实例方法。
静态方法，只能调用类中的其他静态属性和静态方法，不能调用类中的非静态属性和非静态方法。
实例方法，可以调用静态属性和静态方法，也可以调用实例属性和实例方法。
静态方法是属于类的必须由类来调用，实例方法是属于实例的必须实例化类后，用类的实例调用。

8.访问修饰符

        1.类型前
        访问修饰符：public，internal（默认，只在当前程序集（当前项目）中可以被访问）
        多态方面的修饰符：abstract ，sealed（密封，不允许被继承），   static（静态，与多态相反）
      特性（Attribute）
        2.成员前
        public internal（当前项目） private(默认) protected（当前类访问）
        internal protected
        多态方面的修饰符：virtual abstract override sealed   atatic
        特性。
         外部实现
        extern

垃圾回收：自己去申请空间,后台有一个线程专门统计内存使用率,

垃圾回收扩展：参考http://www.cnblogs.com/yang_sy/p/3784151.html

9.this与base

>>this 用法

 class Person
    {
        int age;
        string name;
        char sex;
        public Person(string name,int age,char sex)
        {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        public Person(string name):this(name,"男女"[new Random().Next(2)])
        {
 
        }
        public Person(string name,char sex): this(name, 0,sex)
        {

        }
    }
   
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

this,指向到了派生类对象的自己定义的字段。base才是指向的基类的字段

扩展资料http://www.cnblogs.com/reommmm/archive/2009/03/23/1419573.html

瑾abbyone

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象基础加强二

1.自动属性“属性和行为分离”。通过get/set可以设置某属性只读，也可以控制到某一层可读/可写，也可以通过设置条件使数据合法等。>>本质： public class Person {string name;//字段 public string Name//属性 { get读取器，set读取器
复制链接

扫一扫