Unity之本周总结知识点

来源：互联网发布：南极金字塔知乎编辑：程序博客网时间：2024/05/22 11:39

风云雄起-U3d培训班-学习笔记

一周的学习过去了，总结一下这周讲的知识笔记。

1.枚举类型：

定义：枚举类型是一种只类型，它用于声明一组命名的常数。

若要定义这些值，可以用枚举类型。枚举类型是使用enum关键字声明的。

枚举的声明：枚举声明用于声明新的枚举类型。

格式：访问修饰符 enum 枚举名：基础类型

{

枚举成员

}

例：

枚举成员默认值：

1.在枚举成员中声明的第一个枚举成员他的默认值为零。

2.以后的枚举成员值是将前一个枚举成员（按照文本顺序）的值加1得到的。这样增加后的值必须在该基础类型可表示的值的范围内；否则，会出现编译时错误。

枚举类型与基础类型的转换：

1.基础类型不能隐式转换为枚举类型

2.枚举类型也不能隐式转换为基础类型

例：

System.Enum类型

1.System.Enum类型是所有枚举类型的抽象基类，并且从System.Enum继承的成员在任何枚举类型中都可用。

2.System.Enum本身不是，枚举类型。相反，它是一个类型，所有枚举类型都是从它派生的。

3.System.Enum从类型System.ValueType派生。

2.常量

1.使用 const 关键字来声明某个常量字段或常量局部变量。常量字段和常量局部变量不是变量并且不能修改。

2.常量可以为数字、布尔值、字符串或 null 引用。不要创建常量来表示你需要随时更改的信息。

const float PI=3.14f;

PI=3.2f;//错误

常量一般都大写，也可以用静态来修饰，调用时可以直接用类名.常量的形式来用。

3.只读字段

1.当字段声明中包括readonly修饰符时，该字段成为只读字段。只能在声明只读字段的同时赋初值。其他任何时候都不允许为只读字段赋值。

2.如果在类定义中显式添加一个构造函数，可以在构造函数中改变只读字段的值。

常量：定义时，必须给常量赋值，不能再次赋值；

只读字段：定义时，必须给只读字段赋值，可以在构造函数内再次赋值（只能在构造函数内）。

4.修饰符

C#共有五种访问修饰符：public、private、protected、internal、protected internal。

访问范围由大到小：public--protected internal--internal--protected--private

5.异常

1、C# 语言的异常处理功能可帮助您处理程序运行时出现的任何意外或异常情况。

2、异常处理使用 try、catch 和 finally 关键字尝试某些操作，以处理失败情况，尽管这些操作有可能失败，但如果您确定需要这样做，且希望在事后清理资源，就可以尝试这样做。

3、异常是使用 throw 关键字创建的。

异常(try...catch throw finally)

1.对于给定的 try 子句，可以有一个以上的 catch 子句，每个 catch 捕捉不同的异常类型。导出类型必须始终列在任何基类型之前。

2.throw语句用于发出在程序执行期间出现异常情况的信号。

3.finally 构造用于指定即使发生异常也始终会运行的代码。finally 通常用于清理发生异常时所产生的内容。如果没有finally，这一级的资源就不好释放了

6.继承

（1）继承提供了创建新类的一种方法，继承对开发者来说就是代码共享。

（2）通过继承创建的子类是作为另一个类的扩充或修正所定义的一个类。

（3）子类从超类(父类)中继承所有方法和变量。

（4）子类和超类之间是特化与范化的关系。

子类的声明

（1）语法：子类声明:父类{子类体}

class Son : Father//子类继承父类

（2）子类可以使用父类的protected和public可见的变量和方法，就像这些变量和方法是自己定义的一样。

class Father

{

//可以用public或者private

//protected int a = 2;

public int a = 2;

public Father()

{

Console.WriteLine("我是父类的里面的构造方法");

}

（3）私有成员和方法其实已经被继承了，但是它们却不可以被访问，因为私有成员和方法只能被声明它们的类中才可访问，所以看上去像是没有被继承。

（4）C# 中，如果类声明时没有声明父类，那么缺省为Object 类的子类。C#中的所有类都是System.Object类的子类。

（5）C#中，子类只能继承一个父类，但一个基类可以有多个直接派生类。继承是可以传递的

Sealed

sealed 修饰符，此修饰符会阻止其他类从该类继承

方法隐藏

如果子类方法的方法名和基类的方法名相同时，系统将隐藏基类同名方法，自动调用子类的同名方法

在这里的举例根据前面的例子连接着来：Son

//Son类

class Son : Father//子类继承父类

// sealed class Son:Father//子类继承父类

{

public Son()

: base(10)

{//显示调用父类里面的带参数的构造方法

Console.WriteLine("我是子类的里面的构造方法");

}

static void Main(string[] args)

{

Son son = new Son();//默认先调用父类构造方法，然后再次调用子类构造方法

//son.Get();

// Console.WriteLine( son.a);

Console.ReadKey();

}

派生类的建立需要注意：

(1).派生类会继承基类除了构造函数和析构函数的所有成员。

(2).派生类调用构造函数时，会先调用基类的构造函数。默认调用没有参数的构造函数。

(3).用base关键字显式调用基类构造函数（如果基类定义了带有参数的构造函数，那么此构造函数必须被执行，且在派生类中实现该构造函数，此时我们可以使用base关键字）

7.用属性来实现封装

属性是C#引入的一种语言成分，只有很少的语言支持属性。通过对属性的读和写来保护类中的域。第一种方法体身也是一种好的方式，但用属性来实现封装会更方便

例子：
             private   string   name;
             public    string    Name{
                  set{
                          name=value;
                              }
                  get{
                  return name;
                             }
                               }
              Person P=new Person();
                 P.Name="张三";
              string   name=P.Name;
              Console.WriteLine(name);

}
使用属性的好处：在于对象的使用者可以用一条语句来操作内部的数据

8.抽象类

1.abstract定义类和方法
2.实现一部分，剩下的子类来完成
3.抽象类是父类
例子:
abstract   class  Father(只声明没实现的)
public   abstract   void   Get();//只声明
class son:Father(剩下的用子类来实现)
public   override    void   Get(){}
注：1.抽象类不能被实例化，子类可以实例化
2.父类中方法可以是抽象和非抽象的
3.子类必须实现抽象类所有抽象方法
4.在一子类前加"abstract"，实现一方法，再在另一子类前加"abstract",实现另一方法
5.abstract和seald,static不能一起使用（不能为密封修饰）1.abstract定义类和方法

例子:
      abstract   class  Father(只声明没实现的)
      public   abstract   void   Get();//只声明
      class son:Father(剩下的用子类来实现)
      public   override    void   Get(){}

9.接口

1.属于任何类或结构的一组相关功能

2.定义：interface关键字定义，可由方法，属性，事件，索引器这四种成员类型的任意组合组成

例子：interface EatBehairor{}

接口的特征：

1、接口类似于抽象基类，不能直接实例化接口；接口中的方法都是抽象方法，实现接口的任何非抽象类型都必须实现接口的所有成员。

2、接口不能包含常量、字段、运算符、实例构造函数、析构函数或类型、不能包含静态成员。

3、接口成员是自动公开的，且不能包含任何访问修饰符。

4、接口自身可从多个接口继承，类和结构可继承多个接口，但接口不能继承类。

例子：

interface IProgram
    {
        void Fun();
    }
    class Program：IProgram
    {
         //显式实现接口成员
        void IProgram。Fun()
        {
            Console.WriteLine("I am Fun.");
        }
        staticvoid Main(string[] args)
        {
            IProgram p =new Program();  //声明一个接口实例，但不是对接口进行实例化
            p.Fun();
            Console.Read();
        }
    }

5.一般情况，当类或者结构要实现的是单个接口，可以使用隐式实现。

6.如果类或者结构继承了多个接口且接口中具有相同名称成员时，就要用到显式实现，当显式实现方式存在时，隐式实现方式就失效了。

接口的继承：

接口继承和类继承不同：

1.类继承不仅是说明继承，而且也是实现继承；而接口继承只是说明继承。

2.类继承只允许单继承，但是接口继承允许多继承，一个子接口可以有多个父接口。

interface IProgram
    {
        void Fun();
    }
    interface IAProgram:IProgram
    {
    }
class Program :  IAProgram
    {
       void IProgram.Fun()
        {
            Console.WriteLine("I am IProgram Fun.");
        }

       staticvoid Main(string[] args)
        {
            Program pro =new Program();
            ((IAProgram)pro).Fun();
        }
    }
接口的覆盖：

一个类如果实现了某个接口那么它必须覆盖该接口中的所有方法

interface IProgram
    {
        void Fun();
    }
    abstract  class AProgram : IProgram
    {
        public abstract void AFun();
        void IProgram.Fun()
        {
            AFun();
        }
    }
class Program:AProgram
    {
        public override void AFun()
        {
            Console.WriteLine("I am AProgram.");
        }
        staticvoid Main(string[] args)
        {
            IProgram pro =new Program();
            pro.Fun();
        }
    }

接口和抽象类的区别

1.接口用于规范，抽象类用于共性。

2.接口中只能声明方法，属性，事件，索引器。而抽象类中可以有方法的实现，也可以定义非静态的类变量。

3.抽象类是类，所以只能被单继承，但是接口却可以一次实现多个。

4.抽象类可以提供某些方法的部分实现，接口不可以。

5.抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的。

6.在抽象类中加入一个方法，那么它的子类就同时有了这个方法。而在接口中加入新的方法，那么实现它的类就要重新编写（这就是为什么说接口是一个类的规范了）。

7.接口成员被定义为公共的，但抽象类的成员也可以是私有的、受保护的、内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序的代码或派生类中访问）。

8.此外接口不能包含字段、构造函数、析构函数、静态成员或常量。

更多精彩关注http://unity.gopedu.com

0 0