.NET基础加强第一课--面向对象（OO）

面向对象

面向对象三大特性:
封装，继承，多态
面向对象包括 类和对象

什么是类？

类是一种数据类型
例如：蔬菜，水果
对象是具体的，是类的具体实例。对象具有属性(特征)和方法(行为)

封装–属性封装字段

属性封装字段
class Person
{
private int _age;
public int Id { get; set; }
public int Age
{
get { return _age; }
set {
if(value < 0 || value > 120)
{
throw new Exception(“年龄错误”);
}
else
{
_age = value;
}
}
}
}

2， 方法的多个参数封装成一个类

例如: class Student
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public DateTime Date { get; set; }

}

3， 把一堆代码封装到一个方法中

4， 将一些功能封装到几个类中

5， 将一些具有共有功能封装到程序集中

继承

子类继承父类的属性和方法，使创建子类变得很简单，实现了代码重用
好处：1，代码重用
2，多态

需要一个父类类型时，给一个子类类型对象是可以的
这叫做里氏替换原则
Person p1 = new Student();

class Student:Person
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public string course { get; set; }

}

class Person
{
private int _age;
public int Id { get; set; }
public int Age
{
get { return _age; }
set {
if(value < 0 || value > 120)
{
throw new Exception(“年龄错误”);
}
else
{
_age = value;
}
}
}
}

注意

当一个子类继承 父类以后，该子类中的所有构造函数 默认情况下，在自己被
调用之前都会先调用一次父类的无参构造函数 。如果此时父类中没有无参的父类
构造函数 ，则会报错。

解决：

1， 在父类中增加一个无参的构造函数
2， 在子类的构造函数后面通过:base()的方式，明确指定要调用父类中的
哪个构造函数
:base() 表示 调用父类的构造函数
构造函数 是不能被继承 的

练习：

定义一个父类Person ,有2个属性，Name,Age,
一个Student 子类，扩展方法Learn,一个子类 Teacher，扩展方法Talk,
调用父类的构造base 方法，给子类赋值

class Student:Person
{
public Student(string name,int age) : base(name, age)
{

}
public void Learn()
{
    Console.WriteLine("学习");
}

}

class Teacher : Person
{
public Teacher(string name,int age) : base(name, age)
{

}
public void Talk()
{
    Console.WriteLine("讲课");
}

}

class Person
{
public Person(string name,int age)
{
this.Age = age;
this.Name = name;
}
public int Id { get; set; }
public int Age{get;set;}
public string Name { get; set;}
}

this 访问本类的构造函数

class Person
{
public Person(string name,int age)
{
this.Name = name;
this.Age = age;
}

public Person(string name):this(name,0)
{
}

public Person(int age):this("",age)
{

}
public int Id { get; set; }
public int Age{get;set;}
public string Name { get; set;}

}

注意

Public 任何地方
Protected internal 同时包含 Protected Internal
Internal 同一程序集可访问
Protected 当前类内部及所有子类的内部
private 当前类内部

类的成员变量，如果不写访问修饰符，默认是private
类本身如果不写访问修饰符，默认是Internal

通过虚方法实际多态

// 在方法前加 virtual 变成虚方法
练习：
打印属于哪国人
Person[] pers = new Person[4];
pers[0] = new Chinese();
pers[1] = new American();
pers[2] = new Chinese();
pers[3] = new American();

for (int i = 0; i < pers.Length; i++)
{
pers[i].SayNationality();
}

class Chinese:Person
{
public override void SayNationality()
{
Console.WriteLine(“中国人”);
}

}

class American : Person
{
// 通过override 关键字将父类person中的虚方法重写
public override void SayNationality()
{
Console.WriteLine(“I’m USA”);
}
}

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

// 加 virtual 变成虚方法
public virtual void SayNationality()
{
    Console.WriteLine("人");
}

}