则足以将以此父类强转为子类对象,is和as判别转变来功失败

1.复习
里氏转变:
壹)、子类能够赋值给父类(固然有二个主意供给三个父类作为参数,我们得以传第多个子类对象)
二)、即便父类中装的是子类对象,则能够将这一个父类强转为子类对象

1.复习
里氏调换:
一)、子类能够赋值给父类(假使有二个主意需求贰个父类作为参数,我们得以传第二个子类对象)
二)、倘诺父类中装的是子类对象,则能够将那几个父类强转为子类对象

is和as剖断转变来功战败

is和as决断调换成功失利

图片 1图片 2

图片 3图片 4

 1 Person p = new Student();
 2 //if(p is Student)
 3 //{
 4 // ((Student)p).StudentSayHello();
 5 //}
 6 //else
 7 //{
 8 // Console.WriteLine("转换失败");
 9 //}
10 Student ss = p as Student;
11 ss.StudentSayHello();
12 Console.ReadKey();
 1 Person p = new Student(); 2 //if(p is Student) 3 //{ 4 // p).StudentSayHello(); 5 //} 6 //else 7 //{ 8 // Console.WriteLine; 9 //}10 Student ss = p as Student;11 ss.StudentSayHello();12 Console.ReadKey();

View Code

View Code

在键值对中,键必须是唯1的
查阅键值对聚聚集的数据用foreach循环查看,依据键来猜度值

在键值对中,键必须是唯一的
翻开键值对聚聚焦的数据用foreach循环查看,根据键来推测值

Path能够获取文件名,目录,路线等
Path和File都以静态类

Path能够得到文件名,目录,路线等
帕特h和File都是静态类

ReadAllBytes() 读数据 Encoding.Default.GetString(字节数组)
byte[] buffer =
File.ReadAllBytes(@”C:\Users\SJD\Desktop\123.txt”);
//将字节数组中的每二个要素都要依照我们钦命的编码格式解码成字符串
//UTF-8 GB2312 GBK ASKII Unicode
//UTF八,UTF七,UTF32共同整合的编码格式叫Unicode
//GB2312简体汉语,GBK既有简体也有复杂
//Encoding.Default Default解析存的是如何格式就用什么格式
string s = Encoding.GetEncoding(“GB2312”).GetString(buffer);
Console.WriteLine(s);
Console.ReadKey();

ReadAllBytes() 读数据 Encoding.Default.GetString
byte[] buffer =
File.ReadAllBytes(@”C:\Users\SJD\Desktop\123.txt”);
//将字节数组中的每三个因素都要根据大家钦点的编码格式解码成字符串
//UTF-8 GB2312 GBK ASKII Unicode
//UTF8,UTF柒,UTF3贰手拉手整合的编码格式叫Unicode
//GB231二简体普通话,GBK既有简体也有复杂
//Encoding.Default Default解析存的是怎么着格式就用什么样格式
string s = Encoding.GetEncoding.GetString;
Console.WriteLine;
Console.ReadKey();

WriteAllBytes() 写数据 Encoding.Default.GetBytes(字符串)
string str = “好好学习每1天向上”;
byte[]buffer= Encoding.Default.GetBytes(str);
File.WriteAllBytes(@”C:\Users\SJD\Desktop\new.txt”, buffer);
Console.WriteLine(“写入成功”);
Console.ReadKey();

WriteAllBytes() 写数据 Encoding.Default.GetBytes
string str = “好好学习每一日向上”;
byte[]buffer= Encoding.Default.GetBytes;
File.WriteAllBytes(@”C:\Users\SJD\Desktop\new.txt”, buffer);
Console.WriteLine;
Console.ReadKey();

ReadAllLines()读数据 以行的情势读取,重临三个string类型的数组
string
[]contents=File.ReadAllLines(@”C:\Users\SJD\Desktop\123.txt”,Encoding.Default);
foreach (string item in contents)
{
Console.WriteLine(item);
}
Console.ReadKey();

ReadAllLines()读数据 以行的款型读取,再次回到三个string类型的数组
string
[]contents=File.ReadAllLines(@”C:\Users\SJD\Desktop\123.txt”,Encoding.Default);
foreach (string item in contents)
{
Console.WriteLine;
}
Console.ReadKey();

ReadAllText()读数据 以TEXT的花样读取,再次回到一个string 类型的字符串
string
str=File.ReadAllText(@”C:\Users\SJD\Desktop\123.txt”,Encoding.Default);
Console.WriteLine(str);
Console.ReadKey();

ReadAllText()读数据 以TEXT的样式读取,再次回到四个string 类型的字符串
string
str=File.ReadAllText(@”C:\Users\SJD\Desktop\123.txt”,Encoding.Default);
Console.WriteLine;
Console.ReadKey();

WriteAllLines()写多少 以string类型的数组覆盖写入
File.WriteAllLines(@”C:\Users\SJD\Desktop\new.txt”, new string[] {
“张3”, “李肆”, “王二麻子” });
Console.WriteLine(“写入成功”);
Console.ReadKey();

WriteAllLines()写多少 以string类型的数组覆盖写入
File.WriteAllLines(@”C:\Users\SJD\Desktop\new.txt”, new string[] {
“张三”, “李四”, “王贰麻子” });
Console.WriteLine;
Console.ReadKey();

WriteAllText()写多少 以string类型的字符串覆盖写入
File.WriteAllText(@”C:\Users\SJD\Desktop\new.txt”,
“张三李四王2麻子”);
Console.WriteLine(“写入成功”);
Console.ReadKey();

WriteAllText()写多少 以string类型的字符串覆盖写入
File.WriteAllText(@”C:\Users\SJD\Desktop\new.txt”,
“张3李肆王②麻子”);
Console.WriteLine;
Console.ReadKey();

AppendAllLines(),AppendAllText(),AppendText() 都以充实写入,不掩盖。

AppendAllLines(),AppendAllText(),AppendText() 都以增添写入,不掩盖。

File类最大的弱点是不得不用来读小文件。
因为它读取的艺术是一下子全体读进去,很浪费内存。
读取大文件需求用文件流
读文件的时候用ReadAllText()和ReadAllLines(),读多媒体等文件时用ReadAllBytes()
重回数组能够规范的操作每1行的数据。再次回到字符串只可以重回 三个完好无缺回来。

File类最大的瑕疵是只好用来读小文件。
因为它读取的方法是一下子全方位读进去,很浪费内部存款和储蓄器。
读取大文件须要用文件流
读文件的时候用ReadAllText()和ReadAllLines(),读多媒体等文件时用ReadAllBytes()
回来数组可以正确的操作每一行的多少。再次回到字符串只可以重临 一个一体化回来。

2.绝对路径和相对路线
相对路线:通过给定的那么些门路直接能在自己的Computer中找到那几个文件。
绝对路线:文件相对于应用程序的路线。
放在实施文书的同一目录下里,运转时毫无钦定路径

二.绝对路径和相对路径
相对路线:通过给定的那些门路直接能在自己的微型Computer中找到那么些文件。
相对路线:文件相对于应用程序的路线。
放在实行文书的同一目录下里,运营时毫无内定路径

写代码的时候最佳都使用相对路线,因为相对路线只万幸自家本人的微型Computer能够用。绝对路径在此外计算机都足以用。
开垦中应有尽恐怕接纳相对路线。

写代码的时候最棒都采取绝对路线,因为相对路线只可以在本人要好的Computer能够用。相对路线在别的计算机都足以用。
支付中应有尽恐怕利用相对路线。

三.List泛型集结
ArrayList的收益:壹)、集结的长短可以任意改换
贰)、添增加少的数据类型未有须要,任性的
数码 表明什么项目,里面就要放怎么项目
//创制泛型集合
List<int> list=new list<int>(); 不供给再手动引用命名空间
List泛型集结有ArrayList的功利,集合长度可以随心所欲改动。读取时不须求再强转。
//List泛型集结能够转移为数组
List群集调换为数组
int []nums= List.ToArray();
//创造贰个string类型的泛型集合
List<string> listStr = new List<string>();
//把string类型的泛型集合转变为string类型的数组
string []list= listStr.ToArray();
//把string类型的数组转变为string类型的泛型集结
List<string>listStrTwo= list.ToList<string>();

叁.List泛型集合
ArrayList的受益:1)、集结的尺寸能够随心所欲改换
2)、加多数量的数据类型未有要求,任意的
数据 阐明什么项目,里面将要放怎么品种
//创造泛型集结
List<int> list=new list<int>(); 不要求再手动引用命名空间
List泛型集合有ArrayList的功利,集结长度可以随心所欲改造。读取时不需求再强转。
//List泛型集合能够转换为数组
List集结账和转账换为数组
int []nums= List.ToArray();
//创建一个string类型的泛型集结
List<string> listStr = new List<string>();
//把string类型的泛型会集转变为string类型的数组
string []list= listStr.ToArray();
//把string类型的数组转变为string类型的泛型集合
List<string>listStrTwo= list.ToList<string>();

ArrayList会集和HashTable已经很少有人在用了。取的时候不方便人民群众。

ArrayList群集和HashTable已经很少有人在用了。取的时候不方便人民群众。

4、装箱、拆箱
装箱:正是将值类型调换为引用类型。
拆箱:将引用类型调换为值类型。
int n=10;
object o=n;//装箱
int nn=(int)o;//拆箱
装箱会比平常的要慢(差了10倍),代码中要尽量防止装箱和拆箱
//那些地点尚未发生自便档案的次序的装箱也许拆箱
string str=”123″;
int n=convert.toint32(str);

4、装箱、拆箱
装箱:正是将值类型转换为引用类型。
拆箱:将引用类型调换为值类型。
int n=10;
object o=n;//装箱
int nn=o;//拆箱
装箱会比一般的要慢,代码中要尽量防止装箱和拆箱
//那个地点尚未发生放四档期的顺序的装箱或然拆箱
string str=”123″;
int n=convert.toint32;

看三种档期的顺序是不是爆发了装箱只怕拆箱,要看那两序列型是不是存在继续关系。
一经有三番五次关系,才有相当大希望发生装箱或拆箱,倘若未有继续关系,它们必然不会产生装箱或拆箱。
例:
int n=10;
IComparable i=n;//装箱 IComparable 也是援引类型,并有两次三番关系

看三种等级次序是不是产生了装箱只怕拆箱,要看那三种档次是不是留存继续关系。
只要有三番五次关系,才有希望产生装箱或拆箱,假若没有持续关系,它们必然不会发生装箱或拆箱。
例:
int n=10;
IComparable i=n;//装箱 IComparable 也是援引类型,并有持续关系

5、Dictionary
大多和BashTable是一律的
能够动用键值对来读取
例:
Dictionary<int, string> dic = new Dictionary<int,
string>();
dic.Add(1, “张三”);
dic.Add(2, “李四”);
dic.Add(三, “王贰麻子”);
dic[1] = “新来的”;
foreach (KeyValuePair<int,string> kv in dic)
{
Console.WriteLine(“{0}——{1}”,kv.Key,kv.Value);
}

5、Dictionary
差不离和BashTable是均等的
能够行使键值对来读取
例:
Dictionary<int, string> dic = new Dictionary<int,
string>();
dic.Add;
dic.Add;
dic.Add(三, “王二麻子”);
dic[1] = “新来的”;
foreach (KeyValuePair<int,string> kv in dic)
{
Console.WriteLine(“{0}——{1}”,kv.Key,kv.Value);
}

6、FileStream 文件流
和File的分别,读取文件的距离
五个缸子,A空缸,B装满水。要把B的水装到A里去
File的用法便是把B抬起来一贯把水倒到A里面去。然则会对应用的人产生相当的大的下压力,瘦小的人抗不起那水
FileStream的用法就是用水舀子把B的水1勺1勺舀到A去。每便都舀一勺

6、FileStream 文件流
和File的不一样,读取文件的反差
五个缸子,A空缸,B装满水。要把B的水装到A里去
File的用法正是把B抬起来直接把水倒到A里面去。不过会对利用的人发生比相当大的压力,瘦小的人抗不起那水
FileStream的用法正是用水舀子把B的水一勺1勺舀到A去。每一遍都舀1勺

File读文件是弹指间方方面面读过来
FileStream是一点一点的读(对内部存款和储蓄器基本上没什么压力)

File读文件是一念之差1体读过来
FileStream是一点一点的读(对内部存款和储蓄器基本上没什么压力)

//FileStream 操作字节的,能够操作任何项目的文件.
//StreamReader和StreamWriter 操作字符的,只好操作文本文件。
那三种周旋于File来讲的好处便是他俩能够操作大文件,压力小。
小文件的话用File类就OK了。几百K的

//FileStream 操作字节的,能够操作任何项目标文件.
//StreamReader和StreamWriter 操作字符的,只能操作文本文件。
那二种相持于File来讲的利润便是他们能够操作大文件,压力小。
小文件的话用File类就OK了。几百K的

*****学习.net正是读书它那几个类怎么利用的。会的更加多,越是大拿。
FileStream fsRead = new
FileStream(@”C:\Users\SJD\Desktop\123.txt”,FileMode.OpenOrCreate,FileAccess.Read);
//FileStream fsRead=new
FileStream(一.您要操作的文件的门道,二.你要对文本进行二个怎样操作,三.您要针对性那些文件之中的数额做三个怎么着操作。);
枚举 枚举
开荒后读取
byte[] buffer = new byte[1024 * 1024 * 5];//限定字节数组只好放伍M
//fsRead.Read(1.限定字节,二.象征从哪些地点早先写入数据,三.最多读取的字节数);
int r=fsRead.Read(buffer, 0, buffer.Length);
//返回的Int类型
//唯有三.八M,但本身老是读取伍M 再次来到的r正是这一次次读取实际有效的字节数
//数据都在字节数组里面,看不懂这些事物,所以要把字节数组中每一个因素按小编钦定的编码格式解码成字符串
//将字节数组中每3个要素遵照内定的编码格式解码成字符串
string s= Encoding.Default.GetString(buffer);
//用完了还要关闭流
fsRead.Close();
//释放流所占用的资源
fsRead.Dispose();
GC不能回收文件流
Console.WriteLine(s);
Console.ReadKey();
//有效字节少,大部分打印出来都以空
//超越字节数的就不解码了。
string s=
Encoding.Default.GetString(buffer,0,r);//从0初步解码,解码r个。
//那样解码出来的是r有效字节数,但其实读的依然5M

*****学习.net正是上学它这个类怎么选拔的。会的更加多,越是大咖。
FileStream fsRead = new
FileStream(@”C:\Users\SJD\Desktop\123.txt”,FileMode.OpenOrCreate,FileAccess.Read);
//FileStream fsRead=new
FileStream(1.你要操作的文件的渠道,二.您要对文本进行1个哪些操作,三.你要针对这么些文件之中的数量做三个怎么样操作。);
枚举 枚举
开发后读取
byte[] buffer = new byte[1024 * 1024 * 5];//限定字节数组只好放伍M
//fsRead.Read(壹.限定字节,二.意味从哪个地点初叶写入数据,3.最多读取的字节数);
int r=fsRead.Read(buffer, 0, buffer.Length);
//返回的Int类型
//唯有三.捌M,但本身每回读取⑤M 重返的r就是此次次读取实际可行的字节数
//数据都在字节数组里面,看不懂那么些事物,所以要把字节数组中每1个成分按自个儿钦点的编码格式解码成字符串
//将字节数组中每2个要素依据内定的编码格式解码成字符串
string s= Encoding.Default.GetString;
//用完了还要关闭流
fsRead.Close();
//释放流所占用的能源
fsRead.Dispose();
GC无法回收文件流
Console.WriteLine;
Console.ReadKey();
//有效字节少,超过5/10打字与印刷出来都以空
//超越字节数的就不解码了。
string s=
Encoding.Default.GetString(buffer,0,r);//从0开首解码,解码r个。
//那样解码出来的是r有效字节数,但实质上读的依旧5M

//借使大数量,超越了⑤M,就要循环去读。

//就算大数量,超越了五M,即将循环去读。

//使用FileStream来写入数据

//使用FileStream来写入数据

柒.将开创文件流对象的经过写在using个中,会活动的助手大家释放流所占用的财富。
微软提供的语法,能够不用写fsRead.Close();和fsRead.Dispose();
using()
{

7.将开创文件流对象的进度写在using个中,会活动的相助我们释放流所占用的财富。
微软提供的语法,能够不用写fsRead.Close();和fsRead.Dispose();
using()
{

}
创制对象的长河写在()里,读取和写入写在{ }里面
using (FileStream fsWrite=new
FileStream(@”C:\Users\SJD\Desktop\new.txt”,FileMode.OpenOrCreate,FileAccess.Write))
{
string str = “看本人有未有把你覆盖掉”;
byte[] buffer = Encoding.Default.GetBytes(str);
fsWrite.Write(buffer, 0, buffer.Length);
}
Console.WriteLine(“写入OK”);
Console.ReadKey();

}
创设对象的进度写在()里,读取和写入写在{ }里面
using (FileStream fsWrite=new
FileStream(@”C:\Users\SJD\Desktop\new.txt”,FileMode.OpenOrCreate,FileAccess.Write))
{
string str = “看作者有未有把您覆盖掉”;
byte[] buffer = Encoding.Default.GetBytes;
fsWrite.Write(buffer, 0, buffer.Length);
}
Console.WriteLine;
Console.ReadKey();

写和读用UTF八就不会油不过生乱码
Encoding.UTF8.GetBytes(str);

写和读用UTF八就不会冒出乱码
Encoding.UTF8.GetBytes;

8.FileStream的多媒体拷贝
static void Main(string[] args)
{
//思路:便是先将在复制的多媒体文件读抽出来,然后再写入到您钦赐的岗位。
string source = @”C:\Users\SJD\Desktop\see.mp4″;
string target = @”C:\Users\SJD\Desktop\new.mp4″;
CopyFile(source, target);
Console.WriteLine(“复制OK”);
Console.ReadKey();
}

八.FileStream的多媒体拷贝
static void Main(string[] args)
{
//思路:正是先就要复制的多媒体文件读抽出来,然后再写入到您钦命的地方。
string source = @”C:\Users\SJD\Desktop\see.mp4″;
string target = @”C:\Users\SJD\Desktop\new.mp4″;
CopyFile(source, target);
Console.WriteLine;
Console.ReadKey();
}

public static void CopyFile(string source, string target)
{
//一、大家成立三个肩负读取的流
using (FileStream fsRead = new FileStream(source, FileMode.Open,
FileAccess.Read))
{
//创制二个肩负写入的流
using (FileStream fsWrite = new FileStream(target,
FileMode.OpenOrCreate, FileAccess.Write))
{
byte[] buffer = new byte[1024 * 1024 * 5];
//因为文件或许会一点都不小,所以大家在读取的时候理应经过一个巡回去读取
while (true)
{
//再次回到此番读取实际读取到的字节数
int r = fsRead.Read(buffer, 0, buffer.Length);
//假使回到二个0,也就代表什么都不曾读取到,读取完了
if(r==0)
{
break;
}
fsWrite.Write(buffer, 0, r);
}
}
}
}

public static void CopyFile(string source, string target)
{
//1、大家创立2个担任读取的流
using (FileStream fsRead = new FileStream(source, FileMode.Open,
FileAccess.Read))
{
//创立叁个担负写入的流
using (FileStream fsWrite = new FileStream(target,
FileMode.OpenOrCreate, FileAccess.Write))
{
byte[] buffer = new byte[1024 * 1024 * 5];
//因为文件也许会比比较大,所以大家在读取的时候理应经过一个巡回去读取
while
{
//再次来到这次读取实际读取到的字节数
int r = fsRead.Read(buffer, 0, buffer.Length);
//假诺回到2个0,也就意味着什么都没有读取到,读取完了
if
{
break;
}
fsWrite.Write(buffer, 0, r);
}
}
}
}

9.StreamReader和StreamWriter
FileStream是操作字节的(必须精晓)
StreamReader和StreamWriter是操作字符
//使用StreamWriter来写入3个文书文件 true是扩大写入,不掩盖写入
using (StreamWriter sw = new
StreamWriter(@”C:\Users\SJD\Desktop\new.txt”,true))
{
sw.Write(“看自己有未有把你覆盖掉”);
}
Console.WriteLine(“写入OK”);
Console.ReadKey();

9.StreamReader和StreamWriter
FileStream是操作字节的
StreamReader和StreamWriter是操作字符
//使用StreamWriter来写入四个文件文件 true是增加写入,不掩盖写入
using (StreamWriter sw = new
StreamWriter(@”C:\Users\SJD\Desktop\new.txt”,true))
{
sw.Write(“看自己有未有把您覆盖掉”);
}
Console.WriteLine;
Console.ReadKey();

10.多态
//概念:让贰个目的能够显示出各种的情事(类型)
例:
Chinese cn1 = new Chinese(“韩梅梅”);
Chinese cn2 = new Chinese(“李雷”);
Japanese j1 = new Japanese(“树下君”);
Japanese j2 = new Japanese(“井边子”);
Korea k1 = new Korea(“金秀贤”);
Korea k2 = new Korea(“金贤秀”);
American a一 = new American(“小飞侠Bryant”);
American a2 = new American(“奥尼尔”);
Person[] pers = { cn1, cn2, j1, j2, k1, k2, a1, a2 };
for (int i = 0; i < pers.Length; i++)
{
if(pers[i] is Chinese)
{
((Chinese)pers[i]).SayHello();
}
else if(pers[i]is Japanese)
{
((Japanese)pers[i]).SayHello();
}
else if(pers[i] is Korea)
{
((Korea)pers[i]).SayHello();
}
else
{
((American)pers[i]).SayHello();
}
}
Console.ReadKey();

10.多态
//概念:让2个指标能够展现出多样的动静
例:
Chinese cn1 = new Chinese;
Chinese cn2 = new Chinese;
Japanese j1 = new Japanese;
Japanese j2 = new Japanese;
Korea k1 = new Korea;
Korea k2 = new Korea;
American a1 = new American;
American a2 = new American;
Person[] pers = { cn1, cn2, j1, j2, k1, k2, a1, a2 };
for (int i = 0; i < pers.Length; i++)
{
if(pers[i] is Chinese)
{
pers[i]).SayHello();
}
else if(pers[i]is Japanese)
{
(pers[i]).SayHello();
}
else if(pers[i] is Korea)
{
pers[i]).SayHello();
}
else
{
(pers[i]).SayHello();
}
}
Console.ReadKey();

pers[i].SayHello() 只是为了读取种种子类下相应的主意

pers[i].SayHello() 只是为了读取各类子类下相应的艺术

//达成多态的3种花招:1、虚方法 贰、抽象类 3、接口

//完毕多态的三种花招:一、虚方法 二、抽象类 三、接口

1壹.贯彻多态的手腕
1)、虚方法
步骤:
1、将父类的方式标志为虚方法,使用首要字
virtual,那些函数能够被子类重新写2回
在父类方法重返在此以前加一个virtual
诸如此类就将父类函数标志为虚方法
在子类同名的不二等秘书诀前边加1个override 重写

1一.贯彻多态的手段
1)、虚方法
步骤:
壹、将父类的主意标志为虚方法,使用首要字
virtual,那么些函数能够被子类重新写二次
在父类方法再次来到从前加二个virtual
如此就将父类函数标志为虚方法
在子类同名的办法后面加1个override 重写

调用的如故是父类的靶子,只是那个艺术被再次了,所以调用的是子类的措施。
装的是哪个人的对象,就调用什么人的方式
让一个目的足以显示陆体系型出来,写出通用的代码。最概况义的吊销他们的一个差距性
多态的利润即是削减了不少代码,加强了可发展性。

调用的如故是父类的对象,只是这些形式被重复了,所以调用的是子类的办法。
装的是何人的目的,就调用哪个人的诀窍
让二个对象能够呈现五类别型出来,写出通用的代码。最大效能的裁撤他们的二个差距性
多态的便宜就是减弱了广大代码,加强了可发展性。

动用虚方法 首先要给2个父类 用关键字virtual
给子类 用关键字override

选取虚方法 首先要给三个父类 用关键字virtual
给子类 用关键字override

2)、抽象类
当父类中的方法不知道哪些去达成的时候,能够设想将父类写成抽象类,将艺术写成肤浅方法
用abstract来标识父类 和办法
例:
public abstract class animal
{
public abstract void call();

2)、抽象类
当父类中的方法不亮堂哪些去得以落成的时候,可以思索将父类写成抽象类,将艺术写成肤浅方法
用abstract来标识父类 和措施
例:
public abstract class animal
{
public abstract void call();

}
意思:让子类重写
架空方法必须没有方法体,用abstract标志
因为根本不知晓怎么落到实处这些方法,干脆就不得以达成。抽象类是未曾方法体的
public void Test()
{
//空完毕 有方法体
}

}
意思:让子类重写
泛泛方法必须未有方法体,用abstract标志
因为一贯不领悟怎么落实这几个点子,干脆就不落到实处。抽象类是从未有过方法体的
public void Test()
{
//空达成 有方法体
}

抽象类无法创设对象,接口也是不容许创制对象的

抽象类不可能创设对象,接口也是不允许创立对象的

一.虚无成员必须标志为abstract,并且不可能有任何完毕。
二.虚幻成员必须在抽象类中。
三.抽象类无法被实例化
四.子类承接抽象类后,必须把父类中的全体抽象成员都重写。
(除非子类也是一个抽象类,则能够不重写)
五.虚无成员的走访修饰符不可能是private
陆.在抽象类中得以涵盖实例成员
同时抽象类的实例成员可以不被子类落成
七.抽象类是有构造函数的,纵然不可能被实例化。
八.借使父类的纸上谈兵方法中有参数,那么。承接那一个抽象父类的子类在重写父类的法子的时候必须传入对应的参数
1经抽象父类的思梅止渴方法中有再次来到值,那么子类在重写那么些抽象方法的时候
也不可能不要传播再次回到值

1.虚幻成员必须标识为abstract,并且不可能有别的达成。
2.空洞成员必须在抽象类中。
三.抽象类不能够被实例化
4.子类承袭抽象类后,必须把父类中的全部抽象成员都重写。
(除非子类也是八个抽象类,则足以不重写)
5.虚幻成员的拜会修饰符不可能是private
陆.在抽象类中得以分包实例成员
并且抽象类的实例成员能够不被子类达成
7.抽象类是有构造函数的,固然不可能被实例化。
捌.若是父类的肤浅方法中有参数,那么。承继那几个抽象父类的子类在重写父类的措施的时候必须传入对应的参数
假使抽象父类的肤浅方法中有重回值,那么子类在重写那几个抽象方法的时候
也非得要传播再次回到值

=============
若是父类中的方法由暗中认可的达成,并且父类必要被实例化,那时能够思索将父类定义成3个普通类,用虚方法实现多态。
1经父类中的方法没有默许落成,父类也不须要被实例化,则足以将该类定义为抽象类。

=============
假使父类中的方法由暗中同意的落实,并且父类须要被实例化,那时能够设想将父类定义成二个普通类,用虚方法完结多态。
假若父类中的方法未有私下认可实现,父类也不需求被实例化,则可以将此类定义为抽象类。

在父类中
public abstract void Bark(); 抽象类

在父类中
public abstract void Bark(); 抽象类

public abstract string Name 抽象属性
{
get;
set;
}

public abstract string Name 抽象属性
{
get;
set;
}

测试会开采报错,未有承接。
要承继要去找到子类,光标放在承接后边 shift+alt+f10(达成抽象类)
子类的措施的性质就会重写了。

测试会意识报错,未有持续。
要一连要去找到子类,光标放在承接后边 shift+alt+f10子类的方式的质量就会重写了。

三个子类假设三番五次了两个华而不实的父类,那个子类必须完毕那么些抽象父类中保有的悬空成员
抽象类能够写非抽象成员
父类自个儿不可能创立对象,可是子类承接里面能够用。
故而父类能够有抽象成员也得以有非抽象成员
无法在三个非抽象类中写四个华而不实成员

一个子类如若后续了一个浮泛的父类,这几个子类必须实现那几个抽象父类中享有的虚幻成员
抽象类能够写非抽象成员
父类自个儿不可能创设对象,不过子类承接里面能够用。
所以父类可以有抽象成员也能够有非抽象成员
无法在3个非抽象类中写三个浮泛成员

重回值和参数正是方式里的签字

重临值和参数正是措施里的签名

//使用多态求矩形的面积和周长以及圆形的面积和周长
//Shap shape = new Circle(5);
Shap shape = new Square(5, 6);
double area = shape.GetArea();
double perimeter = shape.GetPerimeter();
Console.WriteLine(“那么些形象的面积是{0},周长是{一}”,area,perimeter);
Console.ReadKey();

//使用多态求矩形的面积和周长以及圆形的面积和周长
//Shap shape = new Circle;
Shap shape = new Square;
double area = shape.GetArea();
double perimeter = shape.GetPerimeter();
Console.WriteLine(“这些形象的面积是{0},周长是{一}”,area,perimeter);
Console.ReadKey();

12.小结
list<T>
Dictionary<Tkey,Tvalue>
比ArrayList的功利正是不会发出拆卸与拼装箱

12.小结
list<T>
Dictionary<Tkey,Tvalue>
比ArrayList的收益正是不会产生拆卸与拼装箱

FileStream 操作字节
SteamReader和StreamWriter 操作字符的
能够操作大文件

FileStream 操作字节
SteamReader和StreamWriter 操作字符的
能够操作大文件

Flie 只好操作小文件

Flie 只可以操作小文件

拆装箱
装箱是值类型到引用类型
拆箱是引用类型到值类型
装箱拆箱都会潜移默化到系统的天性,运行须要时刻。尽量幸免拆装箱

拆装箱
装箱是值类型到引用类型
拆箱是引用类型到值类型
装箱拆箱都会潜移默化到系统的性质,运转须要时间。尽量幸免拆卸与拼装箱

多态
虚方法 父类有落实,父类要求创立对象用虚方法
抽象类 父类没有得以达成,父类不需求创设对象用抽象类
抽象类供给调节一坨特点
接口

多态
虚方法 父类有落到实处,父类要求创造对象用虚方法
空泛类 父类没有落到实处,父类不要求创立对象用抽象类
抽象类要求明白壹坨特点
接口

相关文章