面对对象的复习 - 《C# 基础知识》

封装、继承、多态

字段：存储数据，访问修饰符应该设置为private是有的。
属性：保护字段，对字段的取值和赋值进行限定。
new关键字：一、二、
1、在堆中开辟空间隐藏父类成员
2、在开辟的空间中创建对象
3、调用对象的构造函数
this关键字：1、代表当前类对象
2、调用自己的构造函数
构造函数：初始化对象，当创建对象的时候，会调用构造函数。
对字段的保护方法：
1、get()
2、set()
3、构造函数

字段、属性、方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _130_面对对象复习
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            //给对象的每个属性赋值的过程称之为对象的初始化
            p.Name = "张三";
            p.Gender = '男';
            p.Age = 19;
            p.SayHello();
            Console.ReadKey();
        }
    }
}

Person:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _130_面对对象复习
{
    class Person
    {
        // 字段、属性、构造函数、方法、接口
        private string _name;
        private char _gender;
        private int _age;
        public string Name { get => _name; set => _name = value; }
        public char Gender { get => _gender; set => _gender = value; }
        public int Age { get => _age; set => _age = value; }
        public Person()
        {
        }
        public Person(string name,int age,char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
        //使用this关键字调用自己的构造函数
        public Person(string name):this(name,0,' ')
        { }
        public void SayHello()
        {
            Console.WriteLine("{0}---{1}----{2}",this.Name,this.Gender,this.Age);
        }
    }
}

继承
解决代码的冗余，实现多态，增加了代码的扩展性，便于维护。
1、单根性
2、传递性
子类并没有继承父类的构造函数，而是会默认调用父类那个无参数的构造函数。可使用base调用父类的构造函数。

里式转换
1、子类可以赋值给父类
2、如果父类中装的是子类对象，那么可以将这个父类转换为子类对象。
is:表示类型转换，如果能够转换成功，则返回true否则返回false。
as:表示类型转换，如果能够转换，则返回对应的对象，否则返回null。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _131_里式转换复习
{
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Student(); //子类可以赋值给父类
            //Student s = (Student)person;    //强转
            //Console.WriteLine(s.ID);
            Teacher t = person as Teacher;  //  t=null;
            if (person is Student)
            {
                Console.WriteLine("可以转换");
            }
            else
            {
                Console.WriteLine("转换失败");
            }
            Console.ReadKey();
        }
    }
}

Person.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _131_里式转换复习
{
    class Person
    {
        public string Name
        {
            get;
            set;
        }
    }
}

Student.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _131_里式转换复习
{
    class Student:Person 
    {
        public int ID
        {
            get;
            set;
        }
    }
}

Teacher.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _131_里式转换复习
{
    class Teacher:Person
    {
        public double Salary
        {
            get;
            set;
        }
    }
}

多态
1、虚方法 virtual
2、抽象类 abstract
3、接口 interface

简单工厂计算器：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    class Program
    {
        static void Main(string[] args)
        {
            //多态：虚方法，抽象类，接口
            while (true)
            {
                try
                {
                    Console.WriteLine("请输入第一个数字");
                    double n1 = Convert.ToDouble(Console.ReadLine());
                    Console.WriteLine("请输入第二个数字");
                    double n2 = Convert.ToDouble(Console.ReadLine());
                    Console.WriteLine("请输入运算符");
                    string opera = Console.ReadLine();
                    CalFather cf = GetCal(opera, n1, n2);
                    double result = cf.GetResult();
                    Console.WriteLine("结果为：{0}", result);
                }
                catch
                {
                    Console.WriteLine("请输入正确格式！！！");
                }
            }
            Console.ReadKey();
        }
        public static CalFather GetCal(string opera, double n1, double n2)
        {
            CalFather cal = null;
            switch (opera)
            {
                case "+":
                    cal = new Add(n1, n2);
                    break;
                case "-":
                    cal = new Minus(n1, n2);
                    break;
                case "*":
                    cal = new Multiply(n1, n2);
                    break;
                case "/":
                    cal = new Divide(n1, n2);
                    break;
                default:
                    break;
            }
            return cal;
        }
    }
}

CalFather.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    abstract class CalFather
    {
        public double NumberOne
        {
            get;
            set;
        }
        public double NumbweTwo
        {
            get;
            set;
        }
        public CalFather(double n1,double n2)
        {
            this.NumberOne = n1;
            this.NumbweTwo = n2;
        }
        public abstract double GetResult();
    }
}

Add.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    class Add : CalFather 
    {
        public Add(double n1, double n2) : base(n1, n2)
        {
        }
        public override double GetResult()
        {
            return this.NumberOne + this.NumbweTwo;
        }
    }
}

Multiply.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    class Multiply:CalFather
    {
        public Multiply(double n1, double n2) : base(n1, n2)
        {
        }
        public override double GetResult()
        {
            return this.NumberOne * this.NumbweTwo;
        }
    }
}

Minus.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    class Minus:CalFather
    {
        public Minus(double n1, double n2) : base(n1, n2)
        {
        }
        public override double GetResult()
        {
            return this.NumberOne - this.NumbweTwo;
        }
    }
}

Divide.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace _132_多态复习_简单工厂计算器
{
    class Divide:CalFather
    {
        public Divide(double n1, double n2) : base(n1, n2)
        {
        }
        public override double GetResult()
        {
            return this.NumberOne / this.NumbweTwo;
        }
    }
}