泛型学习(可空类型,排序,定义泛型类,变体(协变与抗变))

最新推荐文章于 2024-03-22 08:57:56 发布
最新推荐文章于 2024-03-22 08:57:56 发布
阅读量673 收藏
点赞数 


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

namespace 可空类型
{
    public class Vector
    {
        public Double? 半径 = null, 角度 = null;
        public Double? 弧度
        { get { return (角度 * Math.PI / 180.0); } }
        public Vector(Double? 半径参, Double? 角度参)
        {
            if (半径参 < 0) { 半径参 = -半径参; 角度参 += 180; }
            角度参 %= 360;
            半径 = 半径参;
            角度 = 角度参;
        }
        public static Vector operator +(Vector 值1, Vector 值2)
        {
            try
            {
                double 新X = 值1.半径.Value * Math.Sin(值1.角度.Value) + 值2.半径.Value * Math.Sin(值2.角度.Value);
                double 新Y = 值1.半径.Value * Math.Cos(值1.角度.Value) + 值2.半径.Value * Math.Cos(值2.角度.Value);
                double 新半径 = Math.Sqrt(新X * 新X + 新Y * 新Y);
                double 新角度 = Math.Atan2(新X, 新Y) * 180.0 / Math.PI;
                return new Vector(新半径, 新角度);
            }
            catch { return new Vector(null, null); }
        }
        public static Vector operator -(Vector 值1)
        {
            return new Vector(-值1.半径, 值1.角度);
        }
        public static Vector operator -(Vector 值1, Vector 值2)
        {
            return 值1 + (-值2);
        }
        public override string ToString()
        {
            string 半径值 = 半径.HasValue ? 半径.ToString() : "null";
            string 角度值 = 角度.HasValue ? 角度.ToString() : "null";
            return string.Format("({0},{1})", 半径值, 角度值);
        }
    }
    
}

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

namespace 可空类型
{
    class Program
    {
        static void Main(string[] args)
        {
            Vector 值1 = 获取矢量("Vector1");
            Vector 值2 = 获取矢量("Vector2");
            Console.WriteLine("{0} + {1} = {2}", 值1, 值2, 值1 + 值2);
            Console.WriteLine("{0} - {1} = {2}", 值1, 值2, 值1 - 值2);

            Console.ReadLine();
        }
        static Vector 获取矢量(string 名称)
        {
            Console.WriteLine("输入幅度{0}", 名称);
            double? 半径 = 获取可空值();
            Console.WriteLine("输入角（度）{0}", 名称);
            double? 角度 = 获取可空值();
            return new Vector(半径, 角度);
        }

        static double? 获取可空值() 
        {
            double? 结果;
            string 用户输入 = Console.ReadLine();
            try { 结果 = double.Parse(用户输入); }
            catch { 结果 = null; }
            return 结果;
        }
    }
}

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

namespace 可空类型
{
    public class 泛型排序 : List<Vector>
    {
        public 泛型排序(){}
        public 泛型排序(IEnumerable<Vector> 最初的项目)
        {
            foreach (Vector 元素 in 最初的项目) Add(元素);
        }
        public string 总和()
        {
            StringBuilder 输出 = new StringBuilder();
            Vector 当前点 = new Vector(0.0, 0.0);
            输出.Append("起源");
            foreach (Vector 元素 in this)
            {
                输出.AppendFormat(" + {0}", 元素);
                当前点 += 元素;
            }
            输出.AppendFormat(" = {0}", 当前点);
            return 输出.ToString();
        }
    }
}

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

namespace 可空类型
{
    public static class 矢量代表
    {
        public static int 比较(Vector x, Vector y)
        {
            if (x.半径 > y.半径) return 1;
            else if (x.半径 < y.半径) return -1;
            return 0;
        }
        public static bool 右上象限(Vector 目标)
        {
            if (目标.角度 >= 0.0 && 目标.角度 <= 90.0) return true; else return false;
        }
    }
}

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

namespace 可空类型
{
    class Program
    {
        static void Main(string[] args)
        {
            泛型排序 路线 = new 泛型排序();
            路线.Add(new Vector(2.0, 90.0));
            路线.Add(new Vector(1.0, 180.0));
            路线.Add(new Vector(0.5, 45.0));
            路线.Add(new Vector(2.5, 315.0));
            Console.WriteLine(路线.总和());
            //Comparison<Vector> 排序 = new Comparison<Vector>(矢量代表.比较);
            //路线.Sort(排序);
            路线.Sort(矢量代表.比较/*隐式创建类型实例*/);
            Console.WriteLine(路线.总和());

            Predicate<Vector> 搜索 = new Predicate<Vector>(矢量代表.右上象限);
            泛型排序 右上象限路线 = new 泛型排序(路线.FindAll(搜索));
            Console.WriteLine(右上象限路线.总和());

            Console.ReadLine();
        }
    }
}

修改以前动物例子:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 集合示例
{
    public class 鸡 : 动物
    {
        public void 下蛋() { Console.WriteLine("{0}一个鸡蛋.", 名称); }
        public override void 马可的噪声()
        { Console.WriteLine("{0}写着'咕咕'", 名称); }
        public 鸡(string 新名称) : base(新名称) { }
    }
}

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

namespace 集合示例
{
    public class 牛 : 动物
    {
        public void 牛奶() { Console.WriteLine("{0}已经挤奶.", 名称); }
        public override void 马可的噪声()
        { Console.WriteLine("{0}写着'哞哞'", 名称); }
        public 牛(string 新名称) : base(新名称) { }
    }
}

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

namespace 集合示例
{
    class 超牛 : 牛
    {
        public void 飞() { Console.WriteLine("{0}飞行!", 名称); }
        public 超牛(string 新名) : base(新名) { }
        public override void 马可的噪声()
        { Console.WriteLine("{0}写着'在这里，我来保存一天！'", 名称); }
    }
}

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

namespace 集合示例
{
    class 农场<T> : IEnumerable<T> where T : 动物/*被约束为基类或继承类型*/
    {
        private List<T> 集动物 = new List<T>();
        public List<T> 动物集 { get { return 集动物; } }
        public IEnumerator<T> GetEnumerator()
        { return 集动物.GetEnumerator(); }
        IEnumerator IEnumerable.GetEnumerator() { return 集动物.GetEnumerator(); }
        public void 马可的声音() { foreach (T 动物 in 集动物)动物.马可的噪声(); }
        public void 喂动物() { foreach (T 动物 in 集动物)动物.饲料(); }
        public 农场<牛> 获取奶牛()
        {
            农场<牛> 农场牛 = new 农场<牛>();
            foreach (T 动物 in 集动物)
                if (动物 is 牛) 农场牛.集动物.Add(动物 as 牛);
            return 农场牛;
        }

        public static implicit operator List<动物>(农场<T> 农场动物)
        {
            List<动物> 结果 = new List<动物>();
            foreach (T 元素 in 农场动物) 结果.Add(元素);
            return 结果;/*隐式的转换运算符*/
        }
        public static 农场<T> operator +(农场<T> 农场动物1, List<T> 农场动物2)
        {
            农场<T> 结果 = new 农场<T>();
            foreach (T 元素 in 农场动物1) 结果.动物集.Add(元素);
            foreach (T 元素 in 农场动物2) if (!结果.动物集.Contains(元素)) 结果.动物集.Add(元素);
            return 结果;/*泛型运算符*/
        }
        public static 农场<T> operator +(List<T> 农场动物1, 农场<T> 农场动物2)
        {
            return 农场动物1 + 农场动物2;
        }
        //public static implicit operator 农场<动物>(农场<T> 农场动物)
        //{
        //    农场<动物> 结果 = new 农场<动物>();
        //    foreach (T 元素 in 农场动物) 结果.动物集.Add(元素);
        //    return 结果;/*转换运算符:public static 农场<T> operator +(农场<T> 农场动物1, 农场<T> 农场动物2)*/
        //}
        interface 泛型接口<T> where T : 动物
        {
            bool 学尝试(T 农场动物1, T 农场动物2);
            T 获取缺省 { get; }
        }
        public T 泛型方法<T>() { return default(T); }
        public 农场<U> 动物种<U>() where U : T
        {
            农场<U> 农场种 = new 农场<U>();
            foreach (T 元素 in 集动物) if (元素 is U) 农场种.动物集.Add(元素 as U);
            return 农场种;
        }
    }
}

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



namespace 集合示例
{
    class Program
    {
        public struct 泛型结构<T1, T2>
        { public T1 项1; public T2 项2;}
        public delegate T1 泛型委托<T1, T2>(T2 p1, T2 p2) where T1 : T2;
        static void 列表动物(IEnumerable<动物> 动物合)
        {
            foreach (动物 元素 in 动物合) Console.WriteLine(元素.ToString() + "协变示例->"+ 元素.称名);
        }
        public interface 协变接口<out T>{ }/*继承类值写到基类变量，用作方法的返回值或属性读取get*/
        public interface 抗变接口<in T> { }/*基类值写到继承类变量，用作方法参数，不能用作返回类型*/
        
        static void Main(string[] args)
        {
            农场<动物> 农场动物 = new 农场<动物>();
            农场动物.动物集.Add(new 牛("捷克"));
            农场动物.动物集.Add(new 鸡("伊罗"));
            农场动物.动物集.Add(new 鸡("肯"));
            农场动物.动物集.Add(new 超牛("肯尼亚"));
            农场动物.马可的声音();
            农场<牛> 奶牛场 = 农场动物.获取奶牛();
            奶牛场.喂动物();
            foreach (牛 元素 in 奶牛场)
                if (元素 is 超牛) (元素 as 超牛).飞();
            /*定义泛型转换符和运算符*/
            奶牛场.动物集.Add(new 牛("克捷"));
            农场<动物> 新农场动物 = 农场动物 + 奶牛场;

            农场<牛> 场奶牛 = 农场动物.动物种<牛>();
            农场<鸡> 场鸡 = 农场动物.动物种<鸡>();
            
            List<牛> 牛集 = new List<牛>();
            牛集.Add(new 牛("牛牛"));
            牛集.Add(new 超牛("犇"));
            列表动物(牛集);
            牛集.Sort(new 动物名称的长度比较器());
            
            Console.ReadKey();
        }
    }
}

以前的 动物 类文件中添加:
    public class 动物名称的长度比较器 : IComparer<动物>
    {
        public int Compare(动物 X, 动物 Y) 
        {
            return X.称名.Length.CompareTo(Y.称名.Length);
        }
    }

智者知已应修善业
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【泛型】可空类型篇
广州大学 冠华(Net学生)
05-08 1328
Java泛型
空圆小生的博客
09-23 188
泛型的概念 在没有泛型的出现之前，一般的类和方法中，只能使用具体的类型，要么是基本的类型，要么就是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。在Thinking in Java中，对泛型的术语解释是：“适用于很多很多的类型”，它最初出现是希望类和方法能具备最广泛的表达能力。 泛型的本质是参数化类型，也就是说所将参数指定为一个数据类
泛型可空类型Nullable＜T＞
最新发布
weixin_44279482的博客
03-22 231
可空类型Nullable, int?, bool?, Nullable, HasValue
C# 关键字 使用where来限定泛型约束
Stay Hungry
07-18 2401
用法如下： public interface IEntity { } public class FutureResult<T> where T : class , IEntity , new() { } 使用where来限定T必须是class, 必须是继承自IEntity的类型，而且该类必须有无参构造函数 前面两个好理解，new()的意思就是说该类必须有公共的无参构...
聊一聊泛型的可空性（kotlin）
weixin_34210740的博客
11-07 441
什么？泛型本身也可以是nullable？上来就抛这么个问题实在是不够友好~ 首先回顾，什么是泛型？Oracle Java Tutorials Introduced in J2SE 5.0, this long-awaited enhancement to the type system allows a type or method to operate...
用C++template实现数据列表逆序数量统计教程共23
11-22
在C++编程中，模板（Template）是一种强大的工具，它允许程序员定义泛型函数或类，使得代码可以处理多种不同的数据类型。本教程主要聚焦于如何利用C++模板来实现一个功能，即统计一个数据列表中的逆序数对数量。逆序...
Abstract-data-structures_ADT
03-21
**抽象数据类型（Abstract Data Types, ADT）与Java实现** 抽象数据类型是计算机科学中的一个核心概念，它定义了一组操作以及这些操作作用于的数据集合。ADT并不关心具体的实现细节，而是专注于数据的逻辑表示和...
Visual C++ 2010入门经典(第5版)--源代码及课后练习答案
12-15
7.11.3 定义引用类类型的复制构造函数 346 7.11.4 类属性 346 7.11.5 initonly字段 358 7.11.6 静态构造函数 360 7.12 小结 360 7.13 练习 360 7.14 本章主要内容 361 第8章 深入理解类 363 8.1 类析构函数 ...
数组：基于数组的问题及其解决方案
02-15
2. 排序数组：Java的Arrays类提供了排序方法`Arrays.sort()`，可用于对一维数组进行升序或降序排序。 3. 查找元素：可以使用`Arrays.binarySearch()`进行二分查找，前提是数组已排序。 4. 多维数组的应用：二维...
使用可为空值的数据类型和System.Nullable(Of T)泛型类型
wl58796351的专栏
12-30 2098
使用可为空值的数据类型和System.Nullable(Of T)泛型类型   另一个非常有趣的泛型类型是System.Nullable(Of T)，它允许定义为可空值的数据类型。 CLR数据类型有一个固定的可用值范围。例如，可以为System.Boolean数据类型赋予集合{True,False}中的一个值。 然而，自从.NET 2.0发布以后，创建可为空值的数据类型成
java 泛型
resistancealex的博客
08-10 343
泛型： 泛型是一种不确定的类型，需要使用的时候根据传进来的数据类型来确定 因为java是强类型的语言，当我们不确定数据类型的时候，最好用泛型 public class Point<T>{ T x; T y; } 注意，T是泛型参数，表示一种数据类型，具体是什么类型，需要将来使用Point的时候进行传参来确定 注意，如果将来Point在使用的时候，没有给泛型参数T传值，那么T默认就表示为Object类型 注意，T是泛型参数的名字，也就是相当于形参，名字随便起，但是一般用一个有意义的大写字母
java 泛型空间_聊聊Java的泛型及实现
weixin_36328984的博客
02-25 66
摘要: 和C++以模板来实现静多态不同，Java基于运行时支持选择了泛型，两者的实现原理大相庭径。C++可以支持基本类型作为模板参数，Java却只能接受类作为泛型参数；Java可以在泛型类的方法中取得自己泛型参数的Class类型，C++只能由编译器推断在不为人知的地方生成新的类，对于特定的模板参数你只能使用特化。在本文中我主要想聊聊泛型的实现原理和一些高级特性。泛型基础泛型是对Java语言类型系统...
java可空类型,Java是否允许可以为空的类型？
weixin_39567222的博客
02-19 527
In C# I can a variable to allow nulls with the question mark. I want to have a true/false/null result. I want to have it set to null by default. The boolean will be set to true/false by a test result,...
java泛型 空值,Java泛型值.
weixin_26729841的博客
03-11 490
我进行了面试测试并看到以下代码：编辑：public class TestValue {private Value defaultValue;@Testpublic void Empty_Value_Has_No_Value() {Assert.assertFalse(Value. createEmptyValue().hasValue());}@Testpublic void Default_Va...
TypeScript 学习【9】泛型
不知名人士的博客
06-07 236
Java 语言中对泛型的解释是：泛型指的是类型参数化，即将原来某种具体的类型进行参数化。和定义函数参数一样，我们可以给泛型定义若干个类型参数，并在调用时给泛型传入明确的类型参数。设计泛型的目的在于有效约束类型成员之间的关系，比如函数参数和返回值、类或者接口成员和方法之间的关系。泛型最常用的场景是用来约束函数参数的类型，我们可以给函数定义若干个被调用时才会传入明确类型的参数。比如以下定义的一个 reflect 函数 ，它可以接收一个任意类型的参数，并原封不动地返回参数的值和类型，那我们该如何描述这个函数呢？好
聊一聊泛型的可空性 (kotlin)
weixin_34384557的博客
11-09 1408
什么？泛型本身也可以是nullable？上来就抛这么个问题实在是不够友好~ 首先回顾，什么是泛型？Oracle Java Tutorials Introduced in J2SE 5.0, this long-awaited enhancement to the type system allows a type or method to...
【C#】允许泛型方法<T>返回空值Null
weixin_33857679的博客
03-31 1190
在设计一个返回类型为T的泛型方法时，有时希望能返回空Null，然后会报错： 根据提示，将返回值由Null改为default（T）即可。 default（T）表示返回当前T类型的默认值，如果T为int则返回0。为了使确实能返回Null，可将该T类型继承自class类 where T : class，变成只能返回引用类型。 重要参考： http://stackoverflow.com/ques...
C#中泛型类的定义
热门推荐
不积跬步无以至千里
04-22 1万+
泛型 通过参数化类型来实现在同一份代码上操作多种数据类型。 利用“参数化类型”将类型抽象化，从而实现灵活的复用。 泛型类的定义 定义一个泛型类指的是，定义一个类，这个类中某些字段的类型是不确定的，这些类型可以在构造的时候确定下来。 eg： //创建一个类处理int类型或double类型或其他类型的相加 class ClassA&lt;T&gt; //T为未知的类型（也就是一...
Haskell中的泛型编程实践与类型类扩展
作者提出了一种在类声明中定义默认方法以实现泛型功能的方法，并描述了一个扩展，使得Haskell能够处理高阶kinded数据类型的实例声明。文章分为多个部分详细介绍这个扩展的设计和实现，包括语言设计、实例声明的扩展...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值