java泛型接口,泛型类泛型方法

java泛型接口,泛型类泛型方法
java泛型接口,泛型类泛型方法

泛型可提高代码的高扩展性和重用率.

1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句,例如。习惯上称为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName("https://www.360docs.net/doc/3c6412746.html,ng.String");

泛型可以用在接口,类方法,集合上面.

泛型接口:

interface testGenerics{

T getT(T t);

String assume(T t);

}

泛型类:

public class GenericsFoo {

private T x;

public GenericsFoo(T x) {

this.x = x;

}

public T getX() {

return x;

}

public void setX(T x) {

this.x = x;

}

}

使用来声明一个类型持有者名称,然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。

当然T仅仅是个名字,这个名字可以自行定义。

泛型方法:

是否拥有泛型方法,与其所在的类是否泛型没有关系。要定义泛型方法,只需将泛型参数列表置于返回值前。如:

public class ExampleA {

public void f(T x) {

System.out.println(x.getClass().getName());

}

使用泛型方法时,不必指明参数类型,编译器会自己找出具体的类型。泛型方法除了定义不同,调用就像普通方法一样。

限制泛型的可用类型:

在上面的例子中,由于没有限制class GenericsFoo类型持有者T的范围,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做:

class GenericsFoo,这样类中的泛型T 只能是Collection接口的实现类,传入非Collection接口编译会出错。

注意:这里的限定使用关键字extends,后面可以是类也可以是接口。但这里的extends已经不是继承的含义了,应该理解为T类型是实现Collection接口的类型,或者T是继承了XX类的类型。

下面继续对上面的例子改进,我只要实现了集合接口的类型:

public class CollectionGenFoo {

private T x;

public CollectionGenFoo(T x) {

this.x = x;

}

public T getX() {

return x;

}

public void setX(T x) {

this.x = x;

}

}

通配符泛型:

为了解决类型被限制死了不能动态根据实例来确定的缺点,引入了“通配符泛型”,针对上面的例子,使用通配泛型格式为,“?”代表未知类型,这个类型是实现Collection接口。那么上面实现的方式可以写为:

public class CollectionGenFooDemo {

public static void main(String args[]) {

CollectionGenFoo listFoo = null;

listFoo = new CollectionGenFoo(new ArrayList());

//现在不会出错了

CollectionGenFoo listFoo1 = null;

listFoo=new CollectionGenFoo(new ArrayList());

System.out.println("实例化成功!");

}

}

注意:

1、如果只指定了,而没有extends,则默认是允许Object 及其下的任何Java类了。也就是任意类。

2、通配符泛型不单可以向下限制,如,还可以向上限制,如,表示类型只能接受Double 及其上层父类类型,如Number、Object类型的实例。

3、泛型类定义可以有多个泛型参数,中间用逗号隔开,还可以定义泛型接口,泛型方法。这些都泛型类中泛型的使用规则类似。

《集合框架及泛型》上机实践内容

《集合框架及泛型》作业 一、根据课上讲解内容,完成演示示例和课堂练习 1、ArrayList获取并打印新闻标题 需求说明:按照以下实现的步骤,使用ArrayList获取和打印新闻标题,显示效果如下图所示: (1)创建多个各类新闻标题对象,包含ID、名称和创建者三个属性; (2)创建存储各类新闻标题的集合对象; (3)按照顺序依次添加各类新闻标题,使用add()方法; (4)获取新闻标题的总数,使用size()方法; (5)根据位置获取相应新闻标题、逐条打印每条新闻标题的名称,使用for 循环遍历。 2、ArrayList存储狗狗信息 需求说明:按照以下实现的步骤,使用ArrayList存储狗狗信息,使用ArrayList的方法对狗狗信息进行删除、读取和判断,显示效果如下图所示:(1)存储多条狗信息,获取狗总数,逐条打印出各条狗信息; (2)删除指定位置的狗,使用remove()方法; (3)判断集合中是否包含指定狗,使用contains()方法;

3、LinkedList添加和删除新闻标题 需求说明:在作业1的基础上,换用LinkedList存储新闻数据,并且使用LinkedList的getFirst()和getLast()方法获取第一条和最后一条数据,以及removeFirst()和removeLast()方法删除第一条和最后一条数据,输出效果如下图所示。 4、集合头尾位置删除和条件狗信息 需求说明:按照作业3的实现方式和所用到LinkedList的方法,实现狗狗信

息的更新并输出,输出效果如图所示。 5、使用Iterator和增强型for循环遍历Set 需求说明:按照以下实现的步骤,使用Iterator和增强型for循环遍历Set,输出效果如下图所示: (1)创建多个各类新闻标题对象,包含ID、名称和创建者三个属性; (2)创建存储各类新闻标题的集合对象; (3)按照顺序依次添加各类新闻标题; (4)获取新闻标题的总数; (5)使用iterator()获取Iterator对象; (6)使用Iterator遍历集合,使用hasNext()方法作为循环条件,判断是否存在另一个可访问的元素; (7)使用增强型for遍历集合;

java泛型详解

java泛型详解 泛型(Generic type 或者generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。 可以在集合框架(Collection framework)中看到泛型的动机。例如,Map类允许您向一个Map添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如String)的对象。 因为Map.get()被定义为返回Object,所以一般必须将Map.get()的结果强制类型转换为期望的类型,如下面的代码所示: Map m = new HashMap(); m.put("key", "blarg"); String s = (String) m.get("key"); 要让程序通过编译,必须将get()的结果强制类型转换为String,并且希望结果真的是一个String。但是有可能某人已经在该映射中保存了不是String的东西,这样的话,上面的代码将会抛出ClassCastException。 理想情况下,您可能会得出这样一个观点,即m是一个Map,它将String键映射到String值。这可以让您消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。 泛型的好处 Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化,以支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。这带来了很多好处: · 类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。 Java 程序中的一种流行技术是定义这样的集合,即它的元素或键是公共类型的,比如“Str ing列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了,而不是在运行时当作 ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性。

实验十 泛型与集合框架

实验十泛型与集合框架 1.实验目的 1、掌握LinkedList类和Collections类提供的用于排序和查找链表中 的数据的方法 2、掌握用散列映射来存储数据 3、掌握TreeSet类的使用 2.实验内容 1、根据附录里的源代码,按照注释要求,完成代码填空,使程序能够运行 得出结果。 1)实验1 按身高排序 2)实验2 英汉小字典 3)实验3 演出节目单 4)实验4输出args[]中的单词 2、设计编写程序完成以下任务。 1)仿照实验1编写TV类,要求通过实现Comparable接口规定该类的对象的大小关系,按price值得大小确定大小关系,即电视机按其价格确定之间的大小关系。 2)从控制台输入若干个单词(输入回车结束)放入集合中,将这些单词排序后(忽略大小写)打印出来。 知识点:List接口的实现类、String常用方法 3)请使用LinkedList来模拟一个队列(先进先出的特性): (1)拥有放入对象的方法void put(Object o) (2)取出对象的方法Object get() (3)判断队列当中是否为空的方法boolean isEmpty();并且,编写测试代码,验证你的队列是否正确。 知识点:List接口的实现类LinkedList常用方法 4)在一个列表中存储以下元素:apple,grape,banana,pear (1)返回集合中的最大的和最小的元素 (2)将集合进行排序,并将排序后的结果打印在控制台上 知识点:Collections类中的方法 3.实验步骤 略 4.评分标准 1.A——内容功能完善,编程风格好,人机接口界面好; 2.B——内容功能完善,编程风格良好,人机接口界面良好;

接口和抽象类的区别

.Net提供了接口,这个不同于Class或者Struct的类型定义。接口有些情况,看似和抽象类一样,因此有些人认为在.Net可以完全用接口来替换抽象类。其实不然,接口和抽象类各有长处和缺陷,因此往往在应用当中,两者要结合来使用,从而互补长短。 接下来先说说抽象类和接口的区别。 区别一,两者表达的概念不一样。抽象类是一类事物的高度聚合,那么对于继承抽象类的子类来说,对于抽象类来说,属于“是”的关系;而接口是定义行为规范,因此对于实现接口的子类来说,相对于接口来说,是“行为需要按照接口来完成”。这些听起来有些虚,举个例子。例如,狗是对于所有狗类动物的统称,京哈是狗,牧羊犬是狗,那么狗的一般特性,都会在京哈,牧羊犬中找到,那么狗相对于京哈和牧羊犬来说,就属于这类事物的抽象类型;而对于“叫”这个动作来说,狗可以叫,鸟也可以叫。很明显,前者相当于所说的是抽象类,而后者指的就是接口。 区别二,抽象类在定义类型方法的时候,可以给出方法的实现部分,也可以不给出;而对于接口来说,其中所定义的方法都不能给出实现部分。 例如: public abstract class AbsTest { public virtual void Test() { Debug.WriteLine( "Test" ); } public abstract void NewTest(); } public interface ITest {

void Test(); void NewTest(); } 区别三,继承类对于两者所涉及方法的实现是不同的。继承类对于抽象类所定义的抽象方法,可以不用重写,也就是说,可以延用抽象类的方法;而对于接口类所定义的方法或者属性来说,在继承类中必须要给出相应的方法和属性实现。 区别四,在抽象类中,新增一个方法的话,继承类中可以不用作任何处理;而对于接口来说,则需要修改继承类,提供新定义的方法。 知道了两者的区别,再来说说,接口相对于抽象类的优势。 好处一,接口不光可以作用于引用类型,也可以作用于值类型。而抽象类来说,只能作用于引用类型。 好处二,.Net的类型继承只能是单继承的,也就是说一个类型只能继承一个类型,而可以继承多个接口。其实,我对于这一点也比较赞同,多继承会使继承树变的混乱。 好处三,由于接口只是定义属性和方法,而与真正实现的类型没有太大的关系,因此接口可以被多个类型重用。相对于此,抽象类与继承类的关系更紧密些。 好处四,通过接口,可以减少类型暴露的属性和方法,从而便于保护类型对象。当一个实现接口的类型,可能包含其他方法或者属性,但是方法返回的时候,可以返回接口对象,这样调用端,只能通过接口提供的方法或者属性,访问对象的相关元素,这样可以有效保护对象的其他元素。

接口和抽象类习题-答案

(一)选择题 1.以下哪个接口的定义是正确的? A.interface B{ void print() { } ; } B.abstract interface B { void print() ; } C.abstract interface B extends A1,A2 { abstract void print(){ }; } D.interface B { void print();} 2.定义一个接口时,下列哪个关键字用不到? A.public B.extends C.interface D.class 3.定义一个接口时,要使用如下哪个关键字? A.abstract B.final C.interface D.class 4.在使用interface声明一个接口时,只可以使用哪个修饰符修饰该接口。 A.private B.protected C.private或者protected D.public 5.下列类头定义中,错误的是? A.public x extends y B.public class x extends y C.class x extends y implements y1 D.class x 6.下列类定义中,不正确的是? A.class x B.class x extends y C.class x implements y1,y2 D.public class x extends X1,X2 7.Java中能实现多重继承功能的方式是? A.接口 B.同步 C.抽象类 D.父类 8.下列叙述正确的是? A.Java中允许多重继承 B.Java一个类只能实现一个接口 C.Java中只能单重继承 D.Java中一个类可以继承多个抽象类 (二)简答题

JAVA实验报告-集合框架与泛型机制

Java 语言程序设计 C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日

一、实验目的 学习课程相关章节知识,通过上机练习,掌握以下知识: 1.掌握 List 接口下 ArrayList 及 LinkedList 的使用方法。 2.掌握 Map 接口下 HashMap 及 HashTable的使用方法 3.掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据,并且可以简单查询,利用 map 存储学生信息,字段如下: id ,name,age,实现步骤: (1)创建类,类图如下: (2)在 main 方法编写逻辑代码 (3)运行程序并测试结果 package https://www.360docs.net/doc/3c6412746.html,; public class Student { private String name ; private int age ; private String id ;

public String getName() { return name ; } public void setName(String name ) { this . name =name ; } public int getAge() { return age ; } public void setAge(int age ) { this. age=age ; } public String getId() { return id; } public void setId(String id) { this. id=id; } public Student(String name ,int age , String id ) { super(); this. name =name ; this. age=age ; this. id=id; } public void sayHi() { System.out.println("name=" +this.getName()+"age=" + this .getAge()+" " + "id=" + this.getId()); } }

接口和抽象类习题-答案

一)选择题 1. 以下哪个接口的定义是正确的? A. interface B{ void print() { } ; } B. abstract interface B { void print() ; } C. ab stract interface B extends A1,A2 { abstract void print(){ }; } D. interface B { void print();} 2. 定义一个接口时,下列哪个关键字用不到? A. public B. extends C. interface D. class 3. 定义一个接口时,要使用如下哪个关键字? A. abstract B. final C. interface D. class 4. 在使用interface 声明一个接口时,只可以使用哪个修饰符修饰该接口。 A. private B. protected C. private 或者protected D. public 5. 下列类头定义中,错误的是

A. public x extends y B. public class x extends y C. class x extends y implements y1 D. class x 6. 下列类定义中,不正确的是? A. class x B. class x extends y C. class x implements y1,y2 D. public class x extends X1,X2 7. Java 中能实现多重继承功能的方式是? A. 接口 B侗步 C. 抽象类 D. 父类 8. 下列叙述正确的是? A. Java 中允许多重继承 B. Java 一个类只能实现一个接口 C. Java 中只能单重继承 D. Java 中一个类可以继承多个抽象类 (二)简答题 1) 接口中方法的修饰符都有哪些?属性的修饰符有哪些? 2) 接口的作用是什么?简述接口与类的关系。

java泛型接口,泛型类泛型方法

泛型可提高代码的高扩展性和重用率. 1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。 2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。 3、泛型的类型参数可以有多个。 4、泛型的参数类型可以使用extends语句,例如。习惯上称为“有界类型”。 5、泛型的参数类型还可以是通配符类型。例如Class classType = Class.forName("https://www.360docs.net/doc/3c6412746.html,ng.String"); 泛型可以用在接口,类方法,集合上面. 泛型接口: interface testGenerics{ T getT(T t); String assume(T t); } 泛型类:

public class GenericsFoo { private T x; public GenericsFoo(T x) { this.x = x; } public T getX() { return x; } public void setX(T x) { this.x = x; } } 使用来声明一个类型持有者名称,然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。 当然T仅仅是个名字,这个名字可以自行定义。 泛型方法: 是否拥有泛型方法,与其所在的类是否泛型没有关系。要定义泛型方法,只需将泛型参数列表置于返回值前。如: public class ExampleA { public void f(T x) {

System.out.println(x.getClass().getName()); } 使用泛型方法时,不必指明参数类型,编译器会自己找出具体的类型。泛型方法除了定义不同,调用就像普通方法一样。 限制泛型的可用类型: 在上面的例子中,由于没有限制class GenericsFoo类型持有者T的范围,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做: class GenericsFoo,这样类中的泛型T 只能是Collection接口的实现类,传入非Collection接口编译会出错。 注意:这里的限定使用关键字extends,后面可以是类也可以是接口。但这里的extends已经不是继承的含义了,应该理解为T类型是实现Collection接口的类型,或者T是继承了XX类的类型。 下面继续对上面的例子改进,我只要实现了集合接口的类型: public class CollectionGenFoo { private T x; public CollectionGenFoo(T x) { this.x = x;

JAVA实验报告-集合框架及泛型机制

Java语言程序设计C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识,通过上机练习,掌握以下知识:

1.掌握List接口下ArrayList及LinkedList的使用方法。 2.掌握Map接口下HashMap 及HashTable的使用方法 3.掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据,并且可以简单查询,利用map存储学生信息,字段如下: id ,name,age,实现步骤: (1)创建类,类图如下: (2)在main方法编写逻辑代码 (3)运行程序并测试结果 package com、cn; public class Student { private String name; private int age; private String id; public String getName() { return name; } public void setName(String name) {

this、name = name; } public int getAge() { return age; } public void setAge(int age) { this、age = age; } public String getId() { return id; } public void setId(String id) { this、id = id; } public Student(String name, int age, String id) { super(); this、name = name; this、age = age; this、id = id; } public void sayHi() { System、out、println("name="+this、getName()+"age="+this、getAge()+" "+"id="+this、getId()); } } //Databace类 package com、cn; import java、util、Collection; import java、util、HashMap; import java、util、Iterator; public class Databace { private Student a; public Databace() { super(); map=new HashMap(); } public Student getA() { return a; }

C#泛型探究(自学篇)

前言 前几日同学告诉我他老师告诉他,泛型是定义一种通用的方法,至于为什么用泛型他的答 案还是定义一种通用的方法,当时我也没有学,还不懂啦,毕竟人家是计算机专业的科班生,我当 然没有发言权,只是怀疑的记下了这个错误的结论打算以后看看是不是对的,这两天算是把泛型学 了一下,其实它定义的不只是方法,自己感觉他就是一种规范代码执行效率的模版,这样极不容易 出错,并把我们常用的箱拆箱操作过程给省了,提高了编译器的执行效率,。至于为什么用泛型这 个我貌似已经说明白了,泛型多用于集合类操作,我在这里随意的拿出C#定义的ArrayList的 Add方法的定义我们一起看看: public virtual int Add( Object value ) 可以看出我们可以往ArrayList里添加任何类型的元素,假如有一个string类型的str字符 串它在添加到ArrayList lib的过程中实际进行了装箱操作,即object value=str;那么我 们在获取这个值得时候必须这样使用string s=(string)lib[0];不能遗漏(string)否则会提示你, 错误1无法将类型“object”隐式转换为“string”。存在一个显式转换(是否缺少强制转换?) 但是你假如这样写:int a=(int)lib[0];程序在运行前是无法报错的,只要一旦运行就会出 现异常,而这些错误都可以利用泛型轻松搞定,让你在编译时就可以发现错误,具体的就看你怎么 领悟了,我在文章里没有写任何定义的语法格式,因为这个既没必要说,这是常识,出来混这些迟 早是要明白的,呵呵。玩笑啦......欢迎新手同学来我的博客交流学习,我也希望你们可以为我敞 开心怀,因为我既不是计算机专业的学生,甚至上了大学我已经不再是理工类的学生。我无意扎进了 文科专业去叱咤风云啦,哎,这个文科专业名字太有点科学技术的味道了。我喜欢 ........ 我的博客地址是:https://www.360docs.net/doc/3c6412746.html,

C#抽象类和接口的区别

C#抽象类和接口的区别

c#接口和抽象类的区别大家都容易把这两者搞混,我也一样,在听李建忠老师的设计模式时,他也老把抽象类说成接口,弄的我就更糊涂了,所以找了些网上的资料. 一、抽象类: 抽象类是特殊的类,只是不能被实例化;除此以外,具有类的其他特性;重要的是抽象类可以包括抽象方法,这是普通类所不能的。抽象方法只能声明于抽象类中,且不包含任何实现,派生类必须覆盖它们。另外,抽象类可以派生自一个抽象类,可以覆盖基类的抽象方法也可以不覆盖,如果不覆盖,则其派生类必须覆盖它们。 二、接口: 接口是引用类型的,类似于类,和抽象类的相似之处有三点: 1、不能实例化; 2、包含未实现的方法声明; 3、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员); 另外,接口有如下特性: 接口除了可以包含方法之外,还可以包含属性、索引器、事件,而且这些成员都被定义为公有的。除此之外,不能包含任何其他的成员,例如:常量、域、构造函数、析构函数、静态成员。一个类可以直接继承多个接口,但只能直接继承一个类(包括抽象类)。 三、抽象类和接口的区别: 1.类是对对象的抽象,可以把抽象类理解为把类当作对象,抽象成的类叫做抽象类.而接口只是一个行为的规范或规定,微软的自定义接口总是后带able字段,证明其是表述一类类“我能做。。。”.抽象类更多的是定义在一系列紧密相关的类间,而接口大多数是关系疏松但都实现某一功能的类中. 2.接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法; 3.一个类一次可以实现若干个接口,但是只能扩展一个父类 4.接口可以用于支持回调,而继承并不具备这个特点. 5.抽象类不能被密封。 6.抽象类实现的具体方法默认为虚的,但实现接口的类中的接口方法却默认为非虚的,当然您也可以声明为虚的. 7.(接口)与非抽象类类似,抽象类也必须为在该类的基类列表中列出的接口的所有成员提供它自己的实现。但是,允许抽象类将接口方法映射到抽象方法上。 8.抽象类实现了oop中的一个原则,把可变的与不可变的分离。抽象类和接口就是定义为不可变的,而把可变的座位子类去实现。 9.好的接口定义应该是具有专一功能性的,而不是多功能的,否则造成接口污染。如果一个类只是实现了这个接口的中一个功能,而不得不去实现接口中的其他方法,就叫接口污染。 10.尽量避免使用继承来实现组建功能,而是使用黑箱复用,即对象组合。因为继承的层次增多,造成最直接的后果就是当你调用这个类群中某一类,就必须把他们全部加载到栈中!

Java泛型详解

Java 泛型 1 什么是泛型 (2) 2 泛型类跟接口及泛型方法 (3) 2.1 泛型类跟接口及继承 (3) 2.1.1泛型类 (3) 2.1.2继承 (3) 2.1.3接口 (3) 2.2 泛型方法 (3) 2.2.1 方法 (3) 2.2.2 类型推断 (4) 3 泛型实现原理 (5) 4 泛型数组 (6) 5边界 (7) 6通配符 (8) 7 泛型的问题及建议 (9) 7.1问题 (9) 7.2 建议 (9)

1 什么是泛型 从jdk1.5开始,Java中开始支持泛型了。泛型是一个很有用的编程工具,给我们带来了极大的灵活性。在看了《java核心编程》之后,我小有收获,写出来与大家分享。 所谓泛型,我的感觉就是,不用考虑对象的具体类型,就可以对对象进行一定的操作,对任何对象都能进行同样的操作。这就是灵活性之所在。但是,正是因为没有考虑对象的具体类型,因此一般情况下不可以使用对象自带的接口函数,因为不同的对象所携带的接口函数不一样,你使用了对象A的接口函数,万一别人将一个对象B传给泛型,那么程序就会出现错误,这就是泛型的局限性。所以说,泛型的最佳用途,就是用于实现容器类,实现一个通用的容器。该容器可以存储对象,也可以取出对象,而不用考虑对象的具体类型。因此,在学习泛型的时候,一定要了解这一点,你不能指望泛型是万能的,要充分考虑到泛型的局限性。下面我们来探讨一下泛型的原理以及高级应用。首先给出一个泛型类: public class Pair { public Pair() { first = null; second = null; } public Pair(T first, T second) { this.first = first; this.second = second; } public T getFirst() { return first; } public T getSecond() { return second; } public void setFirst(T newValue) { first = newValue; } public void setSecond(T newValue) { second = newValue; } private T first; private T second; } 我们看到,上述Pair类是一个容器类(我会多次强调,泛型天生就是为了容器类的方便实现),容纳了2个数据,但这2个数据类型是不确定的,用泛型T来表示。关于泛型类如何使用,那是最基本的内容,在此就不讨论了。

继承和接口设计习题

第7章继承和接口设计 一.选择题 1.在C#中,一个类【】。 A) 可以继承多个类B) 可以实现多个接口 C) 在一个程序中只能有一个子类D) 只能实现一个接口 2.【】关键字用于在C#中从派生类中访问基类的成员。 A) new B) super C) this D) base 3.在定义类时,若希望类的某个方法能够在派生类中进一步改进,以满足派生类的不同需要,则应将该方法声明为【】。 A) new B) public C) virtual D) override 4.在C#中,在派生类中对基类的虚方法进行重写,要求在派生类的声明中使用【】。 A) new B) public C) virtual D) override 5.已知类B是由类A继承而来,类A中有一个名为M的非虚方法,现在希望在类B中也定义一个名为M的方法,且两方法的参数个数和类型完全相同,若希望编译时不出现警告信息,则在类B中声明该方法时,应使用【】关键字。 A) static B) new C) override D) virtual 6.假设类B继承了类A,下列说法错误的是【】。 A) 类B中的成员可以访问类A中的公有成员 B) 类B中的成员可以访问类A中的保护成员 C) 类B中的成员可以访问类A中的私有成员 D) 类B中的成员可以访问类A中的静态成员 7.关于多态,下列说法正确的是【】。 A) 多态实际上就是重载,它们本质上是以一样的 B) 多态可以分为编译时多态和运行时多态。前者的特点是在编译时就能确定要调用成 员方法的哪个版本,后者则是在程序运行时才能确定要调用成员方法的哪个版本。 C) 编译时多态是在程序运行时才能确定要调用成员方法的哪个版本,而运行时多态在 编译时就能确定要调用成员方法的哪个版本。 D) 多态和重载是两个完全不同的概念,前者是通过定义虚方法和重写虚方法来实现, 后者是通过对同一函数名编写多个不同的实现代码来实现。 8.下列关于接口的说法,正确的是【】。 A) 接口中定义的方法都必须是虚方法 B) 接口中定义的方法可以编写其实现代码 C) 继承接口的类可提供被继承接口中部分成员的实现代码 D) 接口中的所有方法都必须在其派生类中得到实现。 9.下列关于虚方法的描述中,正确的是【】。 A) 虚方法能在程序执行时动态确定要调用的方法,因此比非虚方法更灵活 B) 在定义虚方法时,基类和派生类的方法定义语句中都要带上virtual修饰符 C) 在重写基类的虚方法时,为消除隐藏基类成员的警告,需要带上new修饰符 D) 在重写基类的虚方法时,需要同时带上virtual和override修饰符 10.在C#中,以下关于抽象类的叙述中错误的是【】。 A) 抽象类可以包含抽象方法B) 含有抽象方法的类一定是抽象类

抽象类与接口的区别

抽象类与接口的区别 abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。 其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。 一、理解抽象类 abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢? 在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。 比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。 在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。 二、从语法定义层面看abstract class和interface 在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。使用abstract class的方式定义Demo抽象类的方式如下: java 代码 abstract class Demo { abstract void method1(); abstract void method2(); …

实验6 泛型与集合框架_附答案

任务一:用LinkedList存放对象 1.利用面向对象的思想,创建以下类: ●Person类,包含Person的姓名和身份证号码,覆盖Object类的toString() 方法,显示“姓名:XXX 身份证号:XXX”。 ●Student类,继承Person类,包含学生的语文、数学、英文课的成绩,并覆盖 父类的toString()方法,显示“姓名:XXX 身份证号:XXX 语文:XXX 数学:XXX 英文:XXX”。 ●Teacher类,继承Person类,包含教师的工资。并覆盖父类的toString()方 法,显示“姓名:XXX 身份证号:XXX 工资:XXX”。 ●public class Person implements Comparable{ ●String name; ●String ID; ●Person(String s,String i){ ●name=s; ●ID=i; } ●public String toString() { ●String str="姓名:"+name+" 身份证号码:"+ID; ●return str; } ●public int compareTo(Object arg0) { ●Person p=(Person)arg0; ●return https://www.360docs.net/doc/3c6412746.html,pareTo(p.ID); } } ●class Student extends Person { ●int Chinese; ●int Math; ●int English; ●Student(String n,String i,int c,int m,int e){ ●super(n,i); ●Chinese=c; ●Math=m; ●English=e; } ●public String toString() { ●String str; ●str=" 语文成绩:"+Chinese+" 数学成绩:"+Math+" 英语成绩: "+English; ●return super.toString()+str; ●} ●} ●class Teacher extends Person{ ●int salary; ●Teacher(String n,String i,int s){ ●super(n,i); ●salary=s; ●}

java泛型详解

Java 泛型详解 泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java 泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。 泛型基础 泛型类 我们首先定义一个简单的Box类: public class Box { private String object; public void set(String object) { this.object = object; } public String get() { return object; }}这是最常见的做法,这样做的一个坏处是Box里面现在只能装入String类型的元素,今后如果我们需要装入Integer等其他类型的元素,还必须要另外重写一个Box,代码得不到复用,使用泛型可以很好的解决这个问题。 public class Box { // T stands for 'Type' private T t; public void set(T t) { this.t = t; } public T get() { return t; }} 这样我们的Box类便可以得到复用,我们可以将T替换成任何我们想要的类型: Box integerBox = new Box();Box doubleBox = new

Box();Box stringBox = new Box(); 泛型方法 看完了泛型类,接下来我们来了解一下泛型方法。声明一个泛型方法很简单,只要在返回类型前面加上一个类似的形式就行了: public class Util { public static boolean compare(Pair p1, Pair p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); }}public class Pair { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public void setKey(K key) { this.key = key; } public void setValue(V value) { this.value = value; } public K getKey() { return key; } public V getValue() { return value; }} 我们可以像下面这样去调用泛型方法: Pair p1 = new Pair(1, 'apple');Pair p2 = new Pair(2, 'pear');boolean same = https://www.360docs.net/doc/3c6412746.html,pare(p1, p2); 或者在Java1.7/1.8利用type inference,让Java自动推导出相应的类型参数: Pair p1 = new Pair(1, 'apple');Pair p2 = new Pair(2, 'pear');boolean same = https://www.360docs.net/doc/3c6412746.html,pare(p1, p2);

java实验报告 接口、泛型、枚举、内部类与异常

实验报告 课程名称: Java程序设计成绩评定: 实验项目名称:接口、泛型、枚举、内部类与异常指导教师: 学生姓名:学号:专业班级: 实验项目类型:基础实验地点:实验时间: 一、实验目的与要求: 1、理解接口的定义与实现; 2、知道泛型、枚举型与内部类的基本应用; 3、掌握常用异常的抛出与捕获及处理. 二、实验环境:(硬件环境、软件环境) 1.硬件环境:奔ⅣPC。 2.软件环境:Windows XP 操作系统,JDK6.0。 三、实验内容:(原理、操作步骤、程序代码等) 任务: 1、按照要求完成下述接口及实现类的程序 1)定义名称为PCI()的接口,包括启动的方法start和关闭的方法stop; 2)定义名称为NetworkCard 的类表示网卡,实现PCI接口,并且其在实现start 方法时输出“sending data……”,在实现stop方法时输出“network stop.” 3)定义名称为SoundCard 的类表示声卡,实现PCI接口;并且其在实现start 方法时输出“dudu……”,在实现stop方法时输出“sound stop.” 4)定义名称为MainBoard 的类表示主板,包含方法public void usePCICard(PCI p),在方法体内通过p来启动和关闭组件; 5)定义一个包含main方法的Test类,在main方法内创建一个MainBoard 对 象用mb来引用,创建一个NetworkCard对象用nc来引用,创建一个 SoundCard对象用sc来引用,分别通过mb来使用usePCICard(PCI p)启动声 卡和网卡。 2、泛型类程序的调试 调试教材P165的程序8-2,写出程序运行结果,理解泛型类的工作机理及应用。 3、调试运行内部类程序: 在类内部再定义另外一个类,这个另外定义的类就叫内部类。调试教材P171-172程序8-3,写出程序运行结果,理解内部类的定义方法与应用。 4、异常抛出与捕获编程与调试 先调试教材P182、183中的程序9-2和9-3,写出调试结果。然后,自己编写一个能抛出并捕获、处理NullPointerException、NumberFormanException多异常的程序,并调试后写出运行结果。

面向对象--接口与抽象类、对象和接口(通俗讲解)

面向对象--接口与抽象类的恩恩怨怨 接口与抽象类是面向对象编程中两个非常重要的角色,二者各自起着非常重要的作用。但是很多初学的朋友往往会对使用接口还是抽象类存在的很大的迷惑。就我自己的一点心得,发表一下拙见。 面向对象的一些回顾: 面向对象世界中有一个古老的法则:接口隔离原则,指的是不要把多个功能全部都集中在一个接口里面。接口实现的功能要相对单一;衍生开来可以得到另外一个结论:对一组或者称一系列功能的实现,尽量定义相对功能单一的小模块来实现这一组功能。这其实也是解耦和的体现。 那这跟我们的接口和抽象类有什么关系呢?那又得摆出另外一个法则:依赖倒置原则,针对接口编程而不是针对实现编程。 说到这,又会有一个新的问题蹦出来,这是自相矛盾啊,既然要针对接口编程还要抽象类干吗使?我们经常说面向对象,面向对象是来源于生活的。是人们要把对现实世界中的一系列方法论应用到程序设计当中来。从对象这一概念的引入我们就可以揣摩这一点。人类社会中有很多对象的概念,人、车、物体。不幸的是用程序来实现这些对象比在概念上定义对象要难很多。 (如果能达成这一共识,您可以继续往下看,否则就请看官您移步至留言讨论吧) MS给出开发者的建议是,用抽象类来实现接口。子类再继承基类。 实例说明: 为什么要这么建议?OK,我们试着结合实际来说明一下这个问题吧。我们要造车。这个车有个基本的属性就是能移动、还必须有轮子。那我们就设计一个接口 1public interface ICar 2 { 3 string Wheel 4 { 5 get; 6 set; 7 } 8 void Move(); 9 } 10

接下来的事情,就是实现了。造什么车都行,继承一下就行。随着科技的发展,我们的车想要飞了。此时当然不能修改这个接口,因为要遵循开闭原则。为什么要遵循?我们可以想一下,人坐上飞机能飞上天。但是也没见谁认为人有会飞这个特性的。那也好办,不许修改,那我再加一个接口。 1interface IFlyable 2 { 3 void Fly(); 4 } 5 好,我们的飞行汽车最后应该是这样的。 1class FlyCar : ICar,IAerocraft 2 { 3 private string wheel = string.Empty; 4 5 public void Fly() 6 { 7 Console.WriteLine("{0}车飞起来了",this.wheel); 8 } 9 public string Engine 10 { 11 get 12 { 13 return wheel; 14 } 15 set 16 { 17 wheel = value; 18 } 19 } 20 21 public void Move() 22 { 23 Console.WriteLine("{0}轮车在走",this.wheel); 24 } 25 } 26 看起来很不错,车能飞能走了。那它现在他的祖宗到底车还是飞行器呢?我们自己在心里辩论一下吧。估计不是很容易辩清楚。 我们前面说过,面向对象的思想来源于现实生活。如果把这组例子引入到现实中来,造会飞的汽车。肯定是要在原有的汽车上面下功夫。比如你装上喷气动力装置,或者装上翅膀。

相关文档
最新文档