在台科大的第二次JAVA作业,老师课上讲的内容是泛型。

  泛型(generic),泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。通俗点说就是一个盒子本来只能放int,改成泛型之后就可以灵活地根据你的要求放你的类型,如int,double,char,string等。下面看两个例子:

  第一个例子中声明了一个Box类型,并继承了Number,也就是说Box只能用于对数的声明,如int,double,而如果改成3处的代码,则1,2处的代码可以正常运行,因为没有再继承Number,Box泛型也就包括了char,string等。

public class TestDemo2 {

    public static void main(String[] args) {

//1        Box<String> name1 = new Box<String>("corn");
Box<Integer> name2 = new Box<Integer>(12);
//2 System.out.println("name:" + name1.getData());
System.out.println("name:" + name2.getData());
} }
//3 class Box<T>{
class Box<T extends Number> { private T data; public Box() { } public Box(T data) {
this.data = data;
} public T getData() {
return data;
} }

运行结果:

name:12

第二个例子声明了一个Point类型,里面包含两个坐标的设置和获取。

public static void main(String[] args){
// 实例化泛型类
Point<Integer, Integer> p1 = new Point<Integer, Integer>();
p1.setX(10);
p1.setY(20);
int x = p1.getX();
int y = p1.getY();
System.out.println("This point is:" + x + ", " + y); Point<Double, String> p2 = new Point<Double, String>();
p2.setX(25.4);
p2.setY("东京180度");
double m = p2.getX();
String n = p2.getY();
System.out.println("This point is:" + m + ", " + n);
}
}
// 定义泛型类
class Point<T1, T2>{
T1 x;
T2 y;
public T1 getX() {
return x;
}
public void setX(T1 x) {
this.x = x;
}
public T2 getY() {
return y;
}
public void setY(T2 y) {
this.y = y;
}
}

运行结果:

This point is:10, 20
This point is:25.4, 东京180度

  老师布置的是编写一个插入算法的泛型类,对于数据结构非常差的我来说,简直了,不过只有慢慢查资料慢慢改。下面放作业代码。

import java.util.Comparator;

public class LinkedList<T> {

    public <T extends Comparable> void sort(T x) {
Node<T> HEAD=head.next,PRE=head.next;
Node<T> newNode = new Node(x, null);
Node<T> transNode= new Node(null,null); for(int i=0;i<count;i++){ if(i==0){
if(x.compareTo(head.data)< 0)//if x<head.data/x字典顺序小于第一个数据
{
newNode = new Node(x, head);
transNode.next=newNode;
head= transNode.next;
count++;
break;
} HEAD=head.next;
continue;
} if(i==1){
if(x.compareTo(HEAD.data)< 0)
{
newNode = new Node(x,HEAD);
head.next=newNode;
count++;
break;
}
else
{
HEAD=HEAD.next;
PRE=head.next;
continue;
}
} if(i<count-1){
if(x.compareTo(HEAD.data)< 0)
{
newNode = new Node(x,HEAD);
PRE.next=newNode;
count++;
break;
}
else{
PRE=HEAD;
HEAD=HEAD.next;
}
} if(i==count-1){
if(x.compareTo(HEAD.data)< 0)
{
newNode.next=HEAD;
PRE.next=newNode;
newNode.data=x;
count++;
break;
}
else
HEAD.next=newNode;
newNode.data=x;
newNode.next=null;
count++;
} }
} public static class Node<T> { T data;
Node next; public Node(T data, Node<T> next) {
this.data = data;
this.next = next;
} public String toString() {
return data.toString();
}
} static int count;
Node<T> head; public LinkedList() {
count = 0;
head = null;
} public boolean insert(int index, T entry) {
if (index < 0 || index > count) {
return false;
}
if (index == 0) {
Node<T> newNode = new Node(entry, head);
head = newNode;
count++;
return true;
}
Node<T> node = head;
for (int i = 0; i < index - 1; i++, node = node.next);
//System.out.println("prev "+node);
Node<T> newNode = new Node(entry, node.next);
node.next = newNode;
count++;
return true;
} public int size() {
return count;
}
public boolean isEmpty() {
return count == 0;
} public String toString() {
StringBuilder s = new StringBuilder();
for (Node<T> node = head; node != null; node = node.next) {
if (node != head) {
s.append(", ");
}
s.append(node.toString());
}
return s.toString();
}
public class Member {
String firstname;
String lastname;
int age;
public Member(String firstname, String lastname, int age) {
this.firstname = firstname;
this.lastname = lastname;
this.age = age;
}
public String toString() {
return firstname + " " + lastname + " age=" + age;
}
} public static void main(String args[]) { LinkedList<String> fruits = new LinkedList();
fruits.insert(0, "apple");
fruits.insert(1, "banana");
fruits.insert(2, "melon");
fruits.insert(3, "pear");
fruits.insert(4, "zzz");
System.out.println(fruits);
System.out.println("***********");
System.out.println("insertion sort:ccc");
fruits.sort("ccc");
System.out.println(fruits);
System.out.print("count:");
System.out.println(fruits.count);
System.out.println("------------------"); LinkedList<Integer> IntNum = new LinkedList();
IntNum.insert(0, 1);
IntNum.insert(1, 3);
IntNum.insert(2, 5);
IntNum.insert(3, 7);
IntNum.insert(4, 9);
System.out.println(IntNum);
System.out.println("***********");
System.out.println("insertion sort:4");
IntNum.sort(4);
System.out.println(IntNum);
System.out.print("count:");
System.out.println(IntNum.count);
System.out.println("------------------"); LinkedList<Double> DouNum = new LinkedList();
DouNum.insert(0, 1.1);
DouNum.insert(1, 3.3);
DouNum.insert(2, 5.1);
DouNum.insert(3, 7.1);
DouNum.insert(4, 9.1);
System.out.println(DouNum);
System.out.println("***********");
System.out.println("insertion sort:4.1");
DouNum.sort(4.1);
System.out.println(DouNum);
System.out.print("count:");
System.out.println(DouNum.count);
System.out.println("------------------"); }
}

运行结果:

apple, banana, melon, pear, zzz
***********
insertion sort:ccc
apple, banana, ccc, melon, pear, zzz
count:6
------------------
1, 3, 5, 7, 9
***********
insertion sort:4
1, 3, 4, 5, 7, 9
count:6
------------------
1.1, 3.3, 5.1, 7.1, 9.1
***********
insertion sort:4.1
1.1, 3.3, 4.1, 5.1, 7.1, 9.1
count:6
------------------

JAVA入门——Generic/泛型的更多相关文章

  1. Java入门系列 泛型

    前言 <Java编程思想>第四版足足用了75页来讲泛型——厚厚的一沓内容,很容易让人头大——但其实根本不用这么多,只需要一句话:我是一个泛型队列,狗可以站进来,猫也可以站进来,但最好不要既 ...

  2. Java入门(二)——泛型

    如果你写过前端,可能会经常写一下关于变量类型的判断,比如:typeof fn === 'function'之类的代码.因为JavaScript作为一门弱类型语言,类型的判断往往需要开发人员自己去检查. ...

  3. 【Java入门提高篇】Day14 Java中的泛型初探

    泛型是一个很有意思也很重要的概念,本篇将简单介绍Java中的泛型特性,主要从以下角度讲解: 1.什么是泛型. 2.如何使用泛型. 3.泛型的好处. 1.什么是泛型? 泛型,字面意思便是参数化类型,平时 ...

  4. 《java入门第一季》之根据小案例体会泛型

    泛型在哪些地方使用呢? * 看API,如果类,接口,抽象类后面跟的有<E>就说要使用泛型.一般来说就是在集合中使用. 下面根据案例,加深体会泛型的作用. 案例一: import java. ...

  5. 夯实Java基础系列13:深入理解Java中的泛型

    目录 泛型概述 一个栗子 特性 泛型的使用方式 泛型类 泛型接口 泛型通配符 泛型方法 泛型方法的基本用法 类中的泛型方法 泛型方法与可变参数 静态方法与泛型 泛型方法总结 泛型上下边界 泛型常见面试 ...

  6. [JavaCore]JAVA中的泛型

    JAVA中的泛型 [更新总结] 泛型就是定义在类里面的一个类型,这个类型在编写类的时候是不确定的,而在初始化对象时,必须确定该类型:这个类型可以在一个在里定义多个:在一旦使用某种类型,在类方法中,那么 ...

  7. Java 中的泛型详解-Java编程思想

    Java中的泛型参考了C++的模板,Java的界限是Java泛型的局限. 2.简单泛型 促成泛型出现最引人注目的一个原因就是为了创造容器类. 首先看一个只能持有单个对象的类,这个类可以明确指定其持有的 ...

  8. java中的泛型(转)

    什么是泛型? 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的一个 ...

  9. 3. Java面向对象之泛型-指定多个泛型

    3. Java面向对象之泛型-指定多个泛型 package generic; class MutiGeneric<K, T> { private K key; private T take ...

随机推荐

  1. trs.getElementsByTagName is not a function 出现原因及解决办法

    好久没有操作dom元素了,在定义dom元素时, let tBo = document.getElementById('tBody') let trs = tBo.getElementsByTagNam ...

  2. sql中的IFNULL函数的应用

    select r.status=1 and IFNULL(r.channel_code,'') != 'crm' 这种查询方式的意思就是说如果r.channel_code为空则设置为空字符串,自然而然 ...

  3. GridView中使用 jQuery DatePicker (UpdatePanel)

    1.无UpdatePanel   1.代码 <script> $(function () { $('.myDatePickerClass').datepicker({ dateFormat ...

  4. 使用ASP.NET广告控件的XML语言创建广告链接--ASP.NET

    1.AdRotator广告控件的所有属性都是可选的,XML文件中可以包含如下表所示的属性(XML文件的广告属性).   属性 说明 ImageUrl 要显示的图像的URL  NavigateUrl 单 ...

  5. Ubantu16.04进行Android 8.0源码编译

    参考这篇博客 经过测试,8.0源码下载及编译之后,占用100多G的硬盘空间,尽量给ubantu系统多留一些硬盘空间,如果后续需要在编译好的源码上进行开发,需要预留更多的控件,为了防止后续出现文件权限问 ...

  6. 【BZOJ3992】序列统计(动态规划,NTT)

    [BZOJ3992]序列统计(动态规划,NTT) 题面 BZOJ 题解 最裸的暴力 设\(f[i][j]\)表示前\(i\)个数,积在膜意义下是\(j\)的方案数 转移的话,每次枚举一个数,直接丢进去 ...

  7. 【BZOJ1040】骑士(动态规划)

    [BZOJ1040]骑士(动态规划) 题面 BZOJ 题解 对于每一组厌恶的关系 显然是连边操作 如果是一棵树的话 很显然的树型\(dp\) 但是,现在相当于有很多个基环 也就是在一棵树的基础上再加了 ...

  8. 检测flash是否安装及版本号

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  9. Android OpenGL ES 开发(十): 通过GLES20与着色器交互

    1. 获取着色器程序内成员变量的id(句柄.指针) GLES20.glGetAttribLocation方法:获取着色器程序中,指定为attribute类型变量的id. GLES20.glGetUni ...

  10. VS中使用.NET Reactor进行代码混淆

    .NET Reactor相信大家都不陌生,网上使用教程也很多.但绝大多数都只介绍到软件的使用,而对于在VS中使用介绍的不多. 首先,在.NET Reactor的Help中Add In,如下图. 重启V ...