C#进阶继承

最新推荐文章于 2024-02-15 13:26:24 发布

今夕何处

最新推荐文章于 2024-02-15 13:26:24 发布

阅读量251

点赞数

分类专栏： C#相关知识文章标签： c#

本文链接：https://blog.csdn.net/weixin_42411048/article/details/107733125

版权

C#相关知识专栏收录该内容

5 篇文章 0 订阅

订阅专栏

继承

单根性： 一个派生类(子类)只能继承一个基类(父类)，不能同时继承多个父类。
传递性： 基类可以依次继承下去。
protected ： 受保护的，在有关系的类中可以直接访问，在没关系的类中无法访问。

查看类图： Vis鼠标右键 —>视图—>查看类图
object: 是所有类的基类

特性：

子类是只能继承父类的共有属性(public), private关键字修饰的无法继承。
构造函数无法继承

创建子类对象：
先会优先创建一个父类对象再创建子类对象(让子类拥有父类的成员)，创建父类对象时默认调用的是无参构造函数。

父类有有参构造函数子类继承报错处理：

自己在父类中写一个无参构造函数，让父子默认调
使用base(parameter1，parameter, …),强制要求父类调用有参构造

namespace ConsoleApplication1
{
    class Person
    {
        public Person(string Na) //写个有参构造函数
        {
            this._name = Na;
        }
        
        protected string _name;	//字段私有，跟Person类有关系的类可以访问
        public string Name //共有属性，让外部可以访问_name
        {
            get { return _name; }
            set { _name = value; }
        }
        public void Func()
        {
            Console.WriteLine("I'm person, name is {0}", this.Name);
        }
    }


    class Woman : Person	//Woman 继承 Person
    {
        public Woman(string Name, int Id) : base(Name) //让父类调用有参构造
        {
            _id = Id;
        }
        
        int _id;
        public int Id	//子类特有字段
        {
            get { return _id; }
            set { _id = value; }
        }
        
        public void FuncId()	//子类特有方法
        {
            Console.WriteLine("My id is {0}，{1}", this.Id, _name);
        }
        
         public new void Func()	//默认隐藏父类的Func，只使用子类的Func
        {
            Console.WriteLine("I'm person, name is {0}", this.Name); //Woman 继承于Person，可以访问protected 修饰的字段
        }
  
    }
     class Boy:Person
    {
        public Boy(string name) : base(name)
        {
        	//无参构造函数
        }
    }
}

里氏转换：

子类可以给父类赋值

Woman Lili = new Woman("Lili", 123); //创建一个子类对象Lili
Person Superman = Lili;		//把子类对象Lili 赋值给父类对象Superman
使用实例：
string Str = String.Join("|", new string[] { "1", "2", "3", "4" }); //new sting[] 创建一个子类对象

如果父类中装的是子类对象，那么可以把这个父类强制转换为子类

Woman Lili = new Woman("Lili", 123);	 //创建一个子类对象Lili
Person Superman = Lili;		//把子类对象Lili 赋值给父类对象Superman
Woman Yinyin = (Woman)Superman;	//把父类Superman 强制转换为子类Yinyin

当父类强制转换给的子类与父类中的子类类型不同时会抛异常

static void Main(string[] args)
{
     person Superman = new Boy("Lgx");  //创建一个子类对象Lili
      
      /* 方法一 */
     if(Superman is Boy)  //如果Superman是Boy类型则转换，否则输出错误
     {
          Boy Yinyin = (Boy)Superman; //把父类Superman 强制转换为子类Yinyin
     }
     else
     {
	  Console.WriteLine("Swithc fail")；//Superman不是Boy类型
     }
     
	/* 方法 二 */
	Boy Handsome = Superman as Boy; //as把Superman转换为Boy类型的对象，如果转换失败返回null,成功返回对应的对象
	if(Handsome == null)
	{
	   Console.WriteLine("Switch fail");
	}
	
}

泛型类泛型方法：

泛型：不指定参数类型，声明时定义。

泛型类：

定义一个类，这个类中某些字段的类型是不确定的，这些类型可以在构造的时候确定下来

class Person<T> // T 属于未知数据类型，可以在构造的时候指定
{
    private T a;
    private T b;
    public Person(T a, T b) //构造函数
    {
        this.a =a;
        this.b = b;
    }
    
    public string GetValue()
    {
        return a + " " + b;
    }
}

Person man = new Person<int>(1, 2); //构造时指定T的数据类型为int
sting s1 = man.GetValue();

var men = new Person<string>("www.","baidu.com"); //构造时指定T的数据类型为string
string s2 = men.GetValue();

泛型方法：

定义一个方法，这种方法的参数类型可以是不确定的，可以当调用这个方法的时候再去确定方法的参数类型。

//实现了任意类型组拼成字符串的方法，可以是int，double，string等类型
public static string GetSum<T>(T a,T b)
{
    return  a + "" + b;
} 
Console.WritrLine(GetSum(12,34));

//多种类型的定义
public static string GetSum2<T1, T2, T3>(T1 a, T2 b, T3 c)
{
    return a + "" + b + ""  + c;//定义了三种参数，三种都使用
}
Console.WriteLine(GetSum<int,double,string>(2,2.1,"34"));

public static string GetSum2<T1, T2, T3>(T1 a, T2 b)
{
    return a + "" + b;//定义了三种参数，只用了两种
}
Console.WriteLine(GetSum<int,double,string>(2,2.1));//但是定义时需要都要写上，参数调用时用两个

集合

ArrayList:

可以放入任何类型的数据组成一个集合。
长度都以前面开辟的倍数增长，可用count(当前元素个数)跟capcity(当前开辟的空间大小)查看。

static void Main(string[] args)
{
      ArrayList List = new ArrayList();
      List.Add(1);    //集合中放入int类型
      List.Add(3.14); //集合中放入double 类型
      List.Add("this is C#"); //集合中放入字符串
      List.AddRange(new int[] { 1, 2, 3, 4, 5 }); //集合中放入数组
      List.Add(List); //输出自己的命名空间
      
      List.Remove(3.14);  //移除3.14这个元素
      List.RemoveAt(0);   //移除下标为0的元素
      List.RemoveRange(0, 3); //移除下标为 0 - 3 的所有元素
      
      //List.Sort();    //排序，元素类型差不多才行，否则抛异常
      List.Reverse(); //反转List
      
      List.Insert(0, "hello world"); //在下标为0的元素前插入一个元素"hello world"
      List.InsertRange(1, new int[] { 1,2,3,4});  //在下标1的元素前插入数组
      bool Judege = List.Contains("3.14"); //判断是否包含3.14
      if (Judege == true)
      {
           List[1] = 9.99; //如果有3.14则替换为9.99
      }
      else List[1] = 3.14;
      
      for (int i = 0; i < List.Count; i++)
      {
           Console.WriteLine(List[i]); //依次输出集合中的元素
      }
      
      List.Clear();
}

HashTable:

HashTable称为键值对集合，根据键找值

 static void Main(string[] args)
{
     Hashtable Table = new Hashtable();
     Table.Add(0, "hello");  //键是0， 值是“hello”
     Table.Add(1, "world");  //键是1， 值是“world”
     Table.Add(2, 3.14);     //键是2， 值是“3.14”
     Table.Add(3, 123);      //键是3， 值是“123”
     Table[4] = "what";	     //可以通过下标赋值，也可修改原有下标的值
     Table[0] = 999;	     //Table.Add(0, 999)报错，键必须唯一值可以不唯一
     
     
     /* 方法一输出 */
    for (int i = 0; i < Table.Count; i++)
     {
         Console.WriteLine(Table[i]);
     }
	/* 方法二 */
    foreach (var item in Table.Keys) //item的值在Table.Keys中
     {
         Console.WriteLine(Table[item]);
     }
    foreach (var item in Table.Values) //item的值在Table.Values中
    {
        Console.WriteLine(item);	//直接输入item就是值	
    }
    	
    Table.Remove(2); //移除键2的值
}

C#跟C C++都是强类型语言，使用前必须先定义
var a = “hello world” //var推断类型，它可以自己推断a是什么类型，使用时必须初始化。
C++ 中使用auto， C语言中都默认添加auto定义(auto int a;)
js是门弱语言类型，可以直接给值，根据值推算类型。

List 泛型集合：
list跟数组差不多只要类型固定就只能装这种类型的数据，但是长度可变。

static void Main(string[] args)
{
    /* 其它跟以上集合相类似的操作这儿不做演示了 */
     List<int> list = new List<int>();
     list.Add(1);
     list.Add(2);
     list.Add(3);
     list.Add(4);
     list.AddRange(new int[] { 4,3,2,1,0});
     int array = list.ToArray();    //把集合转为数组
     list = array.ToList(); //把数组转为集合
     for (int i = 0; i < list.Count; i++)
     {
          Console.WriteLine(list[i]);
     }
}

键值对集合(字典集合)：
键值对集合在实例化时就固定了键的类型，值的类型。
Dictionary<int, string> dic = new Dictionary<int, string>();

static void Main(string[] args)
        {
            Dictionary<int, string> Dic = new Dictionary<int, string>();
            Dic.Add(0 ,"hello");
            Dic.Add(1, "world");
            Dic.Add(2, "Lili");
            Dic.Add(3, "Yinyin");
            Dic[1] = "yueyue";
            foreach (KeyValuePair<int, string> kv in Dic) //kv及包括键的值，也包括键对应的值
            {
                Console.WriteLine("key:{0}, value:{1}", kv.Key, kv.Value);
            }
        }

将简体字转为繁体：

static void Main(string[] args)
        {
            string data = "这是晴朗的一天，为什么我还要苦逼学习";
            string msg = "這是晴朗的一天，為什麽我還要苦逼學習";
            Hashtable Table = new Hashtable();
            for (int i = 0; i < data.Length; i++)
            {
            	/* 注意键中不能出现相同的键，否则键过头了会出事 */
                Table.Add(data[i], msg[i]);
            }
            Console.WriteLine("Please input");
            
            string input = Console.ReadLine();
            for (int i = 0; i < input.Length; i++)
            {
                if (Table.ContainsKey(input[i]))
                {
                    Console.Write(Table[input[i]]); //查找对应的繁体字
                }
                else 
                {
                    Console.Write(input[i]);
                }
            }
        }

Path类基本操作：

static void Main(string[] args)
{
string str = @"C:\abc\a\b\c\name.txt ";
string FileNameEx = Path.GetFileName(str); //根据路径得到文件名加扩展名
string FileName = Path.GetFileNameWithoutExtension(str); //不要扩展名，只要文件名
string Ex = Path.GetExtension(str); //获取扩展名
string DirName = Path.GetDirectoryName(str); //获取文件夹名字
string FullPath = Path.GetFullPath(str); //获取绝对路径
string Combine = Path.Combine(@"c:\hello\" , "worl.txt"); //拼接路径
}

文件操作(小文件)：

直接起抬着水缸倒过来，碰见水缸水太多你肯定抗不住。

File.Create(@"C:\abc\a\b\c\name.txt "); //创建一个文件
File.Delete(@"C:\abc\a\b\c\name.txt "); //删除一个文件
File.Copy(@"C:\abc\a\b\c\name.txt ", @"C:\abc\a\b\c\hello.txt "); //拷贝一个文件
File.Move(@"C:\abc\a\b\c\name.txt ", @"C:\abc\a\b\c\hello.txt ") //移动文件

读取文件：
byte[] msg = File.ReadAllBytes(@"C:\abc\a\b\c\name.txt "); //将数据从文件中读取处来
string FileData = Encoding.Default.GetString(msg); //将字节数组转换为字符串
Encoding.GetEncoding(“utf-8”).GetString(msg); //可以自己指定读取的编码格式

以文本文件的形式读取：

 string str = File.ReadAllLines(@"C:\abc\a\b\c\name.txt ", Encoding.Default); //按行读取并且指定读取格式
 foreach(string item in str) 
 {
  Console.WriteLine(item);
 }

 string str = File.ReadAllText(@"C:\abc\a\b\c\name.txt ", Encoding.Default); //按行读取并且指定读取格式 
 Console.WriteLine(str);

写文件：
string FileData = “hello world”;
byte[] data = Encoding.Default.GetBytes(FileData);
File.WriteAllBytes(@"C:\abc\a\b\c\name.txt ", data);

/* 按行写入数据 */
 File.WriteAllLines(@"C:\abc\a\b\c\name.txt ", new string[] { "hello", "world"});

/* 按文本的形式写入 */
 File.WriteAllText(@"C:\abc\a\b\c\name.txt ", "hello world");
 File.AppendAllText(@"C:\abc\a\b\c\name.txt ", "hello world") //以追加的形式写入数据

流操作文件方式：

把水缸中的水一点一点的舀过来，你一次能舀多少自己可量力而为。
流的方式读文件：

static void Main(string[] args)
{
     FileStream ReadFile = new FileStream(@"C:\abc\a\b\c\name.txt ", FileMode.OpenOrCreate, FileAccess.Read);
     int size = 0;
     byte[] buf = new byte[1024];
     size = ReadFile.Read(buf, 0, buf.Length);
     string str = Encoding.Default.GetString(buf, 0, size);
     Console.WriteLine(str);
     ReadFile.Close();   //关闭打开的文件
     ReadFile.Dispose(); //释放资源
     }

流的方式写文件：
利用using自动释放资源

static void Main(string[] args)
{
     //using（创建资源，创建成功走大括号执行）， using执行完资源自动释放
   using (FileStream WriteFile = new FileStream(@"C:\abc\a\b\c\name.txt ", FileMode.Open, FileAccess.Write))
   {
        string str = "hello world";
        byte[] buf = Encoding.Default.GetBytes(str);
        WriteFile.Write(buf, 0, buf.Length);
        Console.WriteLine(str);
   }       
}

StreamReader和StreamWriter：
StreamReader和StreamWriter是用于操作字符的，也就是文本文件。

static void Main(string[] args)
        {
            // StreamReader和StreamWriter
            using (StreamReader read = new StreamReader(@"C:\abc\a\b\c\name.txt", Encoding.Default)) //按行读取
            {
                while (!read.EndOfStream)    //判断是否读到文件尾
                {
                    Console.WriteLine(read.ReadLine());	//读出显示
                }
            }
            
            using (StreamWriter Write = new StreamWriter(@"C:\abc\a\b\c\name.txt"))
            {
                Write.Write("hello world"); //把hello world写入name.txt中
            }
        }

编码格式：
编码格式：将字符串以怎样的形式的二进制保存在计算机中。

装箱和拆箱：
装箱：将值类型转换为引用类型
拆箱：将引用类型转换为值类型
int a = 10;
object c = a; //装箱操作
int b = (int)c; //拆箱操作

看有没有装箱拆箱操作，要看两种类型是否有继承关系。
string str = “12345”；
int n = Convert.ToInt32(str); //没有装箱拆箱操作

今夕何处

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C#进阶继承

继承单根性：一个派生类(子类)只能继承一个基类(父类)，不能同时继承多个父类。传递性：基类可以依次继承下去。protected ：受保护的，在有关系的类中可以直接访问，在没关系的类中无法访问。查看类图： Vis鼠标右键 —>视图—>查看类图object: 是所有类的基类特性：子类是只能继承父类的共有属性(public), private关键字修饰的无法继承。构造函数无法继承创建子类对象：先会优先创建一个父类对象再创建子类对象(让子类拥有父类的成员)，创建父类对象时默
复制链接

扫一扫