sschrodinger
sschrodinger

JAVA-泛型

JAVA-泛型

sschrodinger

2018/11/15

简介

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况 ，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处：使用泛型，首先可以通过IDE进行代码类型初步检查，然后在编译阶段进行编译类型检查，以保证类型转换的安全性；并且所有的强制转换都是自动和隐式的，可以提高代码的重用率。

语法语法

基本语法

我们一般在 JAVA 代码中用 <> 定义泛型参数（类型参数）。

泛型参数的定义很简单，在<>中填上占位符代表类，注意占位符可以有多个。如下所示：

//泛型类，T为占位符
class ClassName {
    T item;
    T getT() {}
}

//泛型接口
interface InterfaceName {
    print(T t);
}

//泛型方法
class ClassName {
    public  void(T t) {}
    public static  print(E e) {}
}

note

  • 对于类和接口的泛型定义，直接在类名或者接口名之后添加<>
  • 泛型方法定义为 <占位符> 返回值 方法名()。注意静态方法的泛型定义只能使用这种方法，因为静态方法不能访问泛型类的泛型参数，必须要自己定义泛型参数。
边界

我们来看一个 C++ 的模板例子。

template class Manipulator {
    T obj;
    Manipulator(T x) {obj = x;}
    void manipulate() {obj.f();}
};
class HasF {
public:
    void f() {count << "Has::f()" << endl;}
}
int main() {
    HasF hf;
    Manipulator manipulator(hf);
    manipulator.manipulate();
}

在编译期时，编译器能够自己判断实例化的对象有无f()方法，如果没有则报编译期错误。

JAVA 使用擦除来实现泛型，对于 来说，我们会将其擦除到他的第一个边界，在这里，第一个边界就是指Object。我们来看一个最简单的例子。

public class Holder {
    T item;
    public Holder(T item) { this.item = item;}
    public T get() {return item;}
    
    public static void main(String[] args) {
        Holder holder = new Holder(Long.valueOf(0L));
        Long long1 = holder.get();
        Object object = holder.get();
        Number number = holder.get();
        //编译器报错，类型为Long，不能转化为Integer
        //Integer integer = holder.get();
    }
    
}

这是最简单的一个容器类，可以存储一个指定类型的类。

反编译 Holder 的 class 代码，如下所示：

public class test.Holder {
  T item;

  public test.Holder(T);
    Code:
       0: aload_0
       1: invokespecial #13                 // Method java/lang/Object."":()V
       4: aload_0
       5: aload_1
       6: putfield      #16                 // Field item:Ljava/lang/Object;
       9: return

  public T get();
    Code:
       0: aload_0
       1: getfield      #16                 // Field item:Ljava/lang/Object;
       4: areturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class test/Holder
       3: dup
       4: lconst_0
       5: invokestatic  #29                 // Method java/lang/Long.valueOf:(J)Ljava/lang/Long;
       8: invokespecial #35                 // Method "":(Ljava/lang/Object;)V
      11: astore_1
      12: aload_1
      13: invokevirtual #37                 // Method get:()Ljava/lang/Object;
      16: checkcast     #30                 // class java/lang/Long
      19: astore_2
      20: aload_1
      21: invokevirtual #37                 // Method get:()Ljava/lang/Object;
      24: astore_3
      25: aload_1
      26: invokevirtual #37                 // Method get:()Ljava/lang/Object;
      29: checkcast     #39                 // class java/lang/Number
      32: astore        4
      34: return
}

观察test.Holder(T)，我们发现putfield填充的域是Ljava/lang/Object类型，即 item 在编译好的class文件中，以Object类型存储， 这可以证明到了Object。只不过在调用get函数之后（即main函数13，21，26行之后）编译器会帮我们自动添加checkcast机器码来检查类型是否非法，而不需要我们在程序中显示的对类型进行强制转换。

既然在内部存储为Object，那么在类中就只能调用Object的方法，如果使用了其他的方法，如java.lang.Long类的longValue()方法，就会出现 The method longValue() is undefined for the type T错误，我们在原来的类的基础上增加print函数演示，如下所示：

public class MiddleHolder {
    T item;
    public MiddleHolder(T item) { this.item = item;}
    public MiddleHolder() {
        // TODO Auto-generated constructor stub
    }
    public void print() {
        System.out.println(item.toString());
        //The method longValue() is undefined for the type T
        //System.out.println(item.longValue());
    }
    public T get() {return item;}
    
    public static void main(String[] args) {
        Holder holder = new Holder(Long.valueOf(0L));
        Long long1 = holder.get();
        Object object = holder.get();
        Number number = holder.get();
        //Integer integer = holder.get();
    }
    
}

为了引进和 C++ 一样的功能，JAVA 改写了extends关键字，extends的申明方式是在占位符之后增加具体的类型，如下所示：

class ClassName {}

上面的定义表达的意思是，我是一个具体的类型，并且一定是 BaseClassName 的一个子类。

在我们这里，为了让 Holder 可以调用 Long 的方法，我们改写自己的程序如下所示：

public class Holder {
    T item;
    public Holder(T item) { this.item = item;}
    public Holder() {
        // TODO Auto-generated constructor stub
    }
    public void print() {
        item.longValue();
    }
    public T get() {return item;}
    
    public static void main(String[] args) {
        Holder holder = new Holder(Long.valueOf(0L));
        Long long1 = holder.get();
        Object object = holder.get();
        Number number = holder.get();
    }
}

这里告诉编译器我的 T 一定是 Long 的子类，那么编译器就会把类型擦除到 Long，反编译 class 文件，部分如下所示：

public class test.MiddleHolder {
  T item;

  public test.MiddleHolder(T);
    Code:
       0: aload_0
       1: invokespecial #13                 // Method java/lang/Object."":()V
       4: aload_0
       5: aload_1
       6: putfield      #16                 // Field item:Ljava/lang/Long;
       9: return

机器码第6行我们可以看到域的类型的确为 Long。

在这里，extends关键字也支持类和多个接口的定义，形式如下所示：

class ClassName

上面定义的意思就是说我的 T 是一个具体的类型，且继承了 BaseClassName，并且实现了 interfaceName1，interfaceName1 两个接口。那么也只能继承了 BaseClassName并且实现了 interfaceName1，interfaceName1 两个接口的类才可以作为他的泛型类型。

note

  • 每个名字间以 & 连接
  • 类只能有一个且只能放在左边，接口可以有多个
自限定类型的定义

我们考虑 Comparable 接口，JAVA 中 Comparable接口定义如下：

interface Comparable {
    public int compareTo(T o);
}

在实现过程中，我们往往希望是同种类型的不同实例进行比较，而不是跨类型的比较，那么我们就希望自己的函数有如下的形式：

class ComparableImp implements Comparable {
    @Override public int compareTo(ComparableImp o) {
        return 0;
    }
}

我们用类本身去填充 Comparable 的类型参数，就可以实现同一种类型的比较。

我们实现一个高级的 Holder，他可以存储一个可以在同类型中比较的对象，我们最开始的 HOlder 类型，当然可以存储这个对象，但是我们希望它能够更严格的定义，使得不能进行自比较的泛型无法存入这个 Holder 中，那么我们就需要重新定义泛型参数。如下所示：

public class AdvancedHolder> {
    
    T item;
    
    public T get() {
        return item;
    }
    
    public void set(T t) {
        item = t;
    }
    
    public int compare(T other) {
        return item.compareTo(other);
    }
    
    public AdvancedHolder() {
        // TODO Auto-generated constructor stub
    }
    
}

上述泛型的意义是我的 T 是实现了COmparable的子类，可以进行相互比较。

我们再定义一个无法自己比较的类如下所示，这个类和 String 进行比较：

class NormalComparableImp implements Comparable {

    @Override
    public int compareTo(String o) {
        // TODO Auto-generated method stub
        return 0;
    }
    
}

在编译器中，就会告诉我们 NormalComparableImp 不能作为泛型参数，如下所示：

public class test {

    public static void main(String[] args) {
        ComparableImp AWithCOmpare = new ComparableImp();
        NormalComparableImp normalComparableImp = new NormalComparableImp();
        AdvancedHolder holder1 = new AdvancedHolder<>();
        //Bound mismatch: The type NormalComparableImp is not a valid substitute for the bounded parameter > of the type AdvancedHolder
        //AdvancedHolder holder2 = new AdvancedHolder<>();
    }
    
}

note

  • 自限定类型的检查完全是编译器完成，在编译完成的class代码中，以AdvancedHolder为例，item会被擦除成Comparable

泛型使用

确定类型填充

我们需要在使用的时候填充占位符，有两种方式，一种方式是使用确定类型填充，一种方式是使用通配符填充。

确定类型填充即使指用变量名填充占位符，如：

class Holder {}
class AdvancedHolder> {}

public class Test {
    public static void main(String[] args) {
        Holder holder1 = new Holder<>();
        AdvancedHolder holder2 = new AdvancedHolder<>();
    }
}

以上都是使用确定类型填充占位符。需要注意的是确定类型要符合占位符的继承要求。

无界通配符

无界通配符为一个?，表示可能为任意满足extends要求的类型。下面是一个可能的使用案例。

public class Test {
    public static void main(String[] args) {
        Holder holder2 = new Holder<>();
    }
}
有界通配符

有界通配符有两种基本的形式，一种是? extends BaseClassName，代表继承了 BaseClassName 的某一个类；一种形式是? super BaseClassName，代表子类是 BaseClassName 的某一个类。

我们考虑一组继承关系，继承关系如下：

/*
        Fruit
        /  \
       /    \
     Apple Orange
      / \
     /   \
    Red  Green
*/

那么 就代表 Apple，Red，Green 其中的某一类。就代表 Apple，Fruit 中的某一类。

import java.util.LinkedList;
import java.util.List;

public class Test {
    
    public static void main(String[] args) {
        List fruits = new LinkedList();
        fruits.add(null);
        //The method add(capture#2-of ? extends Fruit) in the type List is not applicable for the arguments (Object)
        //fruits.add(new Object());
        //same exception
        //fruits.add(new Fruit());
    }

}

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
class Red extends Apple {}
class Green extends Fruit {}

在以上例子中，在List fruits = new LinkedList();中，因为 Apple 为 Fruit 的子类，所以一定满足条件，可以类比向上转型得到 List，即如果P是S的超类，那么 Pair就是Pair的子类型。

但是向上转型之后，List丢失了他具体的类型信息，他只知道自己存储的类型应该为 Fruit 的子类，但是并不知道是具体的哪个子类，有可能是 Apple，有可能是 Orange，甚至有可能是 Fruit。因为有可能在List内部可能会实际类的具体方法，如 MiddleHolder 所示，如果不知道具体的边界在哪里，很有可能会出现错误，所以编译器干脆禁止所有的类型添加，只允许 null 的添加。

note

  • Pair 就是 Pair， 因此，无限定通配符可以作为返回值，不可做入参。返回值只能保存在Object中。
  • P 不等于 P，P 是 P 的子类。

    我们来看 super 关键字，对程序略作修改。

    import java.util.LinkedList;
import java.util.List;

public class Test {
    
    public static void main(String[] args) {
        List fruits = new LinkedList();
        fruits.add(null);
        //The method add(capture#2-of ? super Fruit) in the type List is not applicable for the arguments (Object)
        //fruits.add(new Object());
        fruits.add(new Fruit());
    }

}

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}
class Red extends Apple {}
class Green extends Fruit {}
 
 
    super 关键字限定了泛型的下界，即我一定是子类本身或其祖先类。在编译器眼里，虽然不知道具体的类型，但是知道这个类一定是 Fruit 的父类，那么添加 Fruit 的子类到类表中就是安全的。但是同理，因为不知道是父类中的具体哪个类，所以添加父类（包括Object）都认为是不安全的。
     
 
     
 
    类型信息
     
 
     
 
    在运行期，泛型会被完全的擦除，只保留占位符。我们利用反射获得泛型参数的类型，代码如下列所示:
     
 
    public class Test {
    
    public static void main(String[] args) {
        List strings = new LinkedList<>();
        TypeVariable[] variables = strings.getClass().getTypeParameters();
        for (TypeVariable typeVariable : variables) {
            System.out.println(typeVariable);
        }
    }

}

//out: E

     
 
    可以看到，程序并不能知道泛型的具体类型是什么，只能知道有一个泛型参数。实际上，程序在运行时，所有的泛型类方法都会变成原始类。如下所示：
     
 
    public class Test {
    public static void main(String[] args) {
        ArrayList arrayList1=new ArrayList();
        arrayList1.add("abc");
        ArrayList arrayList2=new ArrayList();
        arrayList2.add(123);
        System.out.println(arrayList1.getClass()==arrayList2.getClass());
    }
}

     
 
    我们可以看到最后arrayList1和arrayList2的类型是相同的，都是 ArrayList 类。
     
 
    JAVA 不允许在泛型中使用类字面量来获得类的类型，但是原始类型可以。所谓类字面量就是通过.class关键词获得一个 Class 对象，例子如下：
     
 
        //不合法
    Class clazz = ArrayList.class;
    //不合法
    List list;
    //合法
    Class clazz1 = ArrayList.class;

     
 
    同时，在使用instanceof关键词时，使用参数化类型而非无限制通配符类型都是非法的，在这个时候使用无限制通配符类型替代原生态类型（对 instanceof 右操作数的规则），不会对instanceof操作产生任何不良的影响，即：
     
 
    public class Test {
    
    public static void main(String[] args) {
        List list = null;
        List list3 = null;
        List list2 = null;
         //非法，Cannot perform instanceof check against parameterized type List. Use the form List instead since further generic type information will be erased at runtime
        if (list instanceof List) {}
        //非法，理由同上
        if (list2 instanceof List) {}
        //非法，理由同上
        if (list3 instanceof List) {}
        if (list instanceof List) {}
        if (list2 instanceof List) {}
        if (list3 instanceof List) {}
        if (list instanceof List) {}
        if (list2 instanceof List) {}
        if (list3 instanceof List) {}
    }

}

     
 
    可以看到， instanceof 的右操作数不能够为泛型，只能为无限制通配符或者原生类型。
     
 
    如上，因为在运行态泛型会被擦除，所以与 List 比较并不规范。List 等效于原生类型，所以可以比较。
     
 
    因为在泛型擦除后，保留的是原始类型，所以特别要注意重载和重写。JAVA 不允许不同的泛型参数作为参数进行重写，例子如下：
     
 
    class A {
    public A() {}
    
    //下面两个print为非法重载，因为擦除后都是List，不能作为签名
    public void print(List list) {}
    public void print(List list) {}
}

     
 
    既然(List list)和(List list)都是一个签名，不允许重载，那么是不是就允许重写了呢？实际上 JAVA 也不允许这两个进行重写，例子如下：
     
 
    class A {
    public void print(List list) {}
}

class B extends A {
    //非法，The method print(List) of type B must override or implement a supertype method
    @Override public void print(List list) {}
}

     
 
    编译器会要求你去掉@override注解，以表明这不是一个继承的方法，但是去掉@Override
     注解之后，又会出现新的错误如下：
     
 
    Name clash: The method print(List) of type B has the same erasure as print(List) of type A but does not override it

     
 
    所以说，在泛型类作为参数时，要尽量避免重写和重载，不然，只有更换名字。
     
 
    同时，因为这个原因，我们还需要注意一点的是一个类或类型变量不可成为两个不同参数化的接口类型的子类型。如下例子：
     
 
    class Parent implements Comparator{

    @Override
    public int compare(Parent o1, Parent o2) {
        return 0;
    }
}

//非法
class Son extends Parent  implements Comparator   {
  //The interface Comparator cannot be implemented more than once with different arguments: Comparator and Comparator
}


     
 
    这很容易看出来，因为 Parent 继承了 Comparator，那么 Son 也间接继承了 Comparator，又因为 Son 直接继承了 Comparator，在擦除后 Comparator 和 Comparator 实际上都属于同一个类型，所以矛盾了。
     
 
     
 
    协变
     
 
     
 
    参数话类型是不可变的，即对于任意两个截然不同的类型 Type1 和 Type2 而言，不管 Type1 和 Type2 有什么继承关系，List 既不是 List 的子类型，也不是它的超类型，所以说，如下的写法有错：
     
 
    
public class Test {
    
    public static void main(String[] args) {
        List list = null;
        //非法，The method print(List) in the type Test is not applicable for the arguments (List)
        print(list);
        //合法，子类作为参数
        print(Integer.valueOf(0));
    }
    
    public static void print(List list) {}
    public static void print(Number number) {}

}


     
 
     
 
    实例
     
 
     
 
    PECS 模型
     
 
    PECS 模型指的是如果参数话类型表示一个 T 生产者，就使用，如果它表示一个 T 消费者，就是用。这也叫Get and Put Principal。通过一个实例来解式这个模型。
     
 
    如下，我们考虑实现一个最简单的堆栈。如下是他的公共API：
     
 
    public class Stack {
    public Stack() {}
    public void push(E e) {}
    public E pop() {}
    public boolean isEmpty() {}
}

     
 
    现我们考虑增加一个方法，将它按照顺序将一系列的元素全部放在堆栈中，代码如下：
     
 
    public void pushAll(Iterable src) {
    for (E e:src)
        push(e);
}

     
 
    考虑一个情景，我们有一个 Stack 的实例，我们想将一系列的 Integer 压入栈，我们调用 pushAll 方法，结果如下：
     
 
    public class Test {
    
    public static void main(String[] args) {
        Stack stack = new Stack<>();
        Iterable src = new ArrayList<>();
        //非法，The method pushAll(Iterable) in the type Stack is not applicable for the arguments (Iterable)
        stack.pushAll(src);
    }

}

class Stack {
    public Stack() {}
    public void push(E e) {}
    public E pop() {return null;}
    public boolean isEmpty() {return false;}
    
    public void pushAll(Iterable src) {
        for (E e:src)
            push(e);
    }
    
}

     
 
    因为参数话类型的不可协变，Stack 实例的 pushAll 方法要求提供一个 Iterable 参数，但是我们给的却是一个 Iterable 实例，所以会报错。
     
 
    这就需要第一个原则，PE原则。因为在参数中，src 充当着生产者的角色，即 src 给其他地方提供数据，我们就使用代替T，修改之后的代码如下：
     
 
    class Stack {
    public Stack() {}
    public void push(E e) {}
    public E pop() {return null;}
    public boolean isEmpty() {return false;}
    
    public void pushAll(Iterable src) {
        for (E e:src)
            push(e);
    }


     
 
    这样，我们就把通配符限制在了 E 及其子类中，在讲有界通配符时，我们知道 ClassNmae 可以向上转型为 ClassName，所以在此运行测试代码时不会出现错误。
     
 
    我们继续增加一个popAll方法，将堆栈的数据添加到指定的几何中。代码如下：
     
 
    public void popAll(Collection dst) {
    while(!isEmpty())
        dest.add(pop());
}

     
 
    同理，我们想将元素全部弹出到一个泛型为 Object 的容器中，代码如下：
     
 
    public class Test {
    
    public static void main(String[] args) {
        Stack stack = new Stack<>();
        Collection collection = new ArrayList<>();
        //非法，The method popAll(Collection) in the type Stack is not applicable for the arguments (Collection)
        stack.popAll(dst);
    }

}

class Stack {
    public Stack() {}
    public void push(E e) {}
    public E pop() {return null;}
    public boolean isEmpty() {return false;}
    
    public void pushAll(Iterable src) {
        for (E e:src)
            push(e);
    }
    
    public void popAll(Collection dst) {
        while(!isEmpty())
            dest.add(pop());
    }
    
}
 
 
    和上面是一样的问题，只不过这时我们需要向下转型，这就是第二个原则，CS原则。我们用代替T，修改之后的代码如下：
     
 
    class Stack {
    public Stack() {}
    public void push(E e) {}
    public E pop() {return null;}
    public boolean isEmpty() {return false;}
    
    public void pushAll(Iterable src) {
        for (E e:src)
            push(e);
    }
    
    public void popAll(Collection dst) {
        while(!isEmpty())
            dest.add(pop());
    }
    
}

     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(JAVA-泛型)
    
        
    
            
    
                
      
                    
    • Java【泛型】
                        SkyrimCitadelValinor
Java基础java
                        
      Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
      
                    
      • 
                    
    • C# 开发教程-入门基础
                        天马3798
教程系列整理c#开发语言
                        
      1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
      
                    
      • 
                    
    • 终于搞懂TS中的泛型啦! | typescript 入门指南 04
                        程序员王天
TypeScript实践指南前端javascripttypescript
                        
      大家好，我是王天~今天分享的是《ts入门指南》系列中第四篇，主要讲解ts中的泛型应用泛型在ts中是比较重要的概念，我花挺长时间才搞明白，整理输出这篇文章，希望能帮助到大家~《ts入门指南》系列，点击下方蓝色字体即可访问TsvsJs谁适合前端开发？|TypeScript入门指南01详解tsconfig.json配置文件|TypeScript入门指南02必学！TypeScript语法类型基础|Type
      
                    
      • 
                    
    • Java泛型编程
                        shymoy
java开发语言
                        
      文章目录为什么需要泛型如何实现技术细节泛型数组泛型类型实现接口接收参数小结为什么需要泛型如果为每一种类型都写一个类来适配，会造成code冗长且难读，所以需要写一个同一的抽象的方法来实现，并让编译器自动的传入这些类型。如何实现通常放在类后面的尖括号里publicclassGenertic{}也可以指代多个publicclassGenertic{}这个类中的变量都可以用K和V来表示了泛型不仅可以应用在
      
                    
      • 
                    
    • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
      下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
      
                    
      • 
                    
    • Java-网络
                        胡净
java网络开发语言
                        
      Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。1.网络协议Java支持多种网络协议，最常用的包括：TCP（传输控制协议）：面向连接的协议，确保数据的可靠传输。UDP（用户数据报协议）：无连接的协议，适用于对速度要求高但对可靠性要求低的应用。网络通信模型通常指的是OSI（开放系统互联）模型，它将网络通信分为七个层次。每一层
      
                    
      • 
                    
    • Java-后端程序员个人知识总结
                        金肴羽
java开发语言
                        
      文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
      
                    
      • 
                    
    • .NET常见面试题汇总
                        .Net Core 爱好者
.netc#
                        
      首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
      
                    
      • 
                    
    • Swift基本语法-简例
                        ☆MOON
移动互联网-iOS笔记python正则表达式爬虫
                        
      Swift基本语法简例安全类型?与!区别变量与常量字符串拼接多行字符串数组操作字典操作数组遍历控制条件判断switch语句循环遍历函数闭包对象枚举结构体协议扩展泛型get，set属性属性观察懒加载，重写方法回调及保护安全类型?与!区别?表示：返回值是一个可选类型，需要解包处理，如果有值就是相应类型的，如果没有值，就是“nil”，适用于不确定值的情形!表示：不需要解包处理（第一次赋值时编译器已自动解
      
                    
      • 
                    
    • 包装类&认识泛型
                        秃头的赌徒
JAVASEjavajvm开发语言
                        
      目录一、包装类1.1基本数据类型和对应的包装类1.2装箱和拆箱二、泛型2.1语法三、泛型类的使用3.1语法3.2示例3.3类型推导3.4裸类型四、泛型如何编译的4.1擦除机制4.2为何不能实例化泛型类型数组五、泛型的上界5.1语法5.2示例5.3复杂示例六、泛型方法6.1定义语法6.2示例一、包装类定义：在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给
      
                    
      • 
                    
    • flutter 泛型_Flutter入门——泛型
                        weixin_39627408
flutter泛型
                        
      在查看基本数组类型List的API文档，会看到该类型实际上是List。表示法将List标记为泛型(或参数化)类型-具有正式类型参数的类型。按照惯例，大多数类型变量都有单字母名称，例如E，T，S，K和V.为什么要使用泛型类型安全通常需要泛型，除了允许让代码运行之外，还可以：正确指定泛型类型会生成更好的代码。例如，可以使用List(字符串列表)，来表示列表中只包含字符串，这样编译器就会启用类型检查，非
      
                    
      • 
                    
    • Java 知识框架主要包括面向对象、集合框架、异常处理、泛型和多线程等知识
                        爱摄影的程序猿
JAVA面试java开发工具windowsjavaspringboot
                        
      Java知识框架主要包括面向对象、集合框架、异常处理、泛型和多线程等知识。下面将对每个知识点进行详解，并提供相关的案例和面试题解答。面向对象：面向对象是Java的核心思想，它将程序中的数据和操作封装成对象，并通过对象之间的交互实现程序的功能。在面向对象的思想中，包括类、对象、继承、多态等概念。案例：创建一个学生类，包含学生的姓名和年龄属性，以及获取学生信息和修改学生信息的方法。publicclas
      
                    
      • 
                    
    • 泛型和通配符
                        当归. z Z
java基础java
                        
      泛型所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值或参数的类型。这个类型参数将在使用时（例如，继承或实现这个接口、创建对象或调用方法时）确定（即传入实际的类型参数，也称为类型实参）。例如，集合类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK5.0之前只能把元素类型设计为Object，JDK5.0时Java引入了“参数化类型
      
                    
      • 
                    
    • C++ 萃取技术——固定萃取技术
                        不是仙人的闲人
#C++模板与泛型编程c++开发语言
                        
      目录C++萃取技术——固定萃取技术1.萃取技术简介2.固定萃取技术2.1固定萃取常规范例2.2迭代器范例2.3通过容器（数组）类型萃取元素类型范例2.4引用类型的移除和增加2.5const修饰符的移除2.6退化技术总结C++萃取技术——固定萃取技术在C++的模板和泛型编程领域，“萃取”（trait）技术发挥着至关重要的作用。这种技术让程序能够在编译时对类型执行各种操作和计算，有效提取和利用类型信息
      
                    
      • 
                    
    • kotlin中Gson解析Json时对于泛型的应用
                        张子羽
安卓三分钟jsonkotlinandroid
                        
      Gosn解析Json我们都知道，在使用Gson解析json时，可以通过如下代码将json转为实体类valuser=Gson().fromJson(json,UserBean::class.java)实体类的定义而在开发过程中，我们也可能遇到这样的Json数据//一个登陆接口返回的数据{"data":{"admin":false,"chapterTops":[],"coinCount":10,"co
      
                    
      • 
                    
    • Kotlin reified改造JSON解析
                        折翅鵬
Kotlinkotlinjson开发语言
                        
      reified有什么用？funmyGenericFun(c:Class)在myGenericFun泛型函数体内，无法访问类型T，因为T只有在编译时可用，但在运行时就被擦除了，也就是泛型擦除，。因此，如果想在函数体中使用泛型类型作为普通类型使用，就需要显式将该类作为参数传递，如myGenericFun中所示。如果使用reifiedT创建内联（inline）函数，则就算在运行时也可以访问T的类型，因此
      
                    
      • 
                    
    • Java 类型擦除机制详解
                        项目笔记与工具库
java开发语言
                        
      Java的类型擦除机制（TypeErasure）是Java泛型中一个非常重要的特性。通过类型擦除，Java既实现了泛型功能，又能保持与旧版本的向后兼容性。本文将详细介绍Java类型擦除机制的工作原理、步骤、影响以及相关示例。什么是类型擦除？类型擦除是指在编译时，Java编译器会将泛型类型转换为原始类型（rawtype），并删除或替换与类型参数相关的类型信息。换句话说，在编译后的字节码中，泛型的具体
      
                    
      • 
                    
    • Scala教程之:静态类型
                        flydean程序那些事

                        
      Scala是静态类型的，它拥有一个强大的类型系统，静态地强制以安全、一致的方式使用抽象，我们通过下面几个特征来一一说明：泛类型型变类型上界类型下界内部类抽象类型复合类型自类型隐式参数隐式转换多态方法类型推断通过这些特性，为安全可重用的编程抽象以及类型安全的扩展提供了强大的基础。泛类型和java一样，Scala也有泛型的概念，在scala里面泛型是使用方括号[]来接受类型参数的。通常使用字母A来作为
      
                    
      • 
                    
    • Vue3异步请求的最佳实践：async/await 与 Promise.then()，Vue3请求接口数据，以及TypeScript中的泛型和任意类型（Vue3请求API，TS中的T 和 any）
                        北城笑笑
VueJS前端vue.js
                        
      前言在Vue3开发中，异步请求是非常常见的操作，特别是在与后端API交互时。虽然Vue.js自带了一些对异步数据的处理方式，但合理使用异步操作是确保应用顺畅运行的关键。这里我分享一下Vue3异步请求的最佳实践，并探讨async/await和Promise.then()两种处理异步操作的方式，简单记录一下1.请求接口的实现这里，我们使用一个请求接口callAskRecordList，它会从/gpt/
      
                    
      • 
                    
    • C# List用法 List介绍
                        光怪陆离的节日
C#c#list开发语言
                        
      #List泛型集合集合是OOP中的一个重要概念，C#中对集合的全面支持更是该语言的精华之一。为什么要用泛型集合？在C#2.0之前，主要可以通过两种方式实现集合：a.使用ArrayList直接将对象放入ArrayList，操作直观，但由于集合中的项是Object类型，因此每次使用都必须进行繁琐的类型转换。b.使用自定义集合类比较常见的做法是从CollectionBase抽象类继承一个自定义类，通过对
      
                    
      • 
                    
    • C# List定义和常用方法
                        語衣
C#知识补充c#list
                        
      栏目总目录List的定义列表（List）是一种常用的集合类型，它属于System.Collections.Generic命名空间。列表是一个有序集合，可以包含重复的元素，并且可以根据索引访问元素。ListList是一个泛型集合，它提供了比数组更灵活的方式来存储和操作数据。List继承自IList接口，并实现了许多用于添加、移除、搜索、排序等操作的方法。通过指定类型参数T来定义一个List。例如存储
      
                    
      • 
                    
    • Java基础 -- 05反射reflect
                        mmlz00
Java基础Java基础反射reflectProxy动态代理
                        
      目录引序说不通1：注解说不通2：匿名内部类说不通3：动态代理反射：反射定义强调：类对象又强调：static类静态成员再三强调：synchronized修饰符类对象：知晓类结构类结构之：内部成员内部成员--构造函数内部成员--数据成员内部成员--方法成员静态代理：动态代理：反射+注解反射+泛型+注解getGenericSuperclass()用法引序引序：开始反射概念学习之前，先来段引序。请牢记：计
      
                    
      • 
                    
    • .NET/C#⾯试题汇总系列：集合、异常、泛型、LINQ、委托、EF！
                        微微的猪食小窝
c#.netlinq
                        
      1.IList接⼝与List的区别是什么?‌定义与继承关系‌：IList是一个接口，定义了一组对象的集合，这些对象可以通过索引进行访问，并且支持插入、删除和搜索等操作。它继承自ICollection和IEnumerable，以及它们的非泛型版本。List是一个类，实现了IList接口。它提供了接口中定义的所有方法的具体实现，并添加了一些额外的功能，如排序、搜索等。‌功能与灵活性‌：使用IList接
      
                    
      • 
                    
    • ToList()和ToArray()的区别
                        微微的猪食小窝
.Net进阶.net后端开发语言linqc#
                        
      以下是具体分析：1.返回类型ToList()：返回一个泛型列表List，其中T是列表中元素的类型。ToArray()：返回一个Object类型的数组。如果需要特定类型的数组，必须使用重载的ToArray(T[]a)方法，并传入一个该类型的数组作为参数。2.内部处理ToList()：直接创建一个新的List，并将元素添加到这个List中。ToArray()：根据传入的数组参数情况，可能会创建新数组或
      
                    
      • 
                    
    • Java-实现双向环形链表
                        Bro_cat
数据结构与算法链表数据结构java双向环形链表
                        
      双向链表是一种常用的数据结构，其特点是每个节点不仅包含数据，还持有指向前一个节点和后一个节点的指针。与普通双向链表不同的是，它的哨兵节点的prev指向最后一个元素，而最后一个元素的next指向哨兵。具体双向普通链表可以参考我的上篇文章，这里是传送门。什么是双向环形链表？双向环形链表不仅支持双向遍历，还形成一个闭合环，即最后一个节点的next指针指向链表的头部，第一个节点的prev指针指向链表的尾部
      
                    
      • 
                    
    • ThreadLocal
                        血莲丹
JAVA基础java多线程内存泄漏ThreadLocal
                        
      简介  我们都知道，多线程情况下，是会有资源竞争问题。当并非访问某共享资源时，就会出现问题，尤其是写操作，程序猿一般通过同步锁机制来保证线程安全。而当我们需要为每一个线程都保存一份线程独有的数据时，即相当于将共享变量变为每个线程都有一份的私有变量，就可以使用到ThreadLocal。  ThreadLocal位于java.lang包下，是JDK提供的一个类，支持泛型的。该类的作用就如其名字一样，线
      
                    
      • 
                    
    • Android 面试题——如何徒手写一个非阻塞线程安全队列 ConcurrentLinkedQueue？_android concurrentlinkedqueue
                        2401_84265972
程序员android安全
                        
      队列容器设计若用数组作为队列的容器，就必须得加锁，因为数组是一块连续内存地址，多线程场景下，读写同一块内存地址不得不互斥地访问。链式结构链式结构就没有这个烦恼。链的每个结点都对应不同的内存地址，在多线程场景下，取头结点和插尾结点就不存在并发问题。（至少是降低了并发问题产生的概率）通用的队列应该可存放任何类型的元素。综上，就得声明一个带泛型的链结点：//结点privatestaticclassNod
      
                    
      • 
                    
    • Java泛型中 T 与 T的区别和用法
                        Java大数据布道者

                        
      T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据，通过返回值T和T的两种方法实现一、T用法TT.png二、T用法T.pnggoldmei.png
      
                    
      • 
                    
    • Maven项目结构说明
                        HachiLin
SpringBootmavenspringboot微服务
                        
      1.maven概念是一个基于Java平台的自动化构建工具（make->ant->maven->gradle，它主要有五大功能：（1）清理：删除编译的结果，为重新编译做准备（2）编译：java->class（3）测试：针对与项目中的关键点进行测试，方便开发人员与测试人员交互（4）报告：将测试结果进行显示（5）打包：将项目中包含的多个文件压缩成一个文件，用于安装或部署（java项目打成jar包，web
      
                    
      • 
                    
    • windows C++-并行编程-并行模式库 (PPL)
                        sului
windowsC++并行编程技术c++开发语言windows
                        
      并行模式库(PPL)提供命令式编程模型，以促进开发并发应用程序的可扩展性和易用性。PPL构建在并发运行时的计划和资源管理组件上。通过提供并行作用于数据的泛型安全算法和容器，提高应用程序代码与基础线程机制之间的抽象级别。使用PPL还可以开发通过为共享状态提供替代方案实现缩放的应用程序。PPL提供以下功能：任务并行：基于Windows线程池来并行执行多个工作项（任务）的机制并行算法：基于并发运行时来并
      
                    
      • 
                                
    • java线程的无限循环和退出
                                    3213213333332132
java
                                    
      最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 
突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 
希望帮助刚学java线程的童鞋 
 

package thread;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date
      
                                
      • 
                                
    • tomcat 容器
                                    BlueSkator
tomcatWebservlet
                                    
      Tomcat的组成部分 1、server 
A Server element represents the entire Catalina servlet container. (Singleton) 2、service 
service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。 
  3、connector 
一个connector
      
                                
      • 
                                
    • php递归,静态变量,匿名函数使用
                                    dcj3sjt126com
PHP递归函数匿名函数静态变量引用传参
                                    
        
<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Current To-Do List</title>
</head>
<body>
      
                                
      • 
                                
    • 属性颜色字体变化
                                    周华华
JavaScript
                                    
      function changSize(className){ 
 
 var diva=byId("fot") 
 diva.className=className; 
 } 
</script> 
<style type="text/css"> 
 .max{ 
 background: #900; 
 color:#039; 
 
      
                                
      • 
                                
    • 将properties内容放置到map中
                                    g21121
properties
                                    
      代码比较简单： 
private static Map<Object, Object> map;
private static Properties p;

static {
	//读取properties文件
	InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
      
                                
      • 
                                
    • [简单]拼接字符串
                                    53873039oycg
字符串
                                    
               工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下： 
          
import java.util.HashMap;
import java.uti
      
                                
      • 
                                
    • Struts2学习
                                    云端月影

                                    
      最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 
配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 
使用Convention插件，你需要将其JAR文件放
      
                                
      • 
                                
    • Java新手入门的30个基本概念二
                                    aijuans
java新手java 入门
                                    
      基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
      
                                
      • 
                                
    • jedis 简单使用
                                    antlove
javarediscachecommandjedis
                                    
      jedis.RedisOperationCollection.java 
package jedis;

import org.apache.log4j.Logger;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

pub
      
                                
      • 
                                
    • PL/SQL的函数和包体的基础
                                    百合不是茶
PL/SQL编程函数包体显示包的具体数据包
                                    
      由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,, 
  
函数; 
函数:PL/SQL中的函数相当于java中的方法;函数有返回值
定义函数的
--输入姓名找到该姓名的年薪
create or re
      
                                
      • 
                                
    • Mockito(二)--实例篇
                                    bijian1013
持续集成mockito单元测试
                                    
              学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。 
        比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
      
                                
      • 
                                
    • 精通Oracle10编程SQL(7)编写控制结构
                                    bijian1013
oracle数据库plsql
                                    
      /*
 *编写控制结构
 */
 
--条件分支语句
--简单条件判断
DECLARE
  v_sal NUMBER(6,2);
BEGIN
  select sal into v_sal from emp
  where lower(ename)=lower('&name');
  if v_sal<2000 then
     update emp set
      
                                
      • 
                                
    • 【Log4j二】Log4j属性文件配置详解
                                    bit1129
log4j
                                    
      如下是一个log4j.properties的配置 
  
log4j.rootCategory=INFO, stdout , R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appe
      
                                
      • 
                                
    • java集合排序笔记
                                    白糖_
java
                                    
      public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{
	
	private static final long serialVersionUID = -2958090810811192128L;
	
	private int id;
	private String nam
      
                                
      • 
                                
    • java导致linux负载过高的定位方法
                                    ronin47

                                    
      定位java进程ID 
可以使用top或ps -ef |grep java
![图片描述][1]
 根据进程ID找到最消耗资源的java pid 
比如第一步找到的进程ID为5431
执行
top -p 5431 -H
![图片描述][2]
 打印java栈信息 
$ jstack -l 5431 > 5431.log
 在栈信息中定位具体问题 
将消耗资源的Java PID转
      
                                
      • 
                                
    • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数
                                    bylijinnan
函数
                                    
      
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class RandNFromRand5 {

	/**
	 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。
	 
	 解法1：
		 f(k) = (x0-1)*5^0+(x1-
      
                                
      • 
                                
    • PL/SQL Developer保存布局
                                    Kai_Ge

                                    
            近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段： 
  
&n
      
                                
      • 
                                
    • [未来战士计划]超能查派[剧透,慎入]
                                    comsci
计划
                                    
             非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........ 
 
 
       虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活.... 
 
   &nbs
      
                                
      • 
                                
    • Google Map API V2
                                    dai_lm
google map
                                    
      以后如果要开发包含google map的程序就更麻烦咯 
 
http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 
 
找到篇不错的文章，大家可以参考一下 
 
http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 
 
1. 创建Android工程 
由于v2的key需要G
      
                                
      • 
                                
    • java数据计算层的几种解决方法2
                                    datamachine
javasql集算器
                                    
      2、SQL 
    SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。 
 
    成熟度：5星。最成熟的。 
  
      
                                
      • 
                                
    • Linux下Telnet的安装与运行
                                    dcj3sjt126com
linuxtelnet
                                    
       
Linux下Telnet的安装与运行       linux默认是使用SSH服务的 而不安装telnet服务    如果要使用telnet 就必须先安装相应的软件包    即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置   如果是redhat9，则在第三张光盘中找到   telnet-server-0.17-25.i386.rpm  
      
                                
      • 
                                
    • PHP中钩子函数的实现与认识
                                    dcj3sjt126com
PHP
                                    
      假如有这么一段程序： 
 
 function fun(){ 
  fun1(); 
  fun2(); 
 } 
 
  首先程序执行完fun1()之后执行fun2()然后fun()结束。 
  但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。 
  我们可以在fu
      
                                
      • 
                                
    • EOS中的WorkSpace密码修改
                                    蕃薯耀
修改WorkSpace密码
                                    
      EOS中BPS的WorkSpace密码修改 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 201
      
                                
      • 
                                
    • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】
                                    hanqunfeng
SpringSecurity
                                    
       SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下： 
  
applicationContex
      
                                
      • 
                                
    • ie 9 kendo ui中ajax跨域的问题
                                    jackyrong
AJAX跨域
                                    
      这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 
浏览起来是没问题的，但把应用放到公网上的一台服务器， 
却发现如下情况： 
 
 
1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题 
 
      
                                
      • 
                                
    • 不要让别人笑你不能成为程序员
                                    lampcy
编程程序员
                                    
      在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 
说实话，我感觉我的脑细胞像被轰炸过一样。 
手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 
难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 
我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
      
                                
      • 
                                
    • 马皇后的贤德
                                    nannan408

                                    
         马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 
 
　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
      
                                
      • 
                                
    • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以）
                                    Rainbow702
sqlgroup by最大值max最大的那条记录
                                    
      好久好久不写SQL了，技能退化严重啊！！！ 
  
直入主题： 
比如我有一张表，file_info， 
它有两个属性（但实际不只，我这里只是作说明用）： 
file_code, file_version 
同一个code可能对应多个version 
现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， 
SQL如下： 
select 
    *

      
                                
      • 
                                
    • VBScript脚本语言
                                    tntxia
VBScript
                                    
        
VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。 
  VB家族语言简介 
  
 
 Visual Basic 6.0 
 
          源于BASIC语言。 
          由微软公司开发的包含协助开发环境的事
      
                                
      • 
                                
    • java中枚举类型的使用
                                    xiao1zhao2
javaenum枚举1.5新特性
                                    
      枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量. 
  1.定义一个简单的枚举类型 
public enum Sex {
	MAN,
	WOMAN
} 
  
枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型. 
  2.常用方法 
静态的values()方
      
                                
      •