基础笔记二 面向对象编程

Posted 2020-10-23 海龟123

====================类与对象的概念及属性============================

对象的三大特性

（1）封装，类是最小单元的封装，封装后，其他人直接使用dll 保证了代码的安全性，实际开发中用的最多

（2）继承： .net 类库用的多，实际开发中用的不多，用接口多 （抽象类等用的不多）

（3）多态：重载（编译时多态），和重写（运行时多态），用的也不多，不能随便使用

字段和属性

字段

（1）字段又叫“成员变量”，在类的内部使用，用private修饰

（2）字段一般采用camel命名

属性

（1）一般一个属性对应一个私有字段

（2）属性中是可以添加业务逻辑的，属性是外界访问私有字段的入口

（3）可以只使用 get 或者 set，来设置只读只写

（4）快速封装，鼠标放到私有字段上，右击封装字段

（5）如果属性没有赋值，对应的私有字段会有默认值，字符是“”，数字是0等

public class Student
    {
        public Student() { }
        public Student(int StudentId, string StudentName)
        {
            this.StudentId = StudentId;
            this.StudentName = StudentName;
        }
        private int age;
        public int StudentId { get; set; }
        public string StudentName { get; set; }
　　　　//年纪添加业务逻辑
        public int Age
        {
            get { return age; }
            set
            {
                if (value < 18)
                    age = 18;
                else
                    age = value;
            }

        }
    }

 （5）没有私用字段的属性

 private DateTime birthday;
        public DateTime Birthday
        {
            get { return birthday; }
            set { birthday = value; }
        }
        //没有私有字段的属性
        public int Age
        {
            get { return DateTime.Now.Year-birthday.Year}
        }

（6）像微软的dataview 控件绑定数据源的时候，只认对象的属性，而不是字段，即使字段是public

方法的定义

概念：方法表示这个对象能做什么

类型：实例方法，静态方法（构造方法，抽象方法，虚方法）

方法重载：方法名相同，参数个数，或者类型不同叫重载

ps：void 无条件跳出

public  void getName（）
{
    return；
} 

面向对象知识小结

软件中的封装

类封装：类是最小的程序单元，是对属性，方法的封装，类的public成员是对外提供的数据访问接口

模块的封装：类可以封装成模块，组成更大的程序组件

从OOP理解：外界调用的时候可以不用关心内部实现的细节，充分体现面向对象的“高内聚，低耦合”

面向过程，在同一个类中，一个方法调用了另一个方法，不需要实例化，叫做面向过程

 

=======================对象构造、销毁与对象类型=================================

对象构造

1.构造方法的使用：用来初始化字段，对象创建时候，默认有个无参数的构造方法

（属性是对外的接口，真正存储数据的还是私用字段）

2.构造方法的定义：

访问修饰符 类名（[参数1]，[参数2]，...）{

}

 3. this 在构造函数中的应用，谁调用，this就是谁

        private int studentId;
        private string studentName;
        private int age;
     
        public Student(int studentId ,string studentName)
        {
            this.studentId = studentId;
            this.studentName = studentName;
        }
        public Student(int studentId ,string studentName,int age):this(studentId,studentName)
        {
            this.age = age;
        }

4.对象初始化器使用

传统的使用，要求Student中声明好构造函数

Student objstu4 = new Student(1003, "小李", 20);

net4.0 开始有新变化，初始化的时候，可以直接给属性赋值,这就叫对象初始化器

 // student
public class Student
    {
        private int studentId;
        private string studentName;
        private int age;
        public Student()
        {

        }
        public int StudentId
        {
            get { return studentId; }
            set { studentId = value; }
        }
        public string StudentName
        {
            get { return studentName; }
            set { studentName = value; }
        }
        public int Age
        {
            get { return age; }
            set { age = value; }
        }
    }
//main
 static void Main(string[] args)
        {
            //创建几个学员对象
            Student objstu45 = new Student()
            {
                StudentId = 1003,
                StudentName = "小王",
                Age = 50
            };

        }

 对象销毁

1.对象的生命周期：对象在内存中不断的“生生死死”，具有生命周期

2.对象在内存中的状态

　　　　正在使用--------》  程序正在使用的对象

              游离状态 -------》没有引用的对象，已经使用完毕但依然占据空间

3. 垃圾回收机制（GC）

     Net虚拟机特有的机制，自动运行，并检查对象的状态

    发现对象不再引用，会将其释放所占用的空间（销毁）

4.手动销毁对象：obj.Dispose(); ，适用于资源占用大的程序，Dispose()方法自定义的对象不实现，想要实现需要在定义类中实现析构函数，这里不做了解。

5. using使用，只有当对象使用了IDispose接口后在可以使用，表示对象使用完立即销毁，即在末尾调用了Dispose()方法

using 对自定义的对象不能使用，除非自定义对象实现了IDispose接口（即实现析构函数）

6. 可以给对象赋值 null ，GC 会自动回收

对象类型

string 类型做了特殊的处理，使其改变的值不影响

与 javascript比较，JavaScript的类型有5中：null ，undefined，string，int，bool，其中string类型也做了特殊处理，使其改变的值不影响其他对象

 =======================ref 和out=================================

使用ref 可以使值类型变量按照引用类型方式传递，实际开发中不建议使用

void main（）
{
           int a = 10;
            int b = 10;
            int result = add(ref a, b);
          console.write(a) // 20
} 
  static int add(ref int a,int b)
        {
            a = a + b;
            return a;
        }

 

out可以让方法有多个返回值，实际开发中不建议使用，使用“字典集合”方式返回多个参数

  int a = 10;
  int b = 10;
  int chen = 0;
  int result = yunsuan(a, b,out chen);

static int yunsuan(int a,int b,out int chen)
 {
   chen = a * b;
   return a+b;
 }

 多态

多态分为编译时候多态和运行时多态，编译时多态就是重载，运行时多态就是override

接口、抽象类的区别

有抽象方法的类必须定义为抽象类，抽象类只能作为基类，接口其实是抽象类的补充

public abstract class Fruit
    {
        public string  vendor { get; set; } //默认为private
        
        public abstract float Price { get; } //抽象属性必须是公有的

        public abstract void GrowInArea(); //抽象方法必须是公有的
    }

 

public class Apple : Fruit
    {
        public override float Price
        {
            get
            {
                if (vendor == "红富士")
                    return 100;
                else
                    return 0;

            }
        }

        public override void GrowInArea()
        {
            Console.WriteLine("我在南方北方都能生长,我的生产商是:" + vendor + ",我现在的价格是：" + Price);
        }
    }

 虚方法

在C# 中 一个类型被构造，它的执行顺序是这样的：

     执行变量的初始化表示式 --〉执行父类的初始化 --〉执行父类的构造方法 --〉 执行子类的构造方法