c#学习笔记002days

002days

1. 抽象类
2. 接口
3. 结构体和静态类和密封
4. 命名空间
5. 运算符重载

抽象类

using System;
//抽象类
#region
/*       1.用关键字abstract来修饰的类
                 （1）.不能实例化对象
         2.特点：（2）.抽象类中既可以写静态的成员也可以写非静态的成员
                 （3）抽象类可以被继承

                    （1）用关键字abstract修饰的方法就是抽象方法
抽象类：3.抽象方法：（2）抽象方法使用abstract修饰，只有声明，没有实现
                    （3）抽象方法只能写在抽象类中：1.如果一个非抽象类继承自一个抽象类那么子类必须要重写父类中所有的抽象方法
     
        4.用途：一种规范，用来约束所有子类的行为
 */
#endregion
namespace 抽象类
//抽象方法
{   //定义人的行为，会说话
    public abstract class People
    {
        public abstract void say();
    }
    //只要满足会说话的子类，都是人类的子类
    public class Hero : People
    {
        //通过重写来实现父类中的抽象方法
        public override void say()
        {

        }

    }
}
   

接口

using System;
//interface
//定义一个USB借口
//接口方法不是抽象方法，也不需要访问权限
//实现接口方法方法应该注意：1.接口中的方法必须为public权限
//                          2.实现接口方法不能使用overvide
//                          3.抽象类实现接口，可以把接口实现为抽象方法
//                          4.接口中的方法可以被实现虚方法
//      接口的命名以大写I的开头
//语法：如果一个类的后面既有父类也有接口，一定是父类在前
//      一个类可以实现多个接口
//       
//转型  由实现类类型转型为接口类型  向上转型
//      由接口类型转型为实现类类型  向下转型
//接口中还可以写属性访问器
//实现类中需要一个属性age，并提供set和get访问器
interface USB
{
    void Charge();

}
class people : USB
{
    public void Charge()
    {

    }
}
namespace 接口
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

结构体和静态类和密封

using System;
//结构体
#region
/*
                                  1.都包含字段、属性、方法
                          相同点：2.修饰的访问权限
                                  3.都是通过关键字new来实例化对象的
 结构体和类基本是一样的：
                          不同的：1.结构体对象是在栈上开辟的空间
                                  2.结构体是值类型，不是引用类型
                                  3.构造方法：1.结构体中不允许写无参构造，但是可以写静态无参构造
                                              2.结构体的有参构造方法中，必须要给所有的字段进行赋值  
                                              3.结构体中始终包含一个public权限的无参的构造方法                     
                          结构体中不允许写析构方法
                          结构体中只有一个父类叫做Object：1.不能被其他的结构体或类继承
                                                          2.也不能继承自其他的结构体或者类*/
#endregion
//静态类
#region
/*
             1.由static修饰的类就是静态类
 
                    1.不能实例化对象
     静态类： 2.特点：2.静态类中不能有非静态的成员
                    3.静态类的继承和结构体一样，只有一个父类Object
              
            
             3.用途：用来设计工具类         
     */
#endregion
//密封：关键字：sealed
#region
/*

                       用来修饰类：1.叫做密封类
                                   2.不能被继承
         sealed的用途:
                                     1.叫做密封方法
                       用来修饰方法：2.不能被继续重写
                                     3.只有在override方法可以被密封;            
             */
#endregion

namespace housebook3
{
  
    class Program
    {//结构体
        #region
        public struct point
        {
            public int a;
            public int b;
            //结构体的有参构造方法中，必须要给所有的字段进行赋值  
            public point(int a,int b)
            {
                this.a = a;
                this.b = b;
               
            }
            //但是可以写静态无参构造,静态的构造方法不能有访问权限和参数
            static point() { }
        }
        #endregion
        //静态类
        #region
        static class SON
        {
            static int a;
            static int A
            {
                get { return a; }

            }
            static SON() { }
        }
        #endregion
        
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

命名空间

//命名空间：一个虚拟的集合
//命名空间中的元素只能是类、结构体、枚举、接口类型
//命名空间可以防止类名的重复，以及更好的来管理类
using space0;
using space2;
namespace space0
{
    class a{
}
class b { }
}
//命名空间的名称允许重复，并且如果有多个命名空间的名字是一样的，那么他们是同一个命名空间；
namespace space0
{
   // class a { }//因为是同一个所有会出错
}
//命名空间可以嵌套命名空间
namespace space2
{    class s { }
  // 这个命名空间叫做space2.space2
    namespace space2
    {class ss { }
        // 这个命名空间叫做space2.space2.space2
        namespace space2
        {class sss { }
        }
    }

}
namespace space1
{
    class a { }
    class Program
    {
        public static void Main(string[] angs)
        {//实例化一个对象
            //默认会使用当前命名空间中的a类
            a a = new a();
            //如果想要使用space0中的a类
            space0.a aa = new space0.a();
            //或者需要在开头使用using space0
            //实例化space0中的类
            b b = new b();
            //因为没有using system
            System.Console.WriteLine();
            System.Int32 a1;//等同于开头使用using System 这里用 int a;

            s s = new s();
            space2.space2.ss ss = new space2.space2.ss();
            space2.space2.space2.sss sss = new space2.space2.space2.sss();
        }
    }
}

运算符重载

using System;
//运算符重载
#region
/*           1.通过特定的语法，使某些运算符可以具备特殊的功能
 *           2.关键字：operator
                                 （1）算术运算符：全部可以重载
                                 （2）赋值运算符：全部不能重载
             3.可以重载的运算符：（3）关系运算符：全部可以重载                                  如果重载了>必须重载<
                                                  如果想要重载关系运算符，那么必须要成对的重载：如果重载了>=必须重载<=
                                                                                                如果重载了==必须重载!=
                                  (4)逻辑运算符：& |  ！ ^可以被重载
                                                 &&  || 不能重载

                                 （5）位运算符：~可以被重载
运算符重载 ：
            4. 注意事项:(1)、参数的数量一定要和这个运算符能够操作的数量匹配
                        (2)、参数类型和返回值类型可以随意设置的，但要合情合理
 */
#endregion
namespace 重载运算符
{   public struct point
    {
        public int x;
        public int y;
        public point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        //运算符重载，使加号有新的功能
        //实现两个point对象直接相加，得到一个新的点
        //重载运算符必须是public和static;
        static public point operator +(point a, point b)
        {
            return new point(a.x + b.x, a.y + b.y);
        }

}
    class Program
    {
        static void Main(string[] args)
        { point a = new point(2, 3);
                point b = new point(3, 4);
                point c = a + b;
            Console.WriteLine("{0},{1}",c.x,c.y);
           
        }
    }
}