WPF学习（1）--类与类的继承

在面向对象编程中，继承是一种机制，允许一个类（称为子类或派生类）从另一个类（称为父类或基类）继承属性和方法。继承使我们能够创建一个通用类，然后根据需要扩展或修改它以创建更具体的类。以下是一些关于父类和子类以及它们之间继承关系的基本概念和解释。

一、父类、子类及类的继承关系

1.父类（基类）

• 父类是一个通用的类，它定义了一组属性和方法，这些属性和方法可以被多个子类共享。
• 父类通常是较抽象的，表示一个更通用的概念。例如，Animal（动物）类可以是一个父类，表示所有动物的共同属性和行为。

2.子类（派生类）

• 子类是从父类派生出来的类。它继承了父类的所有属性和方法，但也可以添加自己特有的属性和方法。
• 子类表示一个更具体的概念。例如，Cat（猫）类和Dog（狗）类可以是从Animal类派生出来的子类，表示具体的动物种类。

3.继承关系

3.1 继承属性和方法

• 子类继承父类的所有非私有属性和方法。这意味着子类可以直接使用父类中的代码。
• 子类可以覆盖父类的方法（即方法重写），以提供特定于子类的实现。

3.2 继承的语法

• 在C#中，使用冒号:来表示继承。

下面是一个示例：

public class Animal
{
    public string Sound { get; set; }
    public int Age { get; set; }
    public string Color { get; set; }
}

public class Cat : Animal
{
    public Cat()
    {
        Sound = "Meow";
    }
}

public class Dog : Animal
{
    public Dog()
    {
        Sound = "Woof";
    }
}

3.3 示例解释

在上面的示例中：

• Animal类是父类，定义了三个属性：Sound（叫声）、Age（年龄）和Color（颜色）。
• Cat类和Dog类是从Animal类继承的子类。它们各自有一个构造函数，在创建对象时设置Sound属性的默认值。

3.4 使用继承的优点

1. 代码重用:

   • 继承允许子类重用父类中的代码，减少了代码的重复，提高了代码的可维护性。

2. 扩展性:

   • 可以通过继承扩展现有类，而不需要修改原有的代码。这样，系统更容易扩展和维护。

3. 多态性:

   • 继承是实现多态性的一种手段。通过继承，可以使用父类的引用来指向子类的对象，从而实现不同的行为。

二、代码实现

本次代码基于WPF代码实现观察现象

1.C#代码：MainWindow.xaml.cs

using System;
using System.ComponentModel;
using System.Windows;

namespace WpfApp
{
    // 定义动物基类
    public class Animal : INotifyPropertyChanged
    {
        private string sound; // 动物的叫声
        private int age;      // 动物的年龄
        private string color; // 动物的颜色

        // 动物的叫声属性
        public string Sound
        {
            get { return sound; }
            set
            {
                sound = value;
                OnPropertyChanged("Sound");
            }
        }

        // 动物的年龄属性
        public int Age
        {
            get { return age; }
            set
            {
                age = value;
                OnPropertyChanged("Age");
            }
        }

        // 动物的颜色属性
        public string Color
        {
            get { return color; }
            set
            {
                color = value;
                OnPropertyChanged("Color");
            }
        }

        // 实现INotifyPropertyChanged接口，用于属性改变通知
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    // 定义猫类，继承自动物类
    public class Cat : Animal
    {
        public Cat()
        {
            Sound = "Meow"; // 初始化猫的叫声
        }
    }

    // 定义狗类，继承自动物类
    public class Dog : Animal
    {
        public Dog()
        {
            Sound = "Woof"; // 初始化狗的叫声
        }
    }

    // 定义羊类，继承自动物类
    public class Sheep : Animal
    {
        public Sheep()
        {
            Sound = "Baa"; // 初始化羊的叫声
        }
    }

    // WPF窗口的后台代码
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            // 创建动物对象，并设置它们的属性
            Animal cat = new Cat { Age = 3, Color = "Gray" };
            Animal dog = new Dog { Age = 5, Color = "Brown" };
            Animal sheep = new Sheep { Age = 2, Color = "White" };

            // 将动物对象绑定到WPF窗口的DataContext
            DataContext = new { Cat = cat, Dog = dog, Sheep = sheep };
        }
    }
}

2.XAML代码：MainWindow.xaml

<Window x:Class="WpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Animals" Height="300" Width="300">
    <Grid>
        <Grid.RowDefinitions>
            <!-- 定义三个行，每个行用于显示一种动物的信息 -->
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>

        <!-- 猫的边框 -->
        <Border Grid.Row="0" BorderBrush="Black" BorderThickness="1" Margin="5">
            <StackPanel>
                <!-- 显示动物种类名称 -->
                <TextBlock Text="Cat" FontWeight="Bold" HorizontalAlignment="Center"/>
                <!-- 绑定并显示猫的叫声 -->
                <TextBlock Text="{Binding Cat.Sound}" />
                <!-- 绑定并显示猫的年龄 -->
                <TextBlock Text="{Binding Cat.Age}" />
                <!-- 绑定并显示猫的颜色 -->
                <TextBlock Text="{Binding Cat.Color}" />
            </StackPanel>
        </Border>

        <!-- 狗的边框 -->
        <Border Grid.Row="1" BorderBrush="Black" BorderThickness="1" Margin="5">
            <StackPanel>
                <!-- 显示动物种类名称 -->
                <TextBlock Text="Dog" FontWeight="Bold" HorizontalAlignment="Center"/>
                <!-- 绑定并显示狗的叫声 -->
                <TextBlock Text="{Binding Dog.Sound}" />
                <!-- 绑定并显示狗的年龄 -->
                <TextBlock Text="{Binding Dog.Age}" />
                <!-- 绑定并显示狗的颜色 -->
                <TextBlock Text="{Binding Dog.Color}" />
            </StackPanel>
        </Border>

        <!-- 羊的边框 -->
        <Border Grid.Row="2" BorderBrush="Black" BorderThickness="1" Margin="5">
            <StackPanel>
                <!-- 显示动物种类名称 -->
                <TextBlock Text="Sheep" FontWeight="Bold" HorizontalAlignment="Center"/>
                <!-- 绑定并显示羊的叫声 -->
                <TextBlock Text="{Binding Sheep.Sound}" />
                <!-- 绑定并显示羊的年龄 -->
                <TextBlock Text="{Binding Sheep.Age}" />
                <!-- 绑定并显示羊的颜色 -->
                <TextBlock Text="{Binding Sheep.Color}" />
            </StackPanel>
        </Border>
    </Grid>
</Window>

3.代码解释

1. C#代码：

   • Animal 类是一个基类，定义了三个属性：Sound（叫声）、Age（年龄）、Color（颜色）。这些属性通过INotifyPropertyChanged接口来通知属性变化。
   • Cat、Dog 和 Sheep 类是从 Animal 类继承的子类。它们在构造函数中设置了各自的默认叫声。
   • MainWindow 类是WPF窗口的后台代码。在构造函数中，创建了 Cat、Dog 和 Sheep 对象，并设置它们的属性。然后，将这些对象绑定到窗口的 DataContext。

2. XAML代码：

   • 定义了一个 Grid 布局，其中包含三个行，每行用于显示一种动物的信息。
   • 每种动物的信息显示在一个 Border 中， Border 内部是一个 StackPanel。
   • StackPanel 包含一个显示动物种类名称的 TextBlock 和三个绑定到动物属性的 TextBlock。
   • 通过绑定 (Binding)，TextBlock 显示来自 DataContext 中 Cat、Dog 和 Sheep 对象的属性值。

4.现象显示