在實際項目中，當我們設計一個父類時，經常會遇到這個類不能確定它的具體執行流程的。比如我設計一個文件類：
[csharp]
public class AFile
{
private string name = string.Empty;
private string path = string.Empty;
private FileType type = FileType.IsUnknown;
public string Name
{
get
{
return name;
}
}
public string Path
{
get
{
return path;
}
}
public FileType Type
{
get { return type; }
}
public AFile(string name, string path, FileType type)
{
this.name = name;
this.path = path;
this.type = type;
}
public void Copy(string destPath)
{
//不知道怎麼寫，因為可能是文件還可能是文件夾，如果是壓縮的還要解壓
}
}
public enum FileType
{
IsUnknown = 0,//類型不明
IsFile = 1,//文件
IsDirectory =2,//文件夾
IsCompression//壓縮的
}
public class AFile
{
private string name = string.Empty;
private string path = string.Empty;
private FileType type = FileType.IsUnknown;
public string Name
{
get
{
return name;
}
}
public string Path
{
get
{
return path;
}
}
public FileType Type
{
get { return type; }
}
public AFile(string name, string path, FileType type)
{
this.name = name;
this.path = path;
this.type = type;
}
public void Copy(string destPath)
{
//不知道怎麼寫，因為可能是文件還可能是文件夾，如果是壓縮的還要解壓
}
}
public enum FileType
{
IsUnknown = 0,//類型不明
IsFile = 1,//文件
IsDirectory =2,//文件夾
IsCompression//壓縮的
}
這是一個父類，它的copy方法，應該怎麼寫呢？因為文件存在四種狀態甚至後來根據需要還可能再加，針對不同的文件類型，拷貝方法是不一樣的，而且根據項目需要還可能針對某種文件做一些特殊處理。這樣再設計這個父類時就不能對copy方法寫代碼，只需要誰繼承它誰就重寫這個方法，根據需要寫不同的執行代碼。
這樣，一個類具有某個方法，但是該方法沒有具體執行過程，這樣的方法稱之為“抽象方法”。
上面的AFile類中Copy方法就叫抽象方法，但是隨之有一個問題，如果實例化了這個AFile類，Copy方法也就是這個對象的行為了，但實際上Copy方法還不確定。這樣不符合客觀事物規律。因此，這個類是不能被實例化的，也就是說當類中有抽象方法時，這個類不能被實例化，這樣的類稱之為“抽象類”。抽象不能被實例化，但它還是類。抽象類和抽象方法用abstract關鍵字修飾。
可以看到，抽象類中就存在了兩種方法：抽象方法和非抽象方法。
非抽象方法，抽象類被繼承，子類擁有非抽象方法，可以直接使用，也可以重寫覆蓋。
抽象類，必須覆蓋重寫。
修改上述的文件類：
[csharp]
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace YYS.CSharpStudy.MainConsole
{
public abstract class AFile
{
private string name = string.Empty;
private string path = string.Empty;
private FileType type = FileType.IsUnknown;
public string Name
{
get
{
return name;
}
}
public string AFilePath
{
get
{
return path;
}
}
public FileType Type
{
get { return type; }
}
public AFile(string name, string path, FileType type)
{
this.name = name;
this.path = path;
this.type = type;
}
public abstract void Copy(string destPath);
}
public enum FileType
{
IsUnknown = 0,//類型不明
IsFile = 1,//文件
IsDirectory =2,//文件夾
IsCompression//壓縮的
}
/// <summary>
/// 文件類
/// </summary>
public class FileInfo : AFile
{
public FileInfo(string name, string path, FileType type)
: base(name, path, type)
{
}
/// <summary>
/// 文件的拷貝方法
/// </summary>
public override void Copy(string destPath)
{
if (string.IsNullOrEmpty(destPath))
{
string sourcePath = this.AFilePath + this.Name;
//此時name是文件名，帶有後綴名，加起來是文件路徑
destPath += this.Name;
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destPath, true);
}
}
}
}
/// <summary>
/// 文件夾類
/// </summary>
public class FileDirectoryInfo : AFile
{
public FileDirectoryInfo(string name, string path, FileType type)
: base(name, path, type)
{
}
/// <summary>
/// 文件的拷貝方法
/// </summary>
public override void Copy(string destPath)
{
if (string.IsNullOrEmpty(destPath))
{
string sourcePath = this.AFilePath + this.Name;
//此時文件名是文件夾名，加起來是文件夾路徑
destPath += this.Name;
if (Directory.Exists(sourcePath))
{
CopyDirectory(sourcePath, destPath);
}
}
}
/// <summary>
/// 拷貝文件夾的方法
/// </summary>
private void CopyDirectory(string sourcePath, string destPath)
{
try
{
if (!Directory.Exists(destPath))
{
Directory.CreateDirectory(destPath);
}
DirectoryInfo directoryInfo = new DirectoryInfo(sourcePath);
foreach (FileSystemInfo fileInfo in directoryInfo.GetFileSystemInfos())
{
string subFileOrDirectoryName = Path.Combine(destPath, fileInfo.Name);
if (fileInfo is DirectoryInfo)
{
this.CopyDirectory(fileInfo.FullName, subFileOrDirectoryName);
}
else
{
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destPath, true);
}
}
}
}
catch{}
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace YYS.CSharpStudy.MainConsole
{
public abstract class AFile
{
private string name = string.Empty;
private string path = string.Empty;
private FileType type = FileType.IsUnknown;
public string Name
{
get
{
return name;
}
}
public string AFilePath
{
get
{
return path;
}
}
public FileType Type
{
get { return type; }
}
public AFile(string name, string path, FileType type)
{
this.name = name;
this.path = path;
this.type = type;
}
public abstract void Copy(string destPath);
}
public enum FileType
{
IsUnknown = 0,//類型不明
IsFile = 1,//文件
IsDirectory =2,//文件夾
IsCompression//壓縮的
}
/// <summary>
/// 文件類
/// </summary>
public class FileInfo : AFile
{
public FileInfo(string name, string path, FileType type)
: base(name, path, type)
{
}
/// <summary>
/// 文件的拷貝方法
/// </summary>
public override void Copy(string destPath)
{
if (string.IsNullOrEmpty(destPath))
{
string sourcePath = this.AFilePath + this.Name;
//此時name是文件名，帶有後綴名，加起來是文件路徑
destPath += this.Name;
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destPath, true);
}
}
}
}
/// <summary>
/// 文件夾類
/// </summary>
public class FileDirectoryInfo : AFile
{
public FileDirectoryInfo(string name, string path, FileType type)
: base(name, path, type)
{
}
/// <summary>
/// 文件的拷貝方法
/// </summary>
public override void Copy(string destPath)
{
if (string.IsNullOrEmpty(destPath))
{
string sourcePath = this.AFilePath + this.Name;
//此時文件名是文件夾名，加起來是文件夾路徑
destPath += this.Name;
if (Directory.Exists(sourcePath))
{
CopyDirectory(sourcePath, destPath);
}
}
}
/// <summary>
/// 拷貝文件夾的方法
/// </summary>
private void CopyDirectory(string sourcePath, string destPath)
{
try
{
if (!Directory.Exists(destPath))
{
Directory.CreateDirectory(destPath);
}
DirectoryInfo directoryInfo = new DirectoryInfo(sourcePath);
foreach (FileSystemInfo fileInfo in directoryInfo.GetFileSystemInfos())
{
string subFileOrDirectoryName = Path.Combine(destPath, fileInfo.Name);
if (fileInfo is DirectoryInfo)
{
this.CopyDirectory(fileInfo.FullName, subFileOrDirectoryName);
}
else
{
if (File.Exists(sourcePath))
{
File.Copy(sourcePath, destPath, true);
}
}
}
}
catch{}
}
}
}
這樣，就完成了抽象類的繼承並實現。但是如果子類繼承了抽象類，但是並沒有實現抽象方法，那麼這個子類也將作為一個抽象類存在。有抽象方法的類叫做抽象類，對於有些情況，沒有抽象方法的類，也可以使用abstract關鍵字定義為抽象類，這樣表明該類不能被抽象，必須被繼承。
作者：yysyangyangyangshan
