C#（五）：接口、泛型、struct、继承、方法的隐藏与重写、密封、抽象、多态

妖狐艹你老母 2024-03-30 12:03 76阅读 0赞

#### 接口、泛型、struct、继承、方法的隐藏与重写、密封、抽象、多态 ####

*   *  接口
     *   *  用途
         *  特点
         *  语法
         *  代码
     *  泛型
     *   *  使用在类中的泛型-特点：
         *  使用在方法中的泛型-特点：
         *  使用在接口中的泛型-特点：
     *  struct
     *   *  结构体是 \`值类型\` \`struct\`
         *  结构体与类的区别
     *  继承
     *   *  示例
         *  继承之构造方法
         *  向上转型(隐式类型转换) - 子类转换成父类
         *  向下转型(需要强制类型转换) - 父类转换成子类
     *  方法的隐藏与重写
     *   *  方法隐藏
         *  方法重写
     *  密封
     *   *  密封类
         *  密封方法
     *  抽象
     *   *  \`抽象类\`
         *  \`抽象方法\`
     *  多态 \`virtual\` \`abstract\` \`interface\`

### 接口 ###

#### 用途 ####

*  定义一系列的规范

#### 特点 ####

*  接口中方法不是抽象方法（接口中方法的实现不能使用 override）
 *  接口中方法的实现必须是 public 权限的
 *  抽象类实现接口方法可以把接口方法实现为抽象方法
 *  一个类中实现接口方法可以把方法实现为虚方法

#### 语法 ####

*  一个类可以实现多个接口
 *  一个类继承另一个类并且实现接口需要把接口下载继承类的后边，并用逗号分隔
 *  区分接口与继承规范：接口命名以大写字母I开头

#### 代码 ####

interface IUSB
    {
        
        // 充电
        public void Charge();
        // 数据传输
        void TransportData();
    }
    
    class Hardware {
        }
    
    // 让Mouse去实现USB这个接口
    class Mouse : Hardware, IUSB
    {
        
        // 一个类中实现接口方法可以把方法实现为虚方法
        public virtual void Charge() {
         }
        public void TransportData() {
         }
    }
    
    // 抽象类实现接口方法可以把接口方法实现为抽象方法
    abstract class Keyword : IUSB
    {
        
        public abstract void Charge();
        public void TransportData() {
         }
    }

### 泛型 ###

#### 使用在类中的泛型-特点： ####

class Program
    {
        
        static void Main(string[] args)
        {
        
            // 使用一个泛型
            Person<int> person = new Person<int>();
    
            person.Show(23);
    
            // 使用多个泛型
            Animal<string, uint, char> animal = new Animal<string, uint, char>
            {
        
                name = "Dog",
                age = 23,
                sex = '男'
            };
    
            Console.WriteLine(animal.name);
            Console.WriteLine(animal.age);
            Console.WriteLine(animal.sex);
    
        }
    }
    
    class Person<T> {
        
        public T Show(T x) 
        {
        
            Console.WriteLine(x);
            return x;
        }
    }
    
    class Animal<T, M, D>
    {
        
        public T name;
        public M age;
        public D sex;
    }
    
    class Animal<T, M>
    {
        
        public T name;
        public M age;
    }
    class Animal
    {
        
        public string name;
        public uint age;
    }
    
    class Dog : Animal
    {
        
    
    }
    
    class Lee : Person<string>
    {
        
    
    }

#### 使用在方法中的泛型-特点： ####

class Program
     {
        
         static void Main(string[] args)
         {
        
             Person.Show<string>();
    
             Person.Show<string>("Hello World ~");
    
             Person.Show("Hello World ~");
    
             Console.ReadKey();
    
         }
     }
    
     class Person {
        
         public static void Show<T>()
         {
        
             Console.WriteLine("Hello World");
         }
    
         public static void Show<T>(T x) 
         {
        
             Console.WriteLine(x);
         }
     }

#### 使用在接口中的泛型-特点： ####

interface IUSB<T> {
        
        void Show(T x);
    }
    
    class Mouse : IUSB<string> {
        
        public void Show(string x)
        {
        
            Console.WriteLine(x);
        }
    }

### struct ###

#### 结构体是 `值类型` `struct` ####

struct Person
    {
        
    	// 静态构造
    	static Person(){
        }
    
    	// 有参构造
    	public Person(string name, int age, char sex, double height) {
        
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    		this.height = height;
    	}
    
    	//字段
    	public string name;
    	public int age;
    	public char sex;
    	public double height;
    	public static double weight; // 静态字段
    	
    	//属性
    	public double Height
    	{
        
    		set {
        
    			this.height = value;
    		}
    		get {
        
    			return height;
    		}
    	}
    	
    	//方法
    	public void FunA() {
        
    		Console.WriteLine("Person Show ~");
    	}
    };
    
    class Program
    {
        
    	static void Main(string[] args)
    	{
        
    	
    		Person lee = new Person
    		{
        
    			age = 23
    		};
    		
    		Change(lee);
    		
    		Console.WriteLine(lee.age); // 230
    		
    		Console.ReadKey();
    		
    	}
    		
    	public static void Change(Person person) {
        
    		person.age = 230;
    	}
    }

#### 结构体与类的区别 ####

*  `相同点`：
    
     *  都可以包含字段属性和方法
     *  都可以通过new来实例化
     *  都可以配置访问权限修饰符
 *  `不同点`：
    
     *  结构体是在栈上开辟的空间，是值类型，不是引用类型
        
            class Person
            {
                    
            	public int age;
            };
            
            class Program
            {
                    
            	static void Main(string[] args)
            	{
                    
            	
            		Person lee = new Person();
            		
            		lee.age = 23;
            		
            		Change(lee);
            		
            		Console.WriteLine(lee.age); // 230
            		
            		Console.ReadKey();
            		
            	}
            
            	public static void Change(Person person) {
                    
            		person.age = 230;
            	}
            }
        
            struct Person
            {
                    
            	public int age;
            };
            
            class Program
            {
                    
            	static void Main(string[] args)
            	{
                    
            	
            		Person lee = new Person();
            		
            		lee.age = 23;
            		
            		Change(lee);
            		
            		Console.WriteLine(lee.age); // 23
            		
            		Console.ReadKey();
            	
            	}
            	
            	public static void Change(Person person) {
                    
            		person.age = 230;
            	}
            }
     *  构造方法
        
         *  结构体中不允许写无参构造
         *  结构体的有参构造方法中必须为所有的字段进行赋值操作
            
                struct Person
                {
                          
                
                	public Person(string name, int age, char sex, double height) {
                          
                		this.name = name; // 必须赋值
                		this.age = age; // 必须赋值
                		this.sex = sex; // 必须赋值
                		this.height = height; // 必须赋值
                	}
                	
                	//字段
                	public string name;
                	public int age;
                	public char sex;
                	public double height;
                }
         *  结构体中始终包含一个public无参的构造方法，所以 `Person p = new Person();` 不报错
     *  结构体中不允许写析构函数
     *  结构体中只有一个父类 `Object` ，不能被继承也不能继承

### 继承 ###

1.  如果多个类中拥有共同的属性和方法，那么可以提取出公共的属性和方法定义为一个新类，此类即为 `父类(基类/超类)`
2.  多个具有相同属性和方法的类被称为 `子类(派生类)`
3.  他们之间的关系是： `子类 继承 父类`
4.  特点：  
    a. 子类拥有父类的所有字段、属性和方法。  
    b. 构造方法不能被继承。  
    c. 一个类只能有一个父类，可以拥有多个子类。

#### 示例 ####

> 定义一个硬件类，包括 CPU 硬盘 内存 显卡 主板 电源 类，他们拥有共同属性为 名称 价格 属性

class MainClass
    {
        
        public static void Main(string[] args)
        {
        
            CPU cpu = new CPU
            {
        
                Name = "CPU"
            };
            cpu.SetPrice(100d);
            Console.WriteLine(cpu.Name); // CPU
            Console.WriteLine(cpu.GetPrice()); // 100
    
            GPU gpu = new GPU
            {
        
                Name = "GPU"
            };
            gpu.SetPrice(120d);
            Console.WriteLine(gpu.Name); // GPU
            Console.WriteLine(gpu.GetPrice()); // 120
        }
    }
    
    /// <summary>
    /// 硬件类 - 父类
    /// </summary>
    class Hardware
    {
        
        public string Name;
        private double Price;
    
        public void SetPrice(double price)
        {
        
            Price = price;
        }
    
        public double GetPrice()
        {
        
            return Price;
        }
    }
    
    /// <summary>
    /// CPU 继承 硬件
    /// </summary>
    class CPU : Hardware {
         }
    
    /// <summary>
    /// 显卡 继承 硬件
    /// </summary>
    class GPU : Hardware {
         }
    
    /// <summary>
    /// 硬盘 继承 硬件
    /// </summary>
    class Disk : Hardware {
         }
    
    /// <summary>
    /// 内存 继承 硬件
    /// </summary>
    class Memory : Hardware {
         }
    
    /// <summary>
    /// 主板 继承 硬件
    /// </summary>
    class MainBoard : Hardware {
         }
    
    /// <summary>
    /// 电源 继承 硬件
    /// </summary>
    class PowerSupply : Hardware {
         }

#### 继承之构造方法 ####

*  报错代码
    
        Dog dog = new Dog(); // Error 子类在实例化的时候会先实例化父类中的无参构造方法
        
        class Animal {
              
        
            public string name;
        
            public Animal(string name)
            {
              
                this.name = name;
            }
        
        }
        
        class Dog : Animal {
               // Error
        
            public uint age;
        
        }
 *  报错原因：
    
     *  原因一：`子类在实例化的时候会先实例化父类中的无参构造方法,因为Animal中无无参构造方法`
        
         *  解决（方案一）：`父类提供一个无参构造方法`
            
                Dog dog = new Dog();
                
                class Animal {
                          
                
                    public string name;
                
                    public Animal()
                    {
                          
                    }
                
                    public Animal(string name)
                    {
                          
                        this.name = name;
                    }
                
                }
                
                class Dog : Animal {
                          
                
                    public uint age;
                
                }
     *  原因二：`子类在实例化的时候会先实例化父类中的构造方法,因为Animal中是有参的构造方法,所以需要在子类构造之前先调用父类中的有参构造方法`
        
         *  解决（方案二）：`类构造之前先调用父类中的有参构造方法`
            
                Dog dog = new Dog();
                
                class Animal {
                          
                
                    public string name;
                
                    public Animal(string name)
                    {
                          
                        this.name = name;
                    }
                
                }
                
                class Dog : Animal {
                          
                
                    public uint age;
                
                    // base(参数) -> 执行Dog构造方法之前先去执行他的父类构造方法
                    public Dog() : base("") 
                    {
                          
                    }
                
                }
     *  解决思想：`想办法让父类实例化的时候合理化（让父类实例化的时候不会报错）`

#### 向上转型(隐式类型转换) - 子类转换成父类 ####

*  向上转型一定成功
    
        Dog dog = new Dog();
        Animal animal = dog;
        // => Animal animalDog = new Dog();
        // => sbyte b = 1; int a = b; => int ab = 1;
        
        class Animal {
               }
        class Dog : Animal {
               }
        class Hashiqi : Dog {
               }
 *  示例：动物园动物录入
    
        class MainClass
        {
              
            public static void Main(string[] args)
            {
              
                Animal.RecordAnimal(new Bird()); // 录入动物
                // => 详单于
                // Animal animal = new Bird(); // 向上转型
                // Animal.RecordAnimal(animal);
            }
        }
        
        class Animal {
              
            public static void RecordAnimal(Animal animal) {
               }
        }
        class Bird : Animal {
               }
        class Monkey : Animal {
               }
        class Tiger : Animal {
               }
 *  向上转型后的对象将不再能够使用子类中特有的字段属性和方法
    
        class MainClass
        {
              
            public static void Main(string[] args)
            {
              
                Hashiqi hashiqi = new Hashiqi();
                hashiqi.type = ""; // ok
                hashiqi.sex = ' '; // ok
                hashiqi.name = ""; // ok
                hashiqi.age = 1; // ok
        
        
                Dog dog = new Dog();
                //dog.type = ""; // Error “Dog”未包含“type”的定义，并且找不到可接受第一个“Dog”类型参数的可访问扩展方法“type”
                dog.sex = ' '; // ok
                dog.name = ""; // ok
                dog.age = 1; // ok
        
                Animal animal = new Animal();
                //animal.type = ""; // Error “Animal”未包含“type”的定义，并且找不到可接受第一个“Animal”类型参数的可访问扩展方法“type”
                //animal.sex = ' '; // Error “Animal”未包含“sex”的定义，并且找不到可接受第一个“Animal”类型参数的可访问扩展方法“sex”
                animal.name = ""; // ok
                animal.age = 1; // ok
        
        
                Animal d = new Hashiqi();
                //d.type = ""; // Error “Animal”未包含“type”的定义，并且找不到可接受第一个“Animal”类型参数的可访问扩展方法“type”
                //d.sex = ' '; // Error “Animal”未包含“sex”的定义，并且找不到可接受第一个“Animal”类型参数的可访问扩展方法“sex”
                d.name = ""; // ok
                d.age = 1; // ok
        
                Dog dd = new Hashiqi();
                //dd.type = ""; // Error “Dog”未包含“type”的定义，并且找不到可接受第一个“Dog”类型参数的可访问扩展方法“type”
                dd.sex = ' '; // ok
                dd.name = ""; // ok
                dd.age = 1; // ok
            }
        }
        
        class Animal {
              
            public string name;
            public int age;
        }
        class Dog : Animal {
              
            public char sex;
        }
        class Hashiqi : Dog {
              
            public string type;
        }

#### 向下转型(需要强制类型转换) - 父类转换成子类 ####

*  如果向下转型失败，那么得到 `null`
    
        // Dog dog = (Dog)new Animal(); // 不推荐
        Dog dog = new Animal() as Dog;
        Console.WriteLine(dog == null); // True
        
        class Animal {
               }
        class Dog : Animal {
               }
        class Hashiqi : Dog {
               }
 *  转型成功
    
        class MainClass
        {
              
            public static void Main(string[] args)
            {
              
                Animal animal = new Dog(); // 向上转型
                Dog dog = animal as Dog; // 向下转型
        
                Console.WriteLine(dog); // Dog
                Console.WriteLine(dog == null); // False
            }
        }
        
        class Animal {
               }
        class Dog : Animal {
               }
        class Hashiqi : Dog {
               }
 *  向下转型错误示例
    
        class MainClass
        {
              
            public static void Main(string[] args)
            {
              
                Hashiqi hashiqi = new Animal() as Hashiqi; // 向下转型
                Console.WriteLine(hashiqi == null); // True
                Console.WriteLine(hashiqi.type == null); // Error System.NullReferenceException
            }
        }
        
        class Animal {
              
            public string name;
            public int age;
        }
        class Dog : Animal {
              
            public char sex;
        }
        class Hashiqi : Dog {
              
            public string type;
        }

### 方法的隐藏与重写 ###

#### 方法隐藏 ####

*  父类中含有的字段属性和方法，在子类中也需要定义类似的字段属性和方法，那么就需要隐藏继承自父类的字段属性和方法
    
        class MainClass
        {
              
            public static void Main(string[] args)
            {
              
                Animal a = new Dog();
                a.Show(); // Animal.Show() -> Animal Show
        
                Dog d = new Dog();
                d.Show(); // Dog.Show() -> Dog Show
            }
        }
        
        class Animal {
              
            public void Show() {
              
                Console.WriteLine("Animal Show");
            }
        }
        
        class Dog : Animal {
              
            
            // public void Show()
        
            // 父类中含有name属性，子类还需要定义name属性，需要隐藏继承父类的属性，需要使用new
            public new void Show()
            {
              
                Console.WriteLine("Dog Show");
            }
        
        }

#### 方法重写 ####

*  需要使用关键字 `override` 和 `虚函数(virtual)`
    
     *  虚函数 -> 能被子类隐藏和重写
     *  非虚函数 -> 能被子类隐藏，不能被重写
     *  重写函数
        
            class MainClass
            {
                    
                public static void Main(string[] args)
                {
                    
                    Animal a = new Dog();
                    a.Show(); // Animal.Show() -> Dog Show  因为被重写了
            
                    Dog d = new Dog();
                    d.Show(); // Dog.Show() -> Dog Show
            
                }
            
            }
            
            class Animal {
                    
            
                // 子类中的方法重写父类中的方法，需要将父类中的方法设置为虚函数 virtual
                public virtual void Show() {
                    
                    Console.WriteLine("Animal Show");
                }
            
            }
            class Dog : Animal {
                    
            
                // 子类中的方法重写父类中的方法 override
                public override void Show()
                {
                    
                    Console.WriteLine("Dog Show");
                }
            
            }
     *  隐藏函数
        
            class MainClass
            {
                    
                public static void Main(string[] args)
                {
                    
                    Animal a = new Dog();
                    a.Show(); // Animal.Show() -> Animal Show
            
                    Dog d = new Dog();
                    d.Show(); // Dog.Show() -> Dog Show
            
                }
            
            }
            
            class Animal {
                    
            
                // 子类中的方法重写父类中的方法，需要将父类中的方法设置为虚函数 virtual
                public virtual void Show() {
                    
                    Console.WriteLine("Animal Show");
                }
            
            }
            class Dog : Animal {
                    
            
                // 隐藏父类方法
                public new void Show()
                {
                    
                    Console.WriteLine("Dog Show");
                }
            
            }

### 密封 ###

#### 密封类 ####

*  特点：不能被继承
    
        sealed class Person {
               }
        class Lee : Person {
               } // Error “Lee”: 无法从密封类型“Person”派生

#### 密封方法 ####

*  特点：不能被继续重写，并且只有重写方法才能使用密封
    
        class Animal {
              
            public virtual void Show() {
               }
        }
        class Dog : Animal {
              
            public override sealed void Show() {
               }
        }
        class Hashiqi : Dog{
              
            public override void Show() {
               } // Error “Hashiqi.Show()”: 继承成员“Dog.Show()”是密封的，无法进行重写
        }
    
        class Animal {
              
            public virtual sealed void Show() {
               } // Error 因为“Animal.Show()”不是重写，所以无法将其密封
        }

### 抽象 ###

*  定义一种规范，用于约束子类的行为

#### `抽象类` ####

*  不能实例化对象
 *  抽象类中可以写静态和非静态的成员
 *  抽象类可以被继承和继承其他类

#### `抽象方法` ####

*  抽象方法只能存在在抽象类中
    
     *  一个类继承自抽象类，那么这个类中必须实现父类中的所有抽象方法
        
            // 抽象类
            abstract class Animal {
                    
                // 抽象方法
                public abstract void Eat();
            }
            class Dog : Animal {
                    
                // 通过重写实现父类中的所有抽象方法
                public override void Eat() {
                     }
            }

### 多态 `virtual` `abstract` `interface` ###

> 实现多态主要有3种方法: `虚方法`，`抽象类`，`接口`