深入理解java泛型

一、什么是泛型？

泛
型（Generic type 或者 generics）是对
简单的理解，就是对类型的参数化，比如我们定义一个类属性或者实例属性时，往往要指定具体的类型，如Integer、Person等等，
但是如果使用了泛型，我们把这些具体的类型参数化，用一个广泛的可以表示所有类型的“类型”T来定义，那这个T就是泛型的表示。

可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。

因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型，如下面的代码所示：

[java] view plain copy print ?

Map m = new HashMap();
m.put("key", "value");
String s = (String) m.get("key");

要让程序通过编译，必须将 get() 的结果强制类型转换为 String，并且希望结果真的是一个 String。如果map中保存了的不是 String 的数据，则上面的代码将会抛出 ClassCastException。

二、泛型的好处

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：

1、类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。

2、消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

3、潜在的性能收益。泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。

三、泛型用法的例子

3.1 我们再程序中定义一个类，并制定泛型参数

[java] view plain copy print ?

class Point<T>{ // 此处可以随便写标识符号，T是type的简称
private T var ; // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
return var ;
}
public void setVar(T var){ // 设置的类型也由外部决定
this.var = var ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Point<String> p = new Point<String>() ; // 里面的var类型为String类型
p.setVar("MLDN") ; // 设置字符串
System.out.println(p.getVar().length()) ; // 取得字符串的长度
}
};

说明：

1. 命名类型参数

推荐的命名约定是使用大写的单个字母名称作为类型参数。这与 C++ 约定有所不同（参阅附录 A：与 C++ 模板的比较），并反映了大多数泛型类将具有少量类型参数的假定。对于常见的泛型模式，推荐的名称是：

K —— 键，比如映射的键。

V —— 值，比如 List 和 Set 的内容，或者 Map 中的值。

E —— 异常类。

T —— 泛型。

2. 以上，是将var变量设置为了String类型，当然也可以设置为其他的数据类型，比如Integer等，如果你设置的内容与你制定的泛型类型不一致，则在编译时将出现错误。比如：

[java] view plain copy print ?

class Point<T>{ // 此处可以随便写标识符号，T是type的简称
private T var ; // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
return var ;
}
public void setVar(T var){ // 设置的类型也由外部决定
this.var = var ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Point<Integer> p = new Point<Integer>() ; // 里面的var类型为String类型
p.setVar("MLDN") ; // 设置字符串
}
};

程序在编译期就出报错：

[plain] view plain copy print ?

GenericsDemo.java:13: 错误: 无法将类 Point<T>中的方法 setVar应用到给定类型;
p.setVar("MLDN") ; // 设置字符串
^
需要: Integer
找到: String
原因: 无法通过方法调用转换将实际参数String转换为Integer
其中, T是类型变量:
T扩展已在类 Point中声明的Object
1 个错误

看log就可以发现，我我们已经规定了泛型的类型为Integer，则说明T类型就是Integer，所以在传入参数时，当然不能传入String类型的参数了。

3.2 构造方法中使用泛型

构造方法可以为类中的属性进行初始化，如果类中的属性用过泛型指定，而又需要通过构造器设置属性的内容时，那么构造方法的定义与之前并无不同，不需要像声明类那样指定泛型。

[java] view plain copy print ?

class Point<T>{ // 此处可以随便写标识符号，T是type的简称
private T var ; // var的类型由T指定，即：由外部指定
public Point(T var){ // 通过构造方法设置内容
this.var = var ;
}
public T getVar(){ // 返回值的类型由外部决定
return var ;
}
public void setVar(T var){ // 设置的类型也由外部决定
this.var = var ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Point<String> p = new Point<String>("MLDN") ; // 里面的var类型为String类型
System.out.println("内容：" + p.getVar()) ;
}
};

这里我们讲一个泛型的警告问题：当你为某个类只定了泛型，但是，你实例化该类的对象的时候，并没有指定泛型的类型，则程序在编译时会出现警告，警告并不会影响程序的运行。

[java] view plain copy print ?

class Info<T>{
private T var ;
public T getVar(){
return this.var ;
}
public void setVar(T var){
this.var = var ;
}
public String toString(){ // 覆写Object类中的toString()方法
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info i = new Info() ; // 警告，没有指定泛型类型
i.setVar("MLDN") ; // 设置字符串
System.out.println("内容：" + i.getVar()) ;
}
};

编译程序会出现警告：

注: GenericsDemo10.java使用了未经检查或不安全的操作。

注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

说明：由于没有指定泛型类型，则类可以接受任何数据类型，也就是此时的var的类型就是Object，所有的泛型信息都会被擦除。

三、泛型通配符

3.1 引入泛型通配符

我们先来看一个例子：

[java] view plain copy print ?

class Info<T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){ // 直接打印
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info<String> i = new Info<String>() ; // 使用String为泛型类型
i.setVar("MLDN") ; // 设置内容
fun(i) ;
}
public static void fun(Info<Object> temp){ // 接收Object泛型类型的Info对象
System.out.println("内容：" + temp) ;
}
};

在方法调用过程中，我们将Info<String>传递给Info<Object>，此时会发现，程序在编译时会报错：

[sql] view plain copy print ?

GenericsDemo.java:17: 错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;
fun(i) ;
^
需要: Info<Object>
找到: Info<String>
原因: 无法通过方法调用转换将实际参数Info<String>转换为Info<Object>
1 个错误</span>

上述错误说明，泛型对象进行引用传递的时候，类型必须一致，Info<Object>并不是Info<String>的父类。如果现在非要传递，则可以讲fun方法中的info参数的泛型取消掉：

[java] view plain copy print ?

public static void main(String args[]){
Info<String> i = new Info<String>() ; // 使用String为泛型类型
i.setVar("MLDN") ; // 设置内容
fun(i) ;
}
public static void fun(Info temp){ // 接收Object泛型类型的Info对象
System.out.println("内容：" + temp) ;
}

当然，这样看来程序已经可以正常运行了，但是，我们之前已经指定了泛型，此时却在方法传递过程中把它取消了，总是不妥的，所以，java提供了？通配符来匹配任何的泛型类型。

[java] view plain copy print ?

public class GenericsDemo{
public static void main(String args[]){
Info<String> i = new Info<String>() ; // 使用String为泛型类型
i.setVar("MLDN") ; // 设置内容
fun(i) ;
}
public static void fun(Info<?> temp){ // 可以接收任意的泛型对象
System.out.println("内容：" + temp) ;
}
};

我们应当注意，在fun方法中，我们是直接输出了temp对象，并为其做任何修改，实质上，使用？可以接收任意的内容，但是此内容却无法直接使用<?>进行修改，比如：我们这样去创建一个对象：

[java] view plain copy print ?

public class GenericsDemo{
public static void main(String args[]){
Info<?> i = new Info<String>() ; // 使用String为泛型类型
i.setVar("MLDN") ; // 设置内容
}
};

编译后，程序会报错：

[plain] view plain copy print ?

GenericsDemo.java:16: 错误: 无法将类 Info<T>中的方法 setVar应用到给定类型;
i.setVar("MLDN") ; // 设置内容
^
需要: CAP#1
找到: String
原因: 无法通过方法调用转换将实际参数String转换为CAP#1
其中, T是类型变量:
T扩展已在类 Info中声明的Object
其中, CAP#1是新类型变量:
CAP#1从?的捕获扩展Object
1 个错误

四、受限泛型

4.1 泛型上限：表示参数化的类型可能是所指定类型，或者是其子类。

[java] view plain copy print ?

class Info<T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){ // 直接打印
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info<Integer> i1 = new Info<Integer>() ; // 声明Integer的泛型对象
Info<Float> i2 = new Info<Float>() ; // 声明Float的泛型对象
i1.setVar(30) ; // 设置整数，自动装箱
i2.setVar(30.1f) ; // 设置小数，自动装箱
fun(i1) ;
fun(i2) ;
}
public static void fun(Info<? extends Number> temp){ // 只能接收Number及其Number的子类
System.out.print(temp + "、") ;
}
};

如果你接收的不是Number类及其子类，则程序会报错：

[java] view plain copy print ?

public class GenericsDemo{
public static void main(String args[]){
Info<String> i1 = new Info<String>() ; // 声明String的泛型对象
i1.setVar("hello") ;
fun(i1) ;
}
public static void fun(Info<? extends Number> temp){ // 只能接收Number及其Number的子类
System.out.print(temp + "、") ;
}
};

错误: 无法将类 GenericsDemo中的方法 fun应用到给定类型;

fun(i1) ;

^

需要: Info<? extends Number>

找到: Info<String>

原因: 无法通过方法调用转换将实际参数Info<String>转换为Info<? extends Number>

1 个错误

4.2 泛型下限：使用的泛型只能是本类及其父类类型上应用的时候，就必须使用泛型的下限。

[java] view plain copy print ?

class Info<T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){ // 直接打印
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info<String> i1 = new Info<String>() ; // 声明String的泛型对象
Info<Object> i2 = new Info<Object>() ; // 声明Object的泛型对象
i1.setVar("hello") ;
i2.setVar(new Object()) ;
fun(i1) ;
fun(i2) ;
}
public static void fun(Info<? super String> temp){ // 只能接收String或Object类型的泛型
System.out.print(temp + "、") ;
}
};

五、泛型与子类继承

一个类的子类可以通过对象多态性，为其父类实例化，但是在泛型操作中，子类的泛型类型是无法使用父类的泛型类型接受的，例如，Info<String>不能使用 Info<Object>接收。

六、泛型接口

6.1 定义泛型接口

[java] view plain copy print ?

interface Info<T>{ // 在接口上定义泛型
public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}

6.2 泛型接口的两种实现方式

6.2.1 定义子类，在子类的上也使用泛型声明

[java] view plain copy print ?

interface Info<T>{ // 在接口上定义泛型
public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl<T> implements Info<T>{ // 定义泛型接口的子类
private T var ; // 定义属性
public InfoImpl(T var){ // 通过构造方法设置属性内容
this.setVar(var) ;
}
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
};
public class GenericsDemo{
public static void main(String arsg[]){
Info<String> i = null; // 声明接口对象
i = new InfoImpl<String>("李兴华") ; // 通过子类实例化对象
System.out.println("内容：" + i.getVar()) ;
}
};

6.2.2 定义子类，直接指定泛型的具体操作类型

[java] view plain copy print ?

interface Info<T>{ // 在接口上定义泛型
public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info<String>{ // 定义泛型接口的子类
private String var ; // 定义属性
public InfoImpl(String var){ // 通过构造方法设置属性内容
this.setVar(var) ;
}
public void setVar(String var){
this.var = var ;
}
public String getVar(){
return this.var ;
}
};
public class GenericsDemo{
public static void main(String arsg[]){
Info i = null; // 声明接口对象
i = new InfoImpl("李兴华") ; // 通过子类实例化对象
System.out.println("内容：" + i.getVar()) ;
}
};

七、泛型方法

7.1 泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

[java] view plain copy print ?

class Demo{
public <T> T fun(T t){ // 可以接收任意类型的数据
return t ; // 直接把参数返回
}
};
public class GenericsDemo{
public static void main(String args[]){
Demo d = new Demo() ; // 实例化Demo对象
String str = d.fun("李兴华") ; // 传递字符串
int i = d.fun(30) ; // 传递数字，自动装箱
System.out.println(str) ; // 输出内容
System.out.println(i) ; // 输出内容
}
};

7.2 通过泛型方法，返回泛型类的实例

[java] view plain copy print ?

class Info<T extends Number>{ // 指定上限，只能是数字类型
private T var ; // 此类型由外部决定
public T getVar(){
return this.var ;
}
public void setVar(T var){
this.var = var ;
}
public String toString(){ // 覆写Object类中的toString()方法
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info<Integer> i = fun(30) ;
System.out.println(i.getVar()) ;
}
public static <T extends Number> Info<T> fun(T param){
Info<T> temp = new Info<T>() ; // 根据传入的数据类型实例化Info
temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中
return temp ; // 返回实例化对象
}
};

7.2 使用泛型，统一传递参数的类型

[java] view plain copy print ?

class Info<T>{ // 指定上限，只能是数字类型
private T var ; // 此类型由外部决定
public T getVar(){
return this.var ;
}
public void setVar(T var){
this.var = var ;
}
public String toString(){ // 覆写Object类中的toString()方法
return this.var.toString() ;
}
};
public class GenericsDemo{
public static void main(String args[]){
Info<String> i1 = new Info<String>() ;
Info<String> i2 = new Info<String>() ;
i1.setVar("HELLO") ; // 设置内容
i2.setVar("李兴华") ; // 设置内容
add(i1,i2) ;
}
public static <T> void add(Info<T> i1,Info<T> i2){
System.out.println(i1.getVar() + " " + i2.getVar()) ;
}
};

对于上述程序，我们再add方法里指定的T类型必须一致，比如上面指定了两个String类型，如果你传递的不一致，则会出现错误。

[java] view plain copy print ?

public class GenericsDemo{
public static void main(String args[]){
Info<Integer> i1 = new Info<Integer>() ;
Info<String> i2 = new Info<String>() ;
i1.setVar(30) ; // 设置内容
i2.setVar("李兴华") ; // 设置内容
add(i1,i2) ;
}
public static <T> void add(Info<T> i1,Info<T> i2){
System.out.println(i1.getVar() + " " + i2.getVar()) ;
}
};

编译时报错：

[java] view plain copy print ?

GenericsDemo.java:19: 错误: 无法将类 GenericsDemo中的方法 add应用到给定类型;
add(i1,i2) ;
^
需要: Info<T>,Info<T>
找到: Info<Integer>,Info<String>
原因: 不存在类型变量T的实例, 以使参数类型Info<String>与形式参数类型Info<T>一致
其中, T是类型变量:
T扩展已在方法 <T>add(Info<T>,Info<T>)中声明的Object
1 个错误

六、泛型数组

不能创建一个确切泛型类型的数组。如下面代码会出错。

List<String>[] lsa = new ArrayList<String>[10];

因为如果可以这样，那么考虑如下代码，会导致运行时错误。

[java] view plain copy print ?

List<String>[] lsa = new ArrayList<String>[10]; // 实际上并不允许这样创建数组
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer>li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;// unsound, but passes run time store check
String s = lsa[1].get(0); //run-time error - ClassCastException

因此只能创建带通配符的泛型数组，如下面例子所示，这回可以通过编译，但是在倒数第二行代码
中必须显式的转型才行，即便如此，最后还是会抛出类型转换异常，因为存储在lsa中的是List<Integer>类型的对象，而不是
List<String>类型。最后一行代码是正确的，类型匹配，不会抛出异常。

[java] view plain copy print ?

List<?>[] lsa = new List<?>[10]; // ok, array of unbounded wildcard type
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer>li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; //correct
String s = (String) lsa[1].get(0);// run time error, but cast is explicit
Integer it = (Integer)lsa[1].get(0); // OK

时间： 2024-12-21 15:19:12

深入理解java泛型的相关文章

理解Java泛型通配符 ? 以及其使用

什么是泛型: 泛型从字面上理解,是指一个类.接口或方法支持多种类型,使之广泛化.一般化和更加通用.Java中使用Object类来定义类型也能实现泛型,但缺点是造成原类型信息的丢失,在使用中容易造成ClassCastException. Java泛型带到的好处: 使得一个类或方法中的类型参数化,最终达到代码复用的效果.( 不使用泛型,你可能需要每种情况的类或方法都要定义一遍 ) 实现类型检查的功能,避免ClassCastException.(这是相对于使用Object类型实现泛型而言.因为我可以

Java泛型简明教程

Java泛型简明教程博客分类: Java综合 JavaApple数据结构CC++ Java泛型简明教程本文是从 Java Generics Quick Tutorial 这篇文章翻译而来. 泛型是Java SE 5.0中引入的一项特征,自从这项语言特征出现多年来,我相信,几乎所有的Java程序员不仅听说过,而且使用过它.关于Java泛型的教程,免费的,不免费的,有很多.我遇到的最好的教材有: The Java Tutorial Java Generics and Collections ,

Java泛型-- 通配符

转自:http://blog.csdn.net/flfna/article/details/6576394 ———————————————————————————————————————————— 通配符在本文的前面的部分里已经说过了泛型类型的子类型的不相关性.但有些时候,我们希望能够像使用普通类型那样使用泛型类型: ◆ 向上造型一个泛型对象的引用 ◆ 向下造型一个泛型对象的引用向上造型一个泛型对象的引用例如,假设我们有很多箱子,每个箱子里都装有不同的水果,我们需要找到一种方法能够通用的处

Java泛型学习笔记--Java泛型和C#泛型比较学习（一）

总结Java的泛型前,先简单的介绍下C#的泛型,通过对比,比较学习Java泛型的目的和设计意图.C#泛型是C#语言2.0和通用语言运行时(CLR)同时支持的一个特性(这一点是导致C#泛型和Java泛型区别的最大原因,后面会介绍).C#泛型在.NET CLR支持为.NET框架引入参数化变量支持.C#泛型更类似C++模板,可以理解,C#泛型实际上可以理解为类的模板类.我们通过代码实例来看C# 2.0泛型解决的问题,首先,我们通过一个没有泛型的迭代器的代码示例说起,代码实现如下: interface

Java泛型简明解释

Java泛型由来的动机理解Java泛型最简单的方法是把它看成一种便捷语法,能节省你某些Java类型转换(casting)上的操作: List<Apple> apples=... Apple apple=apples.get(1); 如上的代码,就不用程序员手动做类型判断了,因为泛型,在编译阶段编译器就对类型进行了检查泛型的构成由泛型的构成引出了一个类型变量的概念.根据Java语言规范,类型变量是一种没有限制的标志符,产生于以下几种情况: 泛型类声明泛型接口声明泛型方法声明泛型构造器

对java泛型的理解

自jdk1.6之后泛型就被广泛使用了,刚开始也是这么稀里糊涂的学了但是老是搞不懂其中的奥妙,后来随着项目经验的增多慢慢的才体会到了泛型的各种好处,看了不少项目封装的底层才发现原来泛型一般和接口混合使用来满足标准制定和参数多样化这样的代码需求.弄清楚之后我自己也动手实际体验了一下,觉得还是挺简单的.接下来就分享下我学泛型的心得,写的不好大家可以指出来. 1 标识接口虽然叫标识接口但是这个java类不仅仅局限于interface,class也是OK的,选择接口还是类关键看自己的选择:下面是我定义的

Java:泛型的理解

本文源自参考<Think in Java>,多篇博文以及阅读源码的总结前言 Java中的泛型每各人都在使用,但是它底层的实现方法是什么呢,为何要这样实现,这样实现的优缺点有哪些,怎么解决泛型带来的问题.带着好奇,我查阅资料进行了初步的学习,在此与诸位探讨. 一类型参数学过JAVA的人都知道泛型,明白大概怎么使用.在类上为:class 类名 {},在方法上为:public void 方法名 (T x){}.泛型的实现使得类型变成了参数可以传入,使得类功能多样化. 具体可分为5种情况: T是

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

目录泛型概述一个栗子特性泛型的使用方式泛型类泛型接口泛型通配符泛型方法泛型方法的基本用法类中的泛型方法泛型方法与可变参数静态方法与泛型泛型方法总结泛型上下边界泛型常见面试题参考文章微信公众号 Java技术江湖个人公众号:黄小斜本系列文章将整理到我在GitHub上的<Java面试指南>仓库,更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下Star.Fork.Watch三连哈,感谢你的

Java泛型中extends和super的理解(转)

E – Element (在集合中使用,因为集合中存放的是元素) T – Type(Java 类) K – Key(键) V – Value(值) N – Number(数值类型) ? – 表示不确定的java类型(无限制通配符类型) S.U.V – 2nd.3rd.4th types Object – 是所有类的根类,任何类的对象都可以设置给该Object引用变量,使用的时候可能需要类型强制转换,但是用使用了泛型T.E等这些标识符后,在实际用之前类型就已经确定了,不需要再进行类型强制转换. ?

猜你喜欢

Linux DHCP通过OPTION43为H3C的AP下发AC地址

对于DHCP服务,可以在很多平台上进行设置.那么这里我们就主要讲解一下在Linux DHCP服务器上通过option 43实现H3C的AP自动联系AC注册的相关内容.原来的DHCP Server是放在 ...

uva-10054-欧拉回路

题意:一个项链上面的每一个珠子有俩种颜色,前面一个珠子后面的颜色和后面珠子的前面颜色一样,有一天它断了, 一个人去搜集,问,搜集到的珠子能不能再次串成项链原以为是链表,原来链表这组数据过不了. 71 ...

11个热门物联网开发平台详解

从1999年Kevin Ashton第一次提出这个概念以来,物联网已经经历了迅速的转变.随着近年来连接到物联网的设备在多样性和数量方面出现指数式的增长,物联网已经成为了一种主流技术,在推动现在社会的生 ...

ATSHA204A加密芯片攻略——使用篇

ATSHA204A加密芯片是ATMEL公司研发的一款高安全性的,功能丰富的加密IC,使用SHA-256算法进行加密操作,内置16*32字节的slot(EEPROM)可以存储用户数据和秘钥,唯一的9字节 ...

UIImageView和UIImage

UIImage的两种创建方式: •方式一:有缓存(图片所占用的内存会一直停留在程序中) + (UIImage *)imageNamed:(NSString *)name; name是图片的文件名 •方 ...

spring在整合框架中常用配置的bean

1 数据源 1.1spring默认的数据源DriverManagerDatasource <bean id="dataSource" class="org.spri ...

【幻化万千戏红尘】qianfengDay19-java基础学习：转换流、对象流、打印流、三大标准（重定向）

课程回顾: 流:数据通信的管道常用的流类:1.文件流:File:数据在文件中 1.FileInputStream 2.FileOutputStream 3.FileReader 4.FileWrite ...

用户分组管理

<?php $oppeid=""; $opensecret=""; include("get_token.php"); $to ...

结对项目——高级四则运算检验器记录（168 & 187）

首先,上图(*+﹏+*)[email protected] 1.如何看待结对编程结对编程优点: 1.两个人能够相互支持,相互监督,客服编程过程中可能出现的烦躁的情况0_0. 2.在开发功能的同时,伴 ...

使用SimpleDateFormat注意的地方和在jsp中将字符串转换为日期

一.使用SimpleDateFormat注意的地方 SimpleDateFormat将字符串转换为日期类型时,转换的格式必须和字符串的格式一样,否则就会报错,比如:将字符串"20150825 ...

【OpenGL】Shader实例分析（六）- 卡牌特效

转发请保持地址:http://blog.csdn.net/stalendp/article/details/30989295 本文将介绍怎么通过alpha通道来隐藏信息,并实现卡牌特效.运行效果如下: ...

0和1互换，0和2互换，1和2互换

原文发布时间为:2009-10-22 -- 来源于本人的百度文章 [由搬家工具导入] 采用异或(^)思想 =====0和1互换（原数值异或上 1）======== a=0； a^1=1; a=1; ...

欧米茄最便宜的表多少钱

欧米茄旗舰店是国际著名制表企业和品牌,英文名omega,代表符号“Ω”.由路易士·勃兰特始创于1848 年,欧米茄标志着制表历史上的光辉成就,傲视同侪,相当精致.欧米茄以其先进制表技术,成为制表业的先 ...

ntpdate以一种非常粗暴的方式一次性完成设置时钟.由于实时时钟飘移,你需要周期性的矫正.基本上可以通过设置一个cron例行任务来运行ntpdate,但是你的机器从此就不能是ntp服务器了. 相反, ...

php Hash Table(四) Hash Table添加和更新元素

HashTable添加和更新的函数: 有4个主要的函数用于插入和更新HashTable的数据: int zend_hash_add(HashTable *ht, char *arKey, uint n ...

Js原生双向数据绑定

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

JavaScript之this指针深入详解

javascript中的this含义非常丰富,它可以是全局对象,当前对象或者是任意对象,这都取决于函数的调用方式.函数有以下几种调用方式:作为对象方法调用.作为函数调用.作为构造函数调用.apply或 ...

ActionScript3游戏中的图像编程（连载三十一）

2.2.4 Photoshop转Flash的投影角度换算继续往下看,Photoshop不透明度选项下面是投影角度,默认值是120°,而Flash里角度是45°,两者相差将近90°,投影角度却相近,为 ...

Ajax 及里面的XStream《黑马程序员_超全面的JavaWeb视频教程vedio》

1. ajax是什么? * asynchronous javascript and xml:异步的js和xml * 它能使用js访问服务器,而且是异步访问! * 服务器给客户端的响应一般是整个页面,一 ...

Python实现决策树ID3算法

主要思想: 0.训练集格式:特征1,特征2,...特征n,类别 1.采用Python自带的数据结构字典递归的表示数据 2.ID3计算的信息增益是指类别的信息增益,因此每次都是计算类别的熵 3.ID3每 ...

专题

随机推荐

© 2025 憋错料 | info#biecuoliao.com | 10 q. 0.021 s.