异常处理
class Program
{
static void Main(string[] args)
{
try//try块中,只要有一行代码发生异常,try块中后面的代码就不会执行
{
int[] myArray = { 1, 2, 3, 4 };
int myEle = myArray[4];
}
catch (IndexOutOfRangeException e)//当异常类型和该类型相同,执行catch块,如果没有参数,则任何异常都执行catch块
{
Console.WriteLine("发生异常:IndexOutOfRangeException");
Console.WriteLine("访问数组下标越界");
}
catch(NullReferenceException e)
{
Console.WriteLine("发生异常:NullReferenceException");
}
catch//前面已经处理了,后面就不处理,不能放在第一个。
{
Console.WriteLine("发生异常:未知异常");
}
finally//始终会执行的代码
{
Console.WriteLine("Finally执行语句");
}
Console.WriteLine("test");
Console.ReadKey();
}
}
属性的定义,get方法和set方法
class MyClass
{
private int myIntProperty; //一般编程规范定义一个私有的变量
public int MyIntProperty //然后通过public方法来get或者set该变量
{
set
{
myIntProperty = value;
Console.WriteLine("属性中的set被调用");
Console.WriteLine("SET块中访问value的值是:" + value);
}
get//如果没有get块,就不能通过属性取值
{
Console.WriteLine("属性中的get被调用");
return myIntProperty;
}
}
public string Name { get; set; }//编译器会自动给我们提供一个字段来存储name
}
//下面是对该类的调用
class Program
{
static void Main(string[] args)
{
MyClass myclass = new MyClass();
myclass.MyIntProperty = 10;
int temp = myclass.MyIntProperty;
Console.WriteLine(temp);
myclass.Name = "city";
Console.WriteLine(myclass.Name);
Console.ReadKey();
}
}
匿名类型
static void Main(string[] args)
{
//var可以定义一个变量,可初始化为任意值,但是初始化一次之后就不能再次更改了。
int i = 100;
var j = 1000;
var a = "asdf";
var v1 = new Vector3();
}
继承注意事项
class Program
{
static void Main(string[] args)
{
//父类BaseEnemy,子类Boss,
Boss boss = new Boss();
boss.AI();//父类里面所有的数据成员和函数成员都被继承到子类
BaseEnemy baseEnemy;//父类声明
baseEnemy = new Boss();//父类声明的对象,可以用子类去构造,但是反过来不行
//此时 baseEnemy可以使用Boss的方法
//使用强制类型转换
Boss boss1 = (Boss)baseEnemy;
boss1.Attack();
BaseEnemy baseEnemy1 = new BaseEnemy();//使用父类声明并且实例化
//一个对象是什么类型,就看是什么构造的
//这里的baseEnemy1是父类的构造对象,只有父类的字段
//所以不能强制转换
//Boss boss2 = (Boss)baseEnemy1;
Console.ReadKey();
}
}
虚函数
class Enemy//基类
{
//定义一个虚函数,之后可以在集成类中重写
public void AI()
{
Console.WriteLine("基类的AI方法");
}
public virtual void Move()//定义了一个虚函数
{
Console.WriteLine("基类里面的Move方法");
}
}
class Boss:Enemy//子类,继承父类
{
public override void Move()//关键字override重写该虚函数
{
Console.WriteLine("这里是Boss的Move方法");
}
public void Attack()
{
Move();//这里Move调用的就是重写之后的Move
AI();
}
}
class Program//调用
{
////在子类里面重写虚函数之后,不管在哪里调用,都是调用重写之后的方法,前提是实例化的时候使用的是该子类
static void Main(string[] args)
{
Boss boss = new Boss();//boss中重写了Move
boss.Attack();//使用Boss类的Move
TypeEnemy enemy = new TypeEnemy();//此时使用TypeEnemy实例化的时候,并没有重写Move函数
enemy.Attack();//使用基类的Move
Console.ReadKey();
}
}
//输出
这里是Boss的Move方法
基类的AI方法
基类里面的Move方法
基类的AI方法
隐藏方法:
class Enemy//基类
{
public void Move()
{
Console.WriteLine("父类的Move");
}
}
class Boss:Enemy//子类
{
//在父类中也有个Move方法,但并不是重写了,而是把父类的方法隐藏,实际还存在
public void Move()
{
Console.WriteLine("子类Boss的Move");
}
}
class Program//调用
{
static void Main(string[] args)
{
Boss boss = new Boss();//子类声明
boss.Move();//这个时候直接调用子类的Move
Enemy boss1 = new Boss();//父类声明
boss1.Move();//这个时候调用父类得到Move
Console.ReadKey();
}
}
虚函数和隐藏方法的区别:
在虚函数中,如果子类重写了父类的某方法,那么用该子类实例化的对象就无法使用父类的该方法;
隐藏方法中,并不是对父类的方法进行重写,而是隐藏起来,父类的方法还存在
此时,如果是子类声明的对象,就调用子类的方法,如果是父类声明的对象,就调用父类的方法
抽象类
abstract class Bird_abstractClass//基类,因为类中有抽象方法,所以类也要声明为抽象类
{
private float speed;
public void Eat()
{
}
public abstract void Fly();//当类中有抽象方法的时候,类也需要声明为抽象类,抽象方法没有函数块
}
class Crow : Bird_abstractClass//子类,继承后必须要实现抽象方法
{
public override void Fly()
{
Console.WriteLine("Fly in Crow");
}
}
static void Main(string[] args)//调用
{
Crow crow = new Crow();
crow.Fly();
Bird_abstractClass bird = new Crow();//我们可以抽象类去声明对象,但不能去构造
bird.Fly();
Console.ReadKey();
}
密封类和密封方法_sealed关键字
sealed class BaseClass//说明BaseClass是密封类,此时无法被继承
{
public void Move(){}//注意,密封类中不能再声明新的虚函数,但可以重写基类的虚函数
}
class BaseClass//基类
{
public virtual void Move()
{
}
}
class OverRideBaseClass:BaseClass
{
public sealed override void Move()//只能在子类重写的时候使用sealed声明,表示不能被再次重写
{
base.Move();
}
}
//所以密封类不能被继承,而密封方法只能在重写的时候使用,之后该方法无法再被重写。
static关键字
class StaticClass
{
private int x;
private int y;
public static int z;//静态字段
public static void TestStatic()
{
Console.WriteLine("静态方法");
}
}
class Program
{
static void Main(string[] args)
{
//下面声明sc的时候,只有属性里面的x,y,不包括static定义的静态字段,
//而TestStatic()方法只能通过类名直接访问,不能利用sc访问。
StaticClass sc = new StaticClass();
StaticClass.z = 1;
StaticClass.TestStatic();
Console.ReadKey();
}
}
接口
interface IFly//定义接口,关键字 interface
{//接口只声明,不实现
void Fly();
void MethodA();
void MethodB();
}
interface IDriveFly:IFly//继承接口,和类相似
{
void Method3();
void Method4();
}
class DriveFly : IDriveFly//最后类可以继承接口,需要把接口中的方法全部实现,否则会出现异常。
{
public void Fly()
{
throw new NotImplementedException();
}
public void Method3()
{
throw new NotImplementedException();
}
public void Method4()
{
throw new NotImplementedException();
}
public void MethodA()
{
throw new NotImplementedException();
}
public void MethodB()
{
throw new NotImplementedException();
}
}
泛型
class ClassA<T>//T代表一个数据类型,构造的时候需要指定T的类型
{
private T a;
private T b;
public ClassA(T a,T b)
{
this.a = a;
this.b = b;
}
public string GetSum()
{
return a + "" + b;
}
}
class Program
{
//泛型方法
public static string GetSumm<T>(T a,T b)
{
return a + "" + b;
}
static void Main(string[] args)
{
var o1 = new ClassA<int>(12, 23);//当我们利用泛型类构造的时候,指定了类型
string s = o1.GetSum();
Console.WriteLine(s);
Console.ReadKey();
}
}