C#类&继承&接口

最新推荐文章于 2024-04-17 13:12:04 发布
最新推荐文章于 2024-04-17 13:12:04 发布
阅读量410 收藏 8
点赞数 7
分类专栏： C# 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skx13613650153/article/details/135720403
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OperatorsApplication
{
    public class Number
    {
        public Number()
        {

        }
        public int FindMax(int a, int b)
        {
            int result;
            if (a > b)
            {
                result = a;
            }
            else
            {
                result = b;
            }
            return result;
        }
        public static void Print()
        {
            Console.WriteLine("hello world");
        }
        public int fab(int n)
        {
            return n==1?1:n * fab(n - 1);
        }
        public void swapValue1(ref int x,ref int y)
        {
            Console.WriteLine("before swap x={0},y={1}",x, y);
            int temp;
            temp = x;
            x = y;
            y = temp;
            Console.WriteLine("before swap x={0},y={1}", x, y);
        }
        public void getVal(out int x,out int y)
        {//通过此函数给传参设置值
            x = 100;
            y = 200;
            Console.WriteLine("after getValx={0},y={1}", x, y);
        }
    }
}

using System;
namespace OperatorsApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            //Operator();
            //Console.WriteLine("32:{0}",isPower(32));
            Number number = new Number();
            //调用类的非静态成员方法，必须使用类的实例来调用
            int r = number.FindMax(3, 5);
            Console.WriteLine("max={0}", r);
            //调用类的静态方法，必须使用类名来调用
            Number.Print();
            int a = 3;
            int b = 5;
            number.swapValue1(ref b,ref a);

            int a1;
            int a2;
            number.getVal(out a1,out a2);
            Console.WriteLine("after getVal a1={0},a2={1}", a1, a2);

        }
        static void Operator()
        {
            //+ - * /数组运算符
            //% 取余 模
            int a = 90;
            int b = 20;
            Console.WriteLine("a%b={0}", a % b);
            //++ -- 自增自减运算符 a++先运算后自增 ++a先自增后运算
            //关系运算符== < <= > >= !=
            if (a == b)
            {
                Console.WriteLine("a=b");
            }
            else
            {
                Console.WriteLine("a!=b");
            }
            //逻辑运算符 与&& 或|| 非!
            bool x = true;
            bool y = true;
            if (x && y)
            {
                Console.WriteLine("均为真");
            }
            //位运算符
            //按位与& 按位或| 取反~ 异或^(相同为0不同为1) 右移>> 左移<<
            int aa = 60;//0011 1100
            int bb = 13;//0000 1101
            Console.WriteLine("aa={0}", Convert.ToString(aa, 2));//打印二进制
            Console.WriteLine("aa&bb={0}", Convert.ToString(aa & bb, 2));
            Console.WriteLine("aa|bb={0}", Convert.ToString(aa | bb, 2));
            Console.WriteLine("~bb={0}", Convert.ToString(~ bb, 2));
            Console.WriteLine("aa^bb={0}", Convert.ToString(aa^bb, 2));
            Console.WriteLine("bb>>1={0}", Convert.ToString(bb>>1, 2));
            Console.WriteLine("bb<<1={0}", Convert.ToString(bb << 1, 2));

        }
        //判断一个数是不是2的n次方
        /*
         2^n 10进制
        123=1*10^2+2*10^1+3*10^0
        1(n个0)=1*2^n
        1000  2的n次方和此数-1得到的数相与 等于0，可以确定他是2的n次方
        &
        0111
        0000=0
         */
        public static bool isPower(int x)
        {
            if ((x&(x-1))==0)
            {
                return true;
            }
            else{
                return false;
            }
        }
        //找出数组只出现一次的数
        //1001^0000=1001 x^x=0 x^0=x
        public static int GetOne()
        {
            int[] nums = new int[] { 1, 2, 3, 4, 5, 7, 1, 2, 3, 4, 5 };
            int temp = 0;
            for(int i = 0; i < nums.Length; i++)
            {
                temp = temp ^ nums[i];
            }
            return temp;
        }
        //其他运算符
        public static void OtherOperators()
        {
            int a,b;
            a = 10;
            b = 20;
            int c = a == b ? a : b;//三目运算符：条件?满足：不满足

            string str = "hello";
            if(str is object)
            {
                Console.WriteLine("str是string的实例");//会输出
            }

        }
        //流程控制
        public static void Ctrl()
        {
            int a = 100;
            if (a == 10)
            {

            }
            else if(a == 20)
            {

            }
            else if (a == 30)
            {

            }
            else
            {

            }
            switch (a)
            {
                case 10:
                    Console.WriteLine();
                    break;
                case 20:
                    Console.WriteLine();
                    break;
                default:
                    switch (a)
                    {
                        
                    }
                    break;
            }
        }

    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OOP
{
    internal class Box
    {
        //数据成员 类的成员变量
        public double length;
        public double width;
        public double height;

        //成员方法
        public void setLength(double l)
        {
            length = l;
        }
        public void setWidth(double w)
        {
            width = w;
        }
        public void setHeight(double h)
        {
            height = h;
        }
        public double getVolume()
        {
            return width * length * height;
        }
        public Box(double length,double width,double height)//构造函数，多个构造函数（传参不同）叫重载
        {
            this.length = length;// this当前对象
            this.width = width;
            this.height = height;
            boxNum++;
        }
        public Box()
        {
            boxNum++;
        }
        ~Box()//析构函数：函数名和类名一样，在c++中很重要
        {
            //当对象销毁时调用此函数，释放资源
        }
        //静态变量是全局变量，生存周期为程序的生存周期，所有实例化对象共享一个变量，非静态变量是new的对象用自己的
        public static int boxNum;//静态变量，记录new出多少个实例
        //静态方法
        public static void showBoxNum()//静态方法
        {
            Console.WriteLine(boxNum);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OOP
{
    //模拟数据操作
    internal interface MyInterface//接口
    {
        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        int add(int data);
        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        int update(int data);
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        int remove(int data);
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        List<int> query(string where);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OOP
{
    internal class MySQL:MyInterface
    {
        public MySQL()
        {

        }
        public int add(int data)
        {
            Console.WriteLine("往 MySQL中添加数据{0}", data);
            return 1;
        }

        public List<int> query(string where)
        {
            Console.WriteLine("往 MySQL中查询数据{0}", where);
            return new List<int>();
        }

        public int remove(int data)
        {
            Console.WriteLine("往 MySQL中删除数据{0}", data);
            return 1;
        }

        public int update(int data)
        {
            Console.WriteLine("往 MySQL中更改数据{0}", data);
            return 1;
        }
    }
}

 

namespace OOP
{
    /// <summary>
    /// 面向对象的三个特点：
    /// 1.封装
    /// 2.继承
    /// 3.多态
    /// </summary>
    internal class Program
    {
        public static void DatabaseOperate(MyInterface myInterface)
        {
            myInterface.add(10);
        }
        static void Main(string[] args)
        {
            //Box box = new Box();
            //box.setHeight(10);
            //box.setWidth(20);
            //box.setLength(30);
            Box box = new Box(1,2,3);
            Console.WriteLine(box.getVolume());//体积
            Box box1 = new Box();

            //静态成员函数，要通过类名来访问
            Box.showBoxNum();
            DatabaseOperate(new MySQL());
            DatabaseOperate(new SQLServer());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace OOP
{
    internal class SQLServer: MyInterface//应用MyInterface接口，接口有哪些方法需实现接口的所有方法
    {
        public int add(int data)
        {
            Console.WriteLine("往SQLServer中添加数据{0}",data);
            return 1;
        }

        public List<int> query(string where)
        {
            Console.WriteLine("往SQLServer中查询数据{0}", where);
            return new List<int>();
        }

        public int remove(int data)
        {
            Console.WriteLine("往SQLServer中删除数据{0}", data);
            return 1;
        }

        public int update(int data)
        {
            Console.WriteLine("往SQLServer中更改数据{0}", data);
            return 1;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{/// <summary>
/// 抽象类
/// </summary>
    public abstract class AbsShape
    {
        public abstract double getArea();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{/// <summary>
/// 嵌套类
/// </summary>
    internal class Container
    {
        public Nested nested;
        public class Nested
        {
            public Nested()
            {

            }
        }
        public Container()
        {
            this.nested = new Nested();
        }
        public void NewNested()
        {
            this.nested = new Nested();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    internal interface Interface1
    {
        //接口方法：输出面积的70倍
        double getCost(double are);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    public interface Interface2
    {
        //接口方法
        void ParentInterfaceMethod();
    }
    public interface IMyInterface : 
        Interface2
    {
        //子接口中的方法
        void MethodToImplement();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    internal class MyInterfaceimp : IMyInterface
    {
        public MyInterfaceimp()
        {

        }
        public void MethodToImplement()
        {
            throw new NotImplementedException();
        }

        public void ParentInterfaceMethod()
        {
            throw new NotImplementedException();
        }
    }
}

namespace MultipleInherit
{/// <summary>
/// 多重继承c#里不支持多重继承的，但是我们可以继承单一一个父类，然后实现多个接口
/// </summary>
    internal class Program
    {
        static void Main(string[] args)
        {
            Rectangle rectangle = new Rectangle(7, 5);
            double area = rectangle.getArea();
            Console.WriteLine("矩形面积为：{0}", area);
            double result = rectangle.getCost(area);
            Console.WriteLine("矩形面积为：{0}", result);

            StaticClass.ShowMess();//使用静态类里的静态方法，使用方便相当于全局
            StaticClass.num = 10;
            Console.WriteLine(StaticClass.num);

            //嵌套类
            Container.Nested nested = new Container.Nested();

            //抽象类 不能new
            //AbsShape abs=new AbsShape();
            Re shape = new Re();
            shape.setLength(2);
            shape.setWidth(1);
            AbsShape abs = new Re();//这样定义只能访问抽象类中的方法，多态
            Console.WriteLine(shape.getArea());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{/// <summary>
/// 该类继承自AbsShape
/// </summary>
    internal class Re : AbsShape
    {
        private double length;
        private double width;
        public Re()
        {

        }
        public void setLength(double length)
        {
            this.length = length;
        }
        public void setWidth(double width)
        {
            this.width = width;
        }
        public override double getArea()
        {
            return this.length * this.width;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    internal class Rectangle:Shape1,Interface1
    {
        public Rectangle(double length,double width) : base(length, width)
        {

        }
        public double getArea()
        {
            return width * length;
        }

        public double getCost(double area)//实现接口
        {
            return area * 70;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{//私密封装类 不能被继承
    internal sealed class sealedClass
    {
        public sealedClass()
        {

        }
    }
    //public class Child: sealedClass { }//会报错，因为密封类不能被继承
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    internal class Shape1
    {
        protected double length;
        protected double width;
        public Shape1(double length,double width)
        {
            this.length = length;
            this.width = width;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MultipleInherit
{
    public static class StaticClass
    {
        /// <summary>
        /// 静态类
        /// </summary>
        public static int num;
        public static void ShowMess()
        {
            //在静态类里定义静态方法
        }
    }
}

using System.Security.Cryptography;

namespace InherritanceApplication
{
    //继承，类可以互相继承
    internal class Program
    {
        static void Main(string[] args)
        {
            Rectangle r1 = new Rectangle(10,20);
            //r1.setLength(10);
            //r1.setWidth(20);
            Console.WriteLine(r1.getArea());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InherritanceApplication
{/// <summary>
/// 二维图形
/// </summary>
    internal class Shape
    {
        protected double length;
        protected double width;
        public void setLength(double length)
        {
            this.length = length;
        }
        public void setWidth(double width)
        {
            this.width = width;
        }
        public double getArea()
        {
            return length * width;
        }
        public Shape(double length, double width)
        {
            this.length = length;
            this.width = width;
        }

    }
    class Rectangle:Shape//继承
    {
        private double angle = 90;
        public Rectangle(double length,double width,double angle):base(length,width)
        {
            this.angle = angle;
        }
        public double getArea()
        {
            return length * width;
        }
    }
    class Triangle : Shape//继承
    {
        public Triangle(double length, double width):base(length, width)
        {

        }
        public double getArea()
        {
            return length * width;
        }
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

鱼香鱼香rose
关注
专栏目录
浅谈C# 类的继承
08-31
C# 类的继承是面向对象编程中的核心概念之一，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和行为。这使得子类可以复用基类的代码，并根据需要添加新的特性和功能，从而实现代码的重用和扩展。 ...
C#系列之接口介绍
qiaodahua的博客
04-19 5209
本文详细介绍了接口的定义、使用规范和应用场景，同时与抽象类进行了对比。
C#接口和继承的区别、联系与使用场景
故事不长丨的博客
10-22 1238
本文详细介绍了C#中接口和继承的区别与联系，并讨论了它们各自的使用场景。继承支持构建类之间的层次结构，以及代码的重用和扩展。正确地应用接口和继承对于编写高质量、可维护和可扩展的代码非常重要。通过深入理解接口和继承的概念和用法，开发人员可以更好地应用它们来解决实际编程问题。在面向对象的编程中，接口和继承是常见的重要概念，它们都可以用于实现代码的重用和模块化。然而，它们具有不同的特点和适用场景，正确地应用接口和继承是编写高质量代码的关键。接下来，我们将详细讨论接口和继承之间的区别与联系。
C#中接口的实现与继承
weixin_44437944的博客
03-27 1274
C#中接口的实现与继承
C#中几种代码复用的方式
weixin_34085658的博客
05-21 625
假如在项目中，有多个方法，他们的开头和结尾都是差不多的，不变的只是中间的那部分逻辑。比如：static void f1() { Console.WriteLine("begin"); Console.WriteLine("do something1!"); Console.WriteLine("end"...
C#面向对象——继承、继承案例示例
最新发布
weixin_43603714的博客
04-17 1076
什么是继承？ 继承允许一个类（子类）基于另一个类（父类）的定义来构建。子类继承了父类的属性和方法，并且可以添加自己的特定的属性和方法。
C#中abstract继承抽象类
01-03
本文将深入探讨C#中`abstract`关键字的使用、抽象类的特性以及如何继承抽象类。 首先，我们需要了解什么是抽象类。抽象类是一种不能被实例化的类，它只能作为其他类的基类来使用。抽象类可以包含抽象方法，这些方法...
解析在C#中接口和类的异同
01-20
接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。 接口和类都可以包含事件、索引器、属性。 接口只能定义方法。 1. 类 类的分类有：抽象类(abstract)、密封类(sealed)、静态类(static) 1.1 ...
C#继承公共接口
07-31
在本主题中，我们将深入探讨“C#继承公共接口”的概念及其应用。 首先，让我们理解什么是接口继承。在C#中，一个接口可以继承一个或多个其他接口。这可以通过在接口声明时使用`:`运算符后跟父接口的名称来实现。...
C#教程10：面向对象 II（接口继承）
gongdiwudu的专栏
09-13 5190
在 C# 教程的这一章中，我们继续描述 OOP。我们涵盖了接口、多态性、深浅复制、密封类和异常。
C# 类实现接口(Interface) 多态 多继承
生产队的驴
11-23 2604
接口在程序中起到规范代码的作用，例如：电脑的USB接口，这些都是已经定义好的了，制造鼠标键盘U盘等厂家就按这种规格做出来的成品在任何电脑上都可以直接使用，而不需要进行适配，这就是规范的使用了接口。
C#学习笔记（4）——类的继承、接口
追风者
10-12 585
接口 接口只是一个框架并没有实现，因此在接口定义的时候可以不考虑其实现，可以很轻松地实现多继承。
C# 接口的实现与继承
zls365365的博客
04-03 4730
接口通过类继承来实现，一个类虽然只能继承一个基类，但可以继承任意接口。声明实现接口的类时，需要在基类列表中包含类所实现的接口的名称。例1 创建一个控制台应用程序，该程序在例1 的基础上实现，Program 类继承自接口 ImyInterface，并实现了该接口中的所有属性和方法。然后在 Main 方法中实例化 Program 类的一个对象，...
C#.NET里面抽象类和接口有什么区别?
fengzizhuang的专栏
05-08 661
1抽象类 (1) 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法 (2) 抽象类不能被实例化 (3) 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类 (4) 具体派生类必须覆盖基类的抽象方法 (5) 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。如果不覆盖，则其具体派生类必须覆盖它们。如： u
C#接口-接口的继承
德仔
11-22 3110
<br />类之间可以继承，和类一样，接口也允许继承。C#中接口可以多继承，接口之间可以互相继承和多继承。普通类和抽象类可以继承接口。一个类可以同时继承一个类和多个接口，但是接口不能继承类。<br />假如你是一名在职学习的学生，你就具有双重身份。一个身份是学生，必须完成学习任务，另一身份是职员，必须完成工作任务。进一步说，如果你是计算机类学生，除学基础课外，还必须学习C#程序设计。现在建立一个模型，应该如何建立？<br />我们首先来定义一个学生接口，规定学生必须学习，再建立一个职员接口，规定职员必须完成
关于C#中继承和接口
Fantastic 的博客
04-28 1359
接口也是一种类型，和委托类似。可以有自己的实例。 同时，在继承中，有一个很重要的概念：里氏转换。 里氏转换有两个重要概念： 1.子类可以赋值给父类。 2.包含子类的父类对象可以强制转换成子类。 窗体布局如图所示，代码如下： namespace 接口练习 { public partial class Form1 : Form { public F...
C#中的接口interface的使用
热门推荐
luoshao_的博客
09-04 3万+
interface类似于C++中的继承基类的虚函数，子类重写方法后。将调用对应子类的方法。 原文档https://blog.csdn.net/qq_36922335/article/details/73339342   接口是指定一组函数成员而不实现他们的引用类型。所以只能类和结构来实现接口，在继承该接口的类里面要实现接口的所有方法。 一、 在定义接口时候要注意如下几点： 1.接口声明...
接口(interface)原来是可以被继承(extends)的
周公（周金桥）的专栏
07-20 2万+
在传统的教科书或者书籍中都会灌输我们一个观念，那就是抽象类可以被继承(extends)，接口可以被实现(implements)，但是抽象类不能被实现（implements），接口也不能被继承（extends），但是今天这个观点有些地方被颠覆了。抽象类可以被继承(extends)，接口可以被实现(implements)，但是抽象类不能被实现（implements），这三个观点确实没有什么问题，但
C#编程示例：接口与实现
这样做的好处包括代码的可扩展性和复用性，因为新创建的类可以直接继承接口，而无需复制接口中的所有功能。同时，这种设计模式有助于保持代码清晰和易于维护，因为接口只关注接口，而不关心具体实现。 总结起来，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值