C#封装 继承 多态
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
namespacelesson10
{
enum Sex
{
men,women
}
class Person
{
public string name;//字段骆驼命名
public Sex sex;
public double Money;
public Person() { Console.WriteLine("默认构造方法调用"); }//默认访问修饰符是私有的
public Person(stringname, Sex sex)
{
this.name = name;//如果类没建对象，this等于类，如果创建对象了，this就指对象
this.sex = sex;
}
}
class Teacher: Person
{
public string name;//字段骆驼命名
public Sex sex;
public string teach;
//public Teacher()
//{
// Console.WriteLine("teachr");
//}
public Teacher(stringname, Sex sex, string teach):base(name,sex)//base继承父类的字段
//base()有参数 父类里面也必须要有有参数的构造函数
{
//this.name = name;
//this.sex = sex;
ach = teach;
}
public void WolkDog(Dogsl) {
Console.WriteLine("遛狗");
}
}
class Dog
{
public void Bark() { Console.WriteLine( "dog,bark"); }
}
class SmallDog: Dog
{
public void SmallDogBark() { Console.WriteLine( "sl,baek"); }
}
class BigDog: Dog
{
public void BigDogBark() { Console.WriteLine( "big,bark"); }
}
class Student : Person
{
public Student()
{
}
//public string name;
//public Sex sex;
public Teacher teacher;
public Student( Sexsex, Teacher teacher) : base()//base()无参数 父类里面也必须要有无参数的构造函数
{
this.sex = sex;
acher = teacher;
}
}
//面向对象 先找对象
//class Elephant
//{
//}
//class IceBox
//{
// public void Open() { Console.WriteLine("冰箱门打开了"); }
// public void Zhuang(string thing)
// {
// Console.WriteLine("把" + thing + "装进冰箱");
// }
// public void Off() { Console.WriteLine("冰箱门关上了"); }
//}
//class House //封装
//{
// double price;//私有的
// string add;
// public string Add
// {
// get
// {
// return Add;
// }
// set
// {
// Add = value;
// }
// }
// public House(double price,string add) {
// this.price = price;
// this.add = add;
// }
//}
class Master
{
public void Exam() { Console.WriteLine( "师傅考试" ); }
}
class Disciple: Master
{
public virtual void Exam() { Console.WriteLine("徒弟考试"); }
}
class Disciple5552: Disciple
{
public override voidExam() { Console.WriteLine("徒孙考试"); }
}
class Program
{
static void Main(string[] args)
{
//构造方法是与类名相同，并且无返回值，不加void；
//作用 主要是创建对象，并给对象赋初始值
//不带参数的构造方法称为默认构造
//构造方法可以带有参数，可以重载
//person 点不出来构造方法。 构造方法 只能在new对象中用
//如果给对象赋初始值可以在类里面写出带有参数的构造方法并使用；
//Person person = new Person("张三", );
Person s = new Person();
优先调用无参数的构造方法，，如果在类里面没有任何对象，系统会默认一个构造 供我们使用，如果有带参数的构造的方法，
调用默认构造时 必须显示的把默认构造写出来
//Console.WriteLine(person.name );
//Console.WriteLine(person .sex );
//Teacher teacher = new Teacher("李", ,"语文");
//Student student = new Student("王",Sex.women ,teacher );
//Console.WriteLine(teacher .teach );
//Console.WriteLine(student .name );
//IceBox a = new IceBox();
//Elephant b = new Elephant();
//a.Open();
//a.Zhuang("大象");
//a.Off();
//a.Open();
//a.Zhuang("白菜");
//a.Off();
//面向对象的三大特性
//封装 继承 多态
//封装 我们在创建对象时不需要外部人为的破幻对象所包含的值，此时就需要把字段给封装起来
//具体的做法是把成员的字段用Private 来修饰，这样外部就无法拿到字段并修改所储存的数据，同时把私有的字段改成属性
//通过属性修改字段的值，创建对象并初始化对象时，可以用带有参数的构造方法给字段赋值，
//把字段写成私有，在外部拿不到，但是在类内部可以调用字段
//继承
//被继承的称为父类，或者基类 继承的称为子类
//当一个子类继承父类时 ，会把父类里面的成员继承过来
//父类里面的成员用public修饰，共有的 会被继承过来，如果是private修饰，是私有的 继承过来不能用
//共有继承过来的成员在任何地方都可以使用，私有继承过来的成员只能在父类内部使用，在类的外面不能使用，
//protected继承过来的成员只能父类和子类里面使用类的外面不能用
//里氏转换
//为了在处理数据时，为了使所处理的数据类型达到统一，此时会把数据的类型统一写成父类类型
//这样就可以把子类的对象赋值给父类；
//里氏转换的第一个原则，把子类的对象赋值给父类,但是调用类里面的成员时只能调用父类里面的，子类里面的调不到
//里氏转换的第二个原则，把父类的对象转换成子类,用as 在第一原则上建立的 转换不成功就是null
//Person person = new Person();
//Console.WriteLine(person.name );
//Teacher teacher = new Teacher("li56+", , "yu");
//Student student = new Student("lilkl", Sex.women, teacher);
Console.ach);
Console.WriteLine(teacher.sex);
Console.WriteLine(teacher.name );
Console.WriteLine(student.name);
Console.WriteLine(student.sex);
Console.acher);
SmallDog sldog = newSmallDog();
BigDog bigdog = newBigDog();
//teacher.WolkDog(bigdog);
Dog kl = new Dog();
SmallDog klll = kl asSmallDog;
klll.SmallDogBark();
klll.Bark();
//Dog dog = sldog;
SmallDog sllll=(SmallDog )dog;//不能用强制转换
//SmallDog sllll = dog as SmallDog;
//sllll.Bark();
//sllll.SmallDogBark();
//BigDog slll = dog as BigDog;
//bool issllll = sllll is BigDog;//判断它是不是大狗类
//Console.WriteLine(issllll);
//if (slll != null)//转换不成功
//{
// slll.BigDogBark();
//}
把值类型转换为引用类型的过程称为装箱 开辟双倍空间
把引用类型转换成值类型称为拆箱 开辟双倍空间
//int a = 10;
//object obj = a;//所有的类都是object的子类
//Console.WriteLine(obj );
//int b=(int )obj ;
//Disciple sasa = new Disciple();
//Disciple5552 sa = new Disciple5552();
//子类里面有何父类同名的方法需要在子类的方法前加new表示 用子类的方法替换父类的方法，称为方法替换
//使用new有意隐藏继承过来的同名的方法 new void Exam
//sasa.Exam();//各调个的方法
//sa.Exam();
//Disciple sasasa = sa;
//多态
//1.把父类里面的方法前面加virtual
//2.在子类同名的方法前加 override 进行重写
//当我们把一个子类的对象赋值给对象后，该对象在调用父类里面的虚方法时，如果子类重写了该虚方法，则调用的是子类
//里面重写后的方法，否则就调用父类的虚方法
//sasasa.Exam();
}
}
}
