讲的什么玩意

25

16

练习8

a.Fun2(b);   // b.Fun1(1); 2        Fun1(5); 5 

b.Fun2(a);   // a.Fun1(1); 1        

                      Fun1(5); 5+1=6 

//用子类构造的，所以调用的是子类里的Fun1

 class ClassA<T>
    {
        private T a;
        private T b;

        public ClassA(T a, T b)
        {
            this.a = a;
            this.b = b;
        }
        public T GetSum()
        {
            dynamic num1 = a;
            dynamic num2 = b;
            return (T)(num1+num2);
        }
    }
static void test02()
        {
            ClassA<int> c1 = new ClassA<int>(45,65);
            int res = c1.GetSum();
            Console.WriteLine(res);
            ClassA<string> c2 = new ClassA<string>("hello ", "world");
            string str1 = c2.GetSum();
            Console.WriteLine(str1);
        }
        
        static void Main(string[] args)
        {
            //test01();
            test02();
        }

 class Vector3
    {
        private double x;
        private double y;
        private double z;
        public double Length()       
        {
            double res=Math.Sqrt(x * x + y * y + z * z);
            Console.WriteLine("res="+res);
            return res;
        }
        public void SetX(double temp)
        {
            if (temp<0)
            {
                return;
            }
            x = temp;
        }
        public void SetY(double temp)
        {
            if (temp < 0)
            {
                return;
            }
            y = temp;
        }
        public void SetZ(double temp)
        {
            if (temp < 0)
            {
                return;
            }
            z = temp;
        }
        public double GetX()
        {
            return x;
        }
        public double GetY()
        {
            return y;
        }
        public double GetZ()
        {
            return z;
        }
    }class Student
    {
        public string name;
        public int age;
        public string address;
        public string createTime;

        public void Show()
        {
            Console.WriteLine("名字：" + name);
            Console.WriteLine("地址：" + address);
            Console.WriteLine("年龄：" + age);
            Console.WriteLine("创建日期：" + createTime);

        }
    }
    class  Vehicle
    {
        public string brand;
        public double speed;
        public double maxSpeed;
        public double weight;
        public void Run()
        {
            Console.WriteLine("车在跑");
        }
        public void Stop()
        {
            Console.WriteLine("刹车");
        }
       
       
    }
    class Program
    {
        static void test02()
        {
            Vehicle car1 = new Vehicle();
            car1.Run();
            car1.Stop();
            Vector3 v1 = new Vector3();
            //v1.SetX(5.6);
            v1.SetY(4.5);
            v1.SetZ(8.45);
            //Console.WriteLine(v1.GetX());
            v1.SetX(-5);//默认是0，没有改变成负数
            Console.WriteLine(v1.GetX());
            Console.WriteLine(v1.Length());
        }
        static void test01()
        {
            Student stu1 = new Student();//声明对象+实例化对象
            Student stu2;//声明对象
            stu1.name = "李四";
            stu1.address = "山西";
            stu1.age = 18;
            stu1.createTime = "11月23日";
            stu1.Show();
            stu2 = new Student();//实例化对象
            
        }
        static void Main(string[] args)
        {
            //test01();
            test02();
        }
    }

//定义类的泛型

class Studen  <T>{

}

<T>   ->    type  //可以指定某一类型

//定义方法泛型

public static T GetSum<T>(T a,T b){
dynamic num1 = a;

dynamic num2 = b;
return (T) (num1 +num2);
 

dynamic  动态类型

list. Remove( )  //删除，通过指定某一个元素进行删除 
list. RemoveAt( )  //根据指定的索引进行移除 

Sort ( )  //数值排序 ，升序。

List<int> list = new List<int>();

Console.WriteLine(list.count+" : "+ list.Capacity);

list.count    代表列表的个数

list.Capacity    表示列表的容量

集合(列表 list)

1，泛型 

List<int> list = new List<int>();
 

子类开始继承

如果没有写Overide关键字，则方法为隐藏方法

1，接口没有返回值,。

2，接口与抽象类的区别

接口：只能包含抽象方法（只有方法的声明，没有方法体）

抽象类：可以包含抽象方法，也可以包含普通方法

3，

类的对象 toString

   // public override void Exam()    重写父类（基类）的方法
        //public new void Exam()   new 关键字可以显式隐藏从(父类)基类继承的成员。

索引关键字   this

public string this[int index]{
get{
return name [index];
}
set{
name[index] = value;
}
}
 

列表的遍历

遍历的两种方式：

1.for循环，遍历所有的索引。

for(int i=0;i<list.Count;i++{

循环体；list[i]

}

2.foreach遍历。

List<int> list = new List<int>(50);
            list.Add(34);list.Add(234);
            foreach(int temp in list)
            {
                Console.WriteLine(temp);
            }

列表的一些常见操作（增加 删除 改 查） 

插入数据：list,Insert（i，list[i]);

删除数据：list.Remove(list[i]);只会移除匹配的第一个数据

修饰符
修饰符，用来类型或者成员的关键字。修饰符可以指定方法的可见性。
public:同一程序集(DLL或EXE)中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。
private:只有同一类或结构中的代码可以访问该类型或成员。
. protected:只有同一类或结构或者此类的派生类中的代码扌可以访问该类型或成员。-internal:同一程序集中的任何代码都可以访问该类型或成员，但的代码不可以。protected internal:在一程序集中，protected internal体现的是internal的性质﹔在其他程序集中，protected internal体现的是protected的性质。
·

public DrivedClass(int attack,int hp,int speed):base(hp,speed){
this.attack = attack;
}
 

这可以调用父类的值，

在子类的构造函数里加冒号:base(hp,speed)  调用父类的构造方法

普通类里是不能包括抽象方法的

抽象方法只能包含在抽象类里，抽象类可以没有抽象方法。

.密封类   se

base.   访问父类里面的成员