C# 练习04

1.this关键字指代自身，指向自己，代表是字段，而不是参数

   通过不同的方式进行初始化

    class Program
    {
        static void Main(string[] args)
        {
            Line l1 = new Line();
            Line l2 = new Line(1, 3, 1, 3);//直接四个数值调用
            Point p1 = new Point(1,1);
            Point p2 = new Point(3,3);
            Line l3 = new Line(p1, p2);//通过两个点调用

            Console.WriteLine("L1距离为{0}",l1.Distance());
            Console.WriteLine("L2距离为{0}", l2.Distance());
            Console.WriteLine("L3距离为{0}", l3.Distance());

        }

      
        
    }

    class Point
    {
        public double X { set; get; }
        public double Y { set; get; }
        public Point()//不给参数时，默认是0
        {
            X = Y = 0;
        }
        public Point(double x, double y)
        {
            X = x;
            Y = y;

        }

    }
    class Line
    {
        public  Point p1;
        public  Point p2;
        public Line()
        {
            p1 = new Point();
            p2 = new Point();//p1p2的值都设置为默认值0
        }

        public Line(double x1,double x2,double y1,double y2)//可以通过四个参数来初始化
        {
            p1 = new Point(x1, y1);
            p2 = new Point(x2, y2);
        }
        public Line (Point p1,Point p2)//可以通过两个点来初始化
        {
            this.p1 = p1;//this关键字指代自身，指向自己，代表是字段，而不是参数
            this.p2 = p2;
        }

        public double Distance()
        {
            return Math.Sqrt((p1.X - p2.X)* (p1.X - p2.X)+(p1.Y-p2.Y)*(p1.Y -p2.Y));
        }

2.复数类

总是先调用派生类的构造函数，但是在调用派生类构造函数时，会转向调用基类构造函数

类默认是从object类来派生的

派生类在构造时，不仅要有自己的参数总表，还要有基类的参数总表，通过base传递给基类。

class Program
    {
        static void Main(string[] args)
        {
            Complex x1 = new Complex(1, 2);//有new，分配了空间，将其句柄传递给x1
            Complex x2 = new Complex(2.5, 3.6);
            Complex x3 = x1.Add(x2);//x3只是一个句柄，是x1中计算的结果返回的temp，其句柄被复制
            //让x3也指向了temp的空间  函数调用结束后，temp这个句柄会被销毁，但是由x3要使用其指向的空间，所以空间不会被回收
            Complex x4 = Complex.Add(x1, x2);
            x3.ShowMe();
            x4.ShowMe();

        }
    }

    public class Complex
    {
        private double real;
        private double image;//目前只能通过构造函数来改变private的值

        public Complex ()
        {
            real = 0;
            image = 0;
        }

        public Complex (double real,double image)//没有设置成属性，两个同时设置
        {
            this.image = image;
            this.real = real;
        }
        public void Set(double real, double image)//用来改变private的值   可以在构造函数内调用set,但是不能在set里调用构造函数
        {
            this.image = image;
            this.real = real;
        }

        public double  GetReal()
        {
            return real;
        }
        public double GetImage()
        {
            return image;
        }

        public Complex Add(Complex x)
        {
            Complex temp = new Complex();
            temp.image = this.image + x.image;//自己和传递进来的数相加
            temp.real = this.real + x.real;
            return temp;
        }

        public static Complex  Add (Complex x,Complex y)//static可以直接通过类名来调用
        {
            Complex temp = new Complex();//传递两个复数类型就行
            temp.real = x.real + y.real;
            temp.image = y.image + x.image;
            return temp;
        }

        public Complex Sub(Complex x)
        {
            Complex temp = new Complex();
            temp.image = this.image - x.image;//自己和传递进来的数相加
            temp.real = this.real -x.real;
            return temp;
        }
        public void ShowMe()
        {
            Console.WriteLine("{0}+{1}i", this.real, this.image);
        }
    }