进步·于辰
进步·于辰

关于对Java泛型的理解与简述（读后简结）

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/129773883
出自【进步*于辰的博客】

请先浏览序言！！这对后续阅读一定有所帮助。
由于之前对泛型的学习不够全面，就想找一些博文取取经，其中一位前辈的创文【java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一】（转发）让我受益匪浅！！。
现在回头看，觉得应该写点什么。一是希望能帮助大家更容易地理解和运用泛型；二是对泛型这个知识点进行一次梳理。
当然，前辈们总结的已经很全面，我又怎会班门弄斧。
因此，这篇文章可以说是我阅读完那篇文章后的 读后小结 \color{red}{读后小结} 读后小结。为什么这么说呢？是这样，那位前辈是基于知识分享的角度来撰写那篇文章，更加注重全面、整体，在一些细节上难免有所省略；而我是初次系统地学习泛型这个知识点，为了更好地理解，做了很多测试，又为了让我的阐述更有证明力，就把那些示例都迁移到这篇文章中。简言之， 一一解释、通俗易懂 \color{green}{一一解释、通俗易懂} 一一解释、通俗易懂。
参考笔记三，P21.1、P42.1。

注：向那位前辈的博文借两个概念：泛型声明称之为类型形参，指定泛型具体类型称之为类型实参。

文章目录

  • 1、关于类型判断
  • 2、关于继承泛型类或实现泛型接口
  • 3、关于泛型通配符
    • 3.1 铺垫
    • 3.2 概述
  • 4、关于泛型方法
    • 4.1 概述
    • 4.2 一个疑惑
  • 5、关于泛型上下边界
    • 5.1 全局泛型处定义
    • 5.2 局部泛型处定义
    • 5.3 泛型通配符处定义
      • 5.3.1 概述
      • 5.3.2 单独使用``时
      • 5.3.3 局部泛型与``连用时
    • 5.4 上下边界的说明示例
      • 5.4.1 示例1
      • 5.4.2 示例2
      • 5.4.3 示例3
      • 5.4.4 示例补充说明
    • 5.5 上下边界注意事项
  • 6、关于在静态方法中使用泛型
  • 7、一个巨大的错误
    • 7.1 整个事情发展
    • 7.2 柳暗花明但又疑云重重
  • 8、扩展
  • 9、最后

1、关于类型判断

instanceOf 可用于判断类型，但如下情况不允许，因为已经指定类型实参。

obj instanceOf List<Integer>

留言： \color{brown}{留言：} 留言：其实我不理解其中缘由，欢迎各位博友评论区讨论！

2、关于继承泛型类或实现泛型接口

当继承泛型类或实现泛型接口时，泛型类或泛型接口的类型形参的标识不一定要与其声明时的类型形参一致。若泛型类或泛型接口上带有类型形参，则此类也必须声明此类型形参。
如：

声明：class/interface Generic<T> 

继承或实现时：
// E与T是同一个，且前后两个类型形参的标识必须相同
class Car<E> extends/implements Generic<E>
或
class Car extends/implements Generic

3、关于泛型通配符

3.1 铺垫

大家先看个示例。

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(2, 0, 2, 3);
    List<String> list2 = Arrays.asList("CHAT", "GPT");
    print(list1);// 编译报错
    print(list2);// 编译报错
}

public static void print(List<Object> list) {
    sout list;
}

为何两次调用 \color{grey}{为何两次调用} 为何两次调用print() 都编译报错？ \color{grey}{都编译报错？} 都编译报错？
我的思考：List、List和 List这三个的类型都是List，只是类型实参不同。而 Object 是 Integer 和 String 的父类，为何不能传递？

经查阅资料，我了解到一个新概念： 泛型擦除 \color{red}{泛型擦除} 泛型擦除。

“泛型擦除”指在通过泛型检查后，将类型实参擦除，并上转为其上界类型Object的一种机制。

因此，List和 List中的类型实参会被擦除，并转为Object，而 List也同样如此。
既然如此，为何还不能传递？

留言： \color{brown}{留言：} 留言：这也是我始终不解之处，望各位博友不吝赐教！！

3.2 概述

List的确不能接收 List和 List，尽管我暂不知其原理，但问题仍要解决。
如何解决上面的编译报错问题？ \color{grey}{如何解决上面的编译报错问题？} 如何解决上面的编译报错问题？

关于泛型通配符的理论，目前我还不知如何阐述。大家暂且可以这么理解：表示任意类型。

引入。

 public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(2, 0, 2, 3);
    List<String> list2 = Arrays.asList("CHAT", "GPT");
    print(list1);// 打印：[2, 0, 2, 3]
    print(list2);// 打印：[CHAT, GPT]
}

public static void print(List<?> list) {
	sout list;
}

注意： \color{red}{注意：} 注意：
表示任意类型。换言之：未知，表示对某个泛型未知。因此，必须放置在类型形参的位置。
如：

List<?> list;
Class<?> class;
Map<?, ?> map;

而不能“无中生”。

public void print(? obj) {}

4、关于泛型方法

4.1 概述

关于泛型方法，当初我在阅读那位前辈的博文时，由于是第一次接触这个新概念，着实摸不着头脑，好半天才弄懂。我归纳了两点：

  1. 泛型类或泛型接口的类型形参可理解为 全局泛型 \color{green}{全局泛型} 全局泛型，而在方法上声明的泛型可理解为 局部泛型 \color{blue}{局部泛型} 局部泛型。（大家注意“声明”二字）
    这是什么意思？大家以全局变量和局部变量的特性来理解就懂了。
  2. 引入泛型方法的目的是什么？ \color{grey}{引入泛型方法的目的是什么？} 引入泛型方法的目的是什么？
    首先，大家先回忆一下“局部变量”有什么特性，第一，局部变量的生命周期仅在其声明或定义的当前方法内；第二，局部变量不受全局变量限制和影响。同样，局部泛型也具备这两个特性。
    例如，你需要定义一个方法来实现某种功能，那么，形参的参数类型、参数个数等等是不是都可以任意，对吧？此时你需要去考虑全局变量吗？比如：它们的名字是不是一样？它们的类型是不是一样？等等。。。需要考虑吗？当然不需要！！就是这个道理。

结论： \color{red}{结论：} 结论：

方法的类型形参是独立于泛型类或泛型接口的类型形参存在的。
全局泛型的类型实参由实例化时指定（指定具体类，如：Generic），而局部泛型的类型实参由方法调用时实参的类型决定。

哈哈。。。有点绕口啊，大家继续往下看就明白了。

举个栗子。

class Test {
    class TestGeneric<T> {
        public <E> void print(E e) {
            sout e;// 打印：10
            sout e instanceof Integer;// 打印：true
        }
    }

    public static void main(String[] args) {
        TestGeneric<String> g1 = new Test().new TestGeneric();
        g1.print(10);
    }
}

在此示例中，泛型类TestGeneric 只声明了一个泛型，那print()内使用的泛型是哪来的？ 独立声明一个泛型 \color{red}{独立声明一个泛型} 独立声明一个泛型，这就是泛型方法。
泛型独立于类 TestGeneric 存在，与泛型无关。 何为“无关”？ \color{grey}{何为“无关”？} 何为“无关”？如：可以与同名，而它们的类型实参可以不同。

的类型实参由实例化时指定，为String；
的类型实参由print()调用时的实参类型决定，数字10的类型是什么？是Integer。故的类型实参为Integer。

如果把E重命名为T也是一样的，局部泛型不受全局泛型限制。

4.2 一个疑惑

大家看到这里肯定有一个疑惑：“泛型方法的确可以独立于泛型类或泛型接口声明泛型，但我把泛型置于泛型类TestGeneric 上声明还不是可以实现同样的功能。那泛型方法有什么用？”
没错，的确一样。

不过，我假设一种情况。有100个地方使用了泛型类 TestGeneric，且有66个地方都指定了类型实参。而我现在需要在类 TestGeneric 内定义一个方法来实现某种功能，而这个方法需要使用另一个泛型，如何解决？

如果不用泛型方法，而是将新增泛型声明到类 TestGeneric 上（即），那结果是什么？我需要修改66个地方的类型实参列表（给也指定类型实参）。这就是泛型方法的作用。

5、关于泛型上下边界

先说结论： \color{red}{先说结论：} 先说结论：

上边界的本质是为类型形参定义一个父类或超类，而下边界的本质是为类型形参定义一个子孙类。
从而实现 限制类型实参选择范围 \color{green}{限制类型实参选择范围} 限制类型实参选择范围的作用。

上下边界一共有3个定义位置，以下我会一一进行解释。

为了便于大家理解和阐述，我定义了 A、B、C 三个类，这3个类是依次继承的关系，将用作类型实参。
下图是这3个类的继承关系图。
关于对Java泛型的理解与简述（读后简结）_第1张图片

5.1 全局泛型处定义

待测试类：

class TestBound<T extends A> {}

测试：

TestBound<A> t1 = new TestBound();// 编译通过
TestBound<B> t2 = new TestBound();// 编译通过
TestBound<C> t3 = new TestBound();// 编译通过

示例中定义的上边界是A，实例化时指定的类型实参分别是A、B、C，都编译通过。

因此，关键字extends的作用是将类型实参的范围限制为“上边界”的子孙类。

5.2 局部泛型处定义

待测试泛型方法：

public <T extends A> void testExtends(T t) {}

测试：

TestBound t1 = new TestBound();
t1.testExtends(new A());// 编译通过---------a
t1.testExtends(new B());// 编译通过---------b
t1.testExtends(new C());// 编译通过---------c

示例中定义的上边界是A，根据上文可知：局部泛型的类型实参由方法调用时实参的类型决定。a/b/c 三处的实参的类型分别是A、B、C，都编译通过。

可见，局部泛型上边界的作用与全局泛型相同。

5.3 泛型通配符处定义

5.3.1 概述

注：为什么在上述全局泛型和局部泛型处，我不提及“下边界”？（第5.5项的第2点有答案）

常见的有2种形式：

  1. 在单独使用时，定义泛型上下边界；
  2. 在局部泛型与连用时，定义泛型上下边界。

在上述的阐述中，只解释了这种格式，其表示“上边界”，而“下边界”的定义是，这是什么意思？

解释 \color{purple}{解释} 解释。

其实在学习“泛型上下边界”时，我就有个疑惑：上文所有对泛型上下边界的定义，都是通过extends关键字实现的，这仅仅是“上边界”，那“下边界”在哪？

我写过一些关于Java-API 的文章，在解析API时，我注意到了super这个关键字。尽管我暂且没有找到关于这种格式的文章，但经过测试，得出了答案。

示例：
待测试类：

class TestBound<T> {
    public void testSuper(List<? super T> list) {}
}

测试：

TestBound<C> t1 = new TestBound();// 定义全局泛型 T 的类型实参为 C
List<C> list1 = new ArrayList<>();
t1.testSuper(list1);// 编译通过
List<B> list2 = new ArrayList<>();
t1.testSuper(list2);// 编译通过
List<A> list3 = new ArrayList<>();
t1.testSuper(list3);// 编译通过

从上文中extends关键字的示例，再比对此示例，就可以很容易看出super关键字的作用了。

因此，关键字super的作用是将类型实参的范围限制为“下边界”的父类或超类。

5.3.2 单独使用时

上面概述中的示例就是在单独使用时，定义上下边界。

5.3.3 局部泛型与连用时

例如：

public <T> void show(List<? extends/super T> list) {}

这种情形我开始也不理解，何出此言？
表示可接收任意类型，而的类型实参由调用show()时实参的类型决定，也是任意类型。

那问题来了：
这两者连用，还有何意义？这种格式到底是什么意思？
连用有何作用？
我解析过java.util.Collections类的底层，此类中的很多方法都采用了这种形式来声明参数。

具体说明见下述示例。（为了便于排版，这可能会影响大家阅读，见谅。。。）

5.4 上下边界的说明示例

5.4.1 示例1

在这里插入图片描述
看到这个方法，我有了一个大胆的猜测：

这种格式单个使用，只能表示类型实参可为任意类型，没有限制作用。至于到底与哪个没有发挥作用、亦或者都有作用，无从得知，但肯定有一个多余是真的。
但若是两个一起使用（如上图），就可以实现 将形参类型限制在同一体系 \color{green}{将形参类型限制在同一体系} 将形参类型限制在同一体系的作用。（“同一体系”指存在继承关系）

就如图中方法copy()，其作用是将所有元素从一个列表复制到另一个列表。即为“复制”，那么，dest与src必须要在同一体系才能实现复制。

大家看我在那篇文章中写的示例：
关于对Java泛型的理解与简述（读后简结）_第2张图片

这是java.lang.Integer类的API截图：
关于对Java泛型的理解与简述（读后简结）_第3张图片

可见，Number类是Integer类的父类，
回说copy()，第一个参数dest对应的类型是List，第2个参数src对应的类型是List。
那么，此时的类型实参就是Integer，这便印证了我的猜测。
当然，若 Integer 类是间接实现于 Number 接口（假设中间的继承类是xx），则的类型实参就是xx。

5.4.2 示例2

在这里插入图片描述
此方法的作用是使用指定元素替换指定列表中的所有元素。即为“替换”，则指定元素的类型与列表中元素的类型也必须在同一体系。与第1个例子同理。
回说fill()，表示的类型实参是的类型实参的父类或超类，而第2个形参的类型是T，这样就实现了限制功能。

大家看我在那篇文章中写的示例：
在这里插入图片描述
先看第2个实参10，其类型是Integer，则的类型实参为Integer。而第1个实参类型为List，则此时接收的类型为Object。
Integer 类继承于 Object 类，也印证了我的猜测。

5.4.3 示例3

在这里插入图片描述
此方法与前2个方法都不同，其只有一个形参，可见我在示例1中的猜想有点纰漏。

最终结论 ： \color{red}最终结论{}： 最终结论：

这种格式单个使用，只能表示类型实参可为任意类型，没有限制作用。而之所以没有限制作用，是因为 没有定义具体的上下边界 \color{blue}{没有定义具体的上下边界} 没有定义具体的上下边界。

原因如下。

5.4.4 示例补充说明

1、示例1。
与同时存在，这样就限制了2个List类型形参的类型实参都必须属于同一体系。

2、示例2。
与同时存在，这样就将的类型实参限制为必须是的类型实参的父类或超类。

3、示例3。
与同时存在。
分析： \color{blue}{分析：} 分析：

  1. 首先，的类型实参被限制为只能是 Object 类或 Comparable 接口的子类，
  2. 其中的，将的类型实参限制为必须是的类型实参的父类或超类；
  3. 然后，是将的类型实参限制为必须是的类型实参的子孙类。

因此，这三项结合在一起，产生的效果是：

max()可接收类型为Collection、类型实参为 Object 类或 Comparable 接口的子类的实参，且 Comparable 接口的类型实参必须是此类型实参的父类或超类。

大家看我在那篇文章中写的示例：
在这里插入图片描述
max()接收的类型是List，List接口继承于Collection接口，则的类型实参是Integer。
而 Integer 类既继承于 Object 类，也实现于 Comparable 接口。因而，编译通过。

这是java.lang.Comparable接口的API截图：
关于对Java泛型的理解与简述（读后简结）_第4张图片

5.5 上下边界注意事项

1、 可以表示继承或实现于xx类或接口，因为的类型实参也可以是类或接口；

2、 只有可以定义上下边界，即：；而全局泛型和局部泛型都只能定义上边界，即：；

3、 一种定义上边界的特殊格式。

class Generic<T extends Object & Collection> {}

或：

public <T extends Object & Collection> void handler(T t) {}

使用&符号将2个父类或超类连接起来，表示定义2个上边界。
注意： \color{red}{注意：} 注意：&前可以是类或接口，而&后只能是接口。

6、关于在静态方法中使用泛型

静态方法无法使用全局泛型。因此，若要在静态方法中使用泛型，则必须定义为静态泛型方法。

关于类加载，详述可查阅博文【【java知识点】锦集】的第5项。

因为静态方法加载于类加载的第三过程“初始化”，而全局泛型加载于实例化。

7、一个巨大的错误

7.1 整个事情发展

事情起因： 事情起因： 事情起因：
这是一个泛型方法，业务很简单，可测试时出现了问题。

/**
 * @param origin 数组
 * @param index 索引
 * @return 数组元素
 */
public static <T, U> T at(T[] origin, U index) {
    int temp = index.getClass() == Integer.class? (int) index : 0;
    return origin[temp];
}

测试代码：

int[] origin = {2, 0, 2, 3};
at(origin, 1);// 编译报错

若顺利执行，应返回0，可实际是编译报错，原因是origin的类型不能是int[]。更准确的说，不能是基本数据类型数组。

为何不能是基本数据类型数组？ \color{grey}{为何不能是基本数据类型数组？} 为何不能是基本数据类型数组？
为了研究此问题，做如下测试。

class TestGeneric<T> {
	// 获取指定数组的第1个元素
    public T at(T[] args) {
        return args[0];
    }
}

从此示例可以看出，args不能是基本数据类型数组，即的类型实参不能是基本数据类型，为什么？因为是全局泛型，限制只能是类。

于是，我将此限制也应用于局部泛型。

结论无误，但底层逻辑错了。 \color{red}{结论无误，但底层逻辑错了。} 结论无误，但底层逻辑错了。

泛型也称之为“参数化类型”，类型实参只能是类，而不能是基本数据类型。

换言之，理论如此，根本不需要经过测试进行推论。

为何之前我会认为泛型的类型实参可以是基本数据类型？ 为何之前我会认为泛型的类型实参可以是基本数据类型？ 为何之前我会认为泛型的类型实参可以是基本数据类型？
主要有两个原因。第一，我对泛型的掌握有所欠缺；第二，我的基础功底不够扎实，以致于被误导了。
看这个方法。

<T> void at(T t) {}

请问：t可以是基本数据类型吗？
当然可以。这就是误导之处，于是我认为T[] t的t也可以是基本数据类型数组。

真正的底层逻辑。 \color{red}{真正的底层逻辑。} 真正的底层逻辑。
为什么T t的t可以是基本数据类型？
因为在底层，触发了包装类的“自动装箱”机制。如：at(1)，会在底层自动将的类型实参适配为Integer，即：自动装箱int → Integer。
因此，并不是说类型实参可以是基本数据类型，而是在底层进行了“自动装箱”，将类型实参适配为其包装类。
为什么T[] t的t不可以是基本数据类型数组？
同理，研究其底层，拿上面的测试示例。

int[] origin = {2, 0, 2, 3};
at(origin, 1);// 编译报错

从上文可知： 局部泛型的类型实参由方法调用时实参的类型决定 \color{green}{局部泛型的类型实参由方法调用时实参的类型决定} 局部泛型的类型实参由方法调用时实参的类型决定。
假设t可以是基本数据类型数组（编译通过）。示例中origin的类型是int[]，则的类型实参为int。由于类型实参只能是类，故的类型实参为Integer。
也就是说，在底层会经历int[] → Integer[]。
虽然 int 类型可以经“自动装箱”封装为 Integer 类，但int[]不能转换成Integer[]，此转换不合法。
综上所述，t不可以是基本数据类型数组。

7.2 柳暗花明但又疑云重重

在解析 Java-API 时，我发现T[] t的t可以是基本数据类型数组。需要满足什么条件或有什么规律呢？

大家先看一些示例。
1、

class A<T> {
    public void show(T t) {}
}

// 测试
int a = 2023;
Integer b = 2023;

A<Integer> a1 = new A<>();
a1.show(a);// ------√
a1.show(b);// ------√

// 测试
int[] arr1 = {a};

A<int[]> a2 = new A<>();
a2.show(arr1);// ------√

2、

class A<T> {
    public void show(T[]t) {}
}

// 测试
int[] arr1 = {2023};
Integer[] arr2 = {2023};

A<Integer> a1 = new A<>();
a1.show(arr1);// ---------×
a1.show(arr2);// ---------√

// 测试
int[][] arr11 = {arr1};
Integer[][] arr21 = {arr2};

A<int[]> a2 = new A<>();
a2.show(arr11);// ---------√
a2.show(arr21);// ---------×

A<Integer[]> a3 = new A<>();
a3.show(arr11);// ---------×
a3.show(arr21);// ---------√

3、

public <T> void show(T t) {}

// 测试
int a = 2023;
int[] arr1 = {a};
Integer[] arr2 = {a};
int[][] arr11 = {arr1};
Integer[][] arr21 = {arr2};

show(a);// ------------√
show(arr1);// ---------√
show(arr2);// ---------√
show(arr11);// --------√
show(arr21);// --------√

4、

public <T> void show(T[] t) {}

// 测试
int[] arr1 = {2023};
Integer[] arr2 = {2023};
int[][] arr11 = {arr1};
Integer[][] arr21 = {arr2};

show(arr1);// ---------×
show(arr2);// ---------√
show(arr11);// --------√
show(arr21);// --------√

我自己都迷糊了。。。真是一言难尽，我也不知如何表述。

总结： \color{red}{总结：} 总结：

全局泛型的类型实参可以是类、基本数据类型数组和类数组；局部泛型同样。

8、扩展

大家都熟悉反射，不知道大家有没有注意这个细节：

Class<String> z1 = Integer.class;// 编译报错

为了研究这个问题，我将反编译、反射、类加载、泛型等知识点都考虑其中，却依旧没有答案。不然，我发起了【提问】，向博友们请教。
在大家的回复中，我注意到一个新概念： 泛型擦除 \color{green}{泛型擦除} 泛型擦除。
之前我在解析Java-API 时，遇到过与这个概念类似的描述，只是没注意。关于此概念的理论，在上面【泛型通配符】的阐述中提过，这里就不多赘述，我直接说在此处的应用。

示例中指定了类型实参为String，泛型擦除机制会将String擦除，并转为其上界类型Object。

一个猜测： 一个猜测： 一个猜测：
Integer.class的底层是反编译，与Class类的底层有关，由于此类的底层比较复杂，我暂且未解析，故无法进行说明。
我的猜测：Integer.class的底层是将 Class 类的类型实参适配为Integer。

Class指定类型实参为String，虽然经泛型擦除会转为Object，但依旧是字符串。而Integer.class指定类型实参为Integer，则赋值转换不合法，故编译报错。

留言： \color{purple}{留言：} 留言：虽然这段解析比较合理，但毕竟是我的猜测，没有理论支撑。有不妥之处，欢迎大家在评论区指正！！

9、最后

本文中的例子是为了阐述泛型相关思想、方便大家理解而简单举例的，不一定有实用性。泛型，在java中应用非常广泛，比如：开源。掌握了泛型对阅读源码、使用第三方框架都有很大的助力。关于泛型，大家可以自行测试一下，很多地方就都迎刃而解。

本文完结。

你可能感兴趣的:(java知识点,java泛型)

  • Java【泛型】 SkyrimCitadelValinor Java基础java
    Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
  • Java泛型编程 shymoy java开发语言
    文章目录为什么需要泛型如何实现技术细节泛型数组泛型类型实现接口接收参数小结为什么需要泛型如果为每一种类型都写一个类来适配，会造成code冗长且难读，所以需要写一个同一的抽象的方法来实现，并让编译器自动的传入这些类型。如何实现通常放在类后面的尖括号里publicclassGenertic{}也可以指代多个publicclassGenertic{}这个类中的变量都可以用K和V来表示了泛型不仅可以应用在
  • Java 类型擦除机制详解 项目笔记与工具库 java开发语言
    Java的类型擦除机制（TypeErasure）是Java泛型中一个非常重要的特性。通过类型擦除，Java既实现了泛型功能，又能保持与旧版本的向后兼容性。本文将详细介绍Java类型擦除机制的工作原理、步骤、影响以及相关示例。什么是类型擦除？类型擦除是指在编译时，Java编译器会将泛型类型转换为原始类型（rawtype），并删除或替换与类型参数相关的类型信息。换句话说，在编译后的字节码中，泛型的具体
  • Java泛型中 T 与 T的区别和用法 Java大数据布道者
    T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据，通过返回值T和T的两种方法实现一、T用法TT.png二、T用法T.pnggoldmei.png
  • 给Java新手的一些建议——Java知识点归纳(Java基础部分) 灬佐手边
    写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会，主要是和一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。image.png主要内容为J2SE相关的部分，经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握
  • SpringBoot高并发！java分布式开发面试题 spring面试题 程序员面试后端java
    正文梳理知识点，是快速提升技术的关键前面讲过，快速提升自己的技术硬实力其实是有方法的。大致就是梳理知识点+夯实基础+进阶深入学习+实战，下面我会一点点跟大家剖析，本文干货满满，大家仔细阅读。梳理知识后，夯实基础乃是刚需：深入进阶学习（28个主流Java知识点“一网打尽”）1、并发编程Java并发编程是整个Java开发体系中最难以理解，但也是最重要的知识点之一，一旦掌握你一定在市场上供不应求。Jav
  • Java泛型基础概念 项目笔记与工具库 java开发语言
    Java泛型是JavaSE5引入的一种特性，允许在编写代码时指定类、接口或方法的类型参数。通过泛型，你可以编写更具通用性、类型安全的代码，避免在运行时遇到不必要的类型转换错误。1.泛型的基本语法泛型的基本形式如下：classBox{privateTt;publicvoidset(Tt){this.t=t;}publicTget(){returnt;}}这里，T是一个类型参数，可以被任何类型替代。当
  • JAVA泛型的使用场景与常见问题 项目笔记与工具库 java进阶java开发语言
    泛型（Generics）是编程语言中的一种特性，允许在定义类、接口和方法时使用类型参数，从而提高代码的重用性和类型安全性。本文将详细讲解泛型的使用场景、常见问题，并深入了解类型擦除机制。一、泛型的使用场景1.提高代码的类型安全性示例：在没有泛型的情况下，使用集合需要进行显式类型转换，可能导致运行时错误。Listlist=newArrayList();list.add("Hello");Intege
  • 了解泛型的类型擦除吗？ seven97_top Javajava
    概念Java泛型（generics）是JDK5中引入的一个新特性,泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。优点在编译的时候检查类型安全；使用泛型可以在编译时期进行类型检查，从
  • Java-泛型 ZHOU_VIP MACjava
    Java泛型是一个强大的特性，它允许你在编写代码时使用类型参数来提高代码的复用性和类型安全性。以下是从入门到精通的Java泛型指南，包括基本概念、使用方法以及高级主题。1.泛型的基本概念1.1什么是泛型？泛型是一种在编译时检查类型安全，并且所有的强制转换都是自动和隐式的编程构造。使用泛型可以避免在运行时进行类型转换错误，并且可以使代码更加灵活和易于维护。1.2为什么使用泛型？类型安全：避免运行时出
  • 2022年Android中高级面试框架 Swuagg 简历与面试Android中高级面试内容
    目录Java泛型集合ArrayListLinkedListHashMapLinkedHashMapConcurrentHashMap多线程并发volatile线程反射JVM类加载怎么判断对象是否已死？垃圾回收机制四大引用泛型集合——HashMap、ConcurrentHashMap源码和数据结构多线程反射JVM——类加载、内存模型、内存管理机制、垃圾回收机制Android四大组件和Fragment
  • 10_Java泛型 DustinWangq Java高级编程java泛型
    一、为什么要有泛型1.泛型的设计背景集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayLi
  • 【JAVA】java泛型 详解 CodeCharm——CC JAVA杂项java开发语言
    java泛型详解一、参数化类型（ParameterizedType）：二.泛型类（GenericClass）：三.泛型方法（GenericMethod）：四.通配符类型（WildcardType）：五.类型擦除（TypeErasure）：六.自动装箱和拆箱（AutoboxingandUnboxing）：Java泛型是一种在编写类、接口和方法时使用参数化类型的机制，它提供了更强大的类型安全性、代码重
  • java 泛型----T、？的使用 ok060 java开发语言
    java中T表示泛型。？表示不确定的类型。jdk使用K表示键，V表示值，T表示type类型,E表示enum枚举。这四个符号只是表示泛型名称，可以换成其他字母，但是需要在之前声明。参考文章：java泛型：T与?的使用及区别_javamap?和t用法-CSDN博客示例代码如下：packagejavaCode;importjava.util.HashMap;importjava.util.List;im
  • 详解Java泛型之1——入门泛型必懂的知识点 测试开发Kevin
    我相信，绝大多数初始Java泛型的同学都会感到这个知识点理解起来有些困难，在这里我会对java泛型相关知识点做一个详细的介绍，包括：入门泛型必懂的知识点、通配符、泛型擦除以及泛型应用四个内容。今天我来讲解第一个知识点：入门泛型必懂的知识点。先帮大家扫清泛型基础概念的相关知识点，也欢迎大家持续关注我的后续文章。泛型定义泛型的英文是generics，generic的意思是通用,而翻译成中文，泛应该意为
  • 学习记录(自用) weixin_33962621 java大数据数据库
    Java学习路径及记录，纯粹个人自用，请多指教JavaJava基础常用类常用类8种基础数据类型的包装类自动打包/解包序列化深入理解Java序列化深度解析JAVA序列化异常处理JavaSE基础:异常处理六个例子彻底理解finally语句块JVM原理Java高级特性泛型Java泛型详解细说Java泛型及其应用细说Java泛型及其应用反射注解Java注解完全解析Java网络编程Java多线程编程线程基础
  • 推荐java教程 chip1234
    推荐java学习网站：http://how2j.cn/p/1215全套java学习教程，学习之后发现不错，java知识点全面且系统，框架足够丰富
  • Java泛型：详解使用技巧及举例说明 一休哥助手 javajava开发语言
    Java泛型：详解使用技巧及举例说明1.引言Java泛型是一项强大的编程概念，它允许我们编写通用的代码，在编写代码时不需要预先指定具体的数据类型。泛型的引入解决了在传统的编程中需要频繁进行类型转换的问题，提高了代码的安全性和可读性。泛型的概念泛型是一种参数化类型的概念，它使得类、接口、方法可以在定义时使用未知的类型。通过在声明时使用类型参数，可以在使用时指定具体的类型。例如，List中的就是一个类
  • 深入理解Java泛型：概念、用法与优势 程序吟游 JAVAjava
    泛型是JDK的一个特性，它允许在定义类、接口和方法时使用类型参数。例如泛型类：在定义类时，可以使用类型参数来指定类中某些字段或方法的类型publicclassBox{privateTt;publicvoidset(Tt){this.t=t;}publicTget(){returnt;}}例如通配符类型：这个方法可以接受任何类型的List作为参数，因为?代表任意类型。publicvoidprintL
  • Java面试题2024(Java面试八股文) 思静语 Java面试总结java
    文章目录基础SpringspringMybatis数据库Mysqlredis并发编程网络通信消息队列MQ分布式分布式事务设计模式更新中基础Java基础Java对象的创建集合HashMap详解HashMap实现原理ConcurrentHashMap原理详解反射JAVA反射详解异常Java的异常体系泛型Java泛型详解注解Java注解序列化java序列化有哪些方式Springspringspring事
  • Java学习day29：线程池Pool中创建线程方式（面试必考！） 凌~风 java从0到1学习面试职场和发展java开发语言java-eeintellij-idea
    声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)往期回顾Java学习day28：线程池Pool（知识点非常非常的详解）-CSDN博客Java学习day27：join方法、生产者消费者模式（知识点详解）-CSDN博客Java学习day26：和线程相关的Object类的方法、等待线程和唤
  • Java学习day30：Stream流入门、集合获取流对象、流对象的方法（知识点详解） 凌~风 java从0到1学习javajava-ee开发语言intellij-idea
    声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)往期回顾Java学习day29：线程池Pool中创建线程方式（面试必考！）-CSDN博客Java学习day28：线程池Pool（知识点非常非常的详解）-CSDN博客Java学习day27：join方法、生产者消费者模式（知识点详解）-C
  • Java泛型 kbforever8 java开发语言
    泛型在编译阶段约束操作的数据类型格式泛型只能支持引用数据类型泛型可以在类后面，方法申明上，接口后面定义泛型类的格式：修饰符class类名{}作用：编译阶段指定数据类型，类似于集合的使用泛型方法（定义方法同时定义了泛型的方法）：修饰符方法返回值方法名称（形参列表）{}作用：方法中可以使用泛型接受一切实际类型的参数泛型接口：可以让实现类选择当前功能需要操作的数据类型修饰符interface接口名称{}
  • 【006期】JavaSE面试题（六）：泛型 我可能是个假开发
    开篇介绍大家好，我是Java最全面试题库的提裤姐，今天这篇是面试系列的第六篇，主要总结了JavaSE中泛型相关面试题，在后续，会沿着第一篇开篇的知识线路一直总结下去，做到日更！如果我能做到百日百更，希望你也可以跟着百日百刷，一百天养成一个好习惯。什么是泛型？Java泛型（generics）是JDK5中引⼊的⼀个新特性，允许在定义类和接口的时候使⽤类型参数（typeparameter）。声明的类型参
  • Java 泛型 T，E，K，V，?，傻傻分不清？ 北诺成尘_6bd8
    前言Java泛型（generics）是JDK5中引入的一个新特性,泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。泛型带来的好处在没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的
  • 2019-03-28 昕柒
    1、java泛型的介绍：泛型实在jdk1.5添加的功能,现在应该是到12了，泛型的出现实际上就是为了相对安全。主要是就是解决数据类型相对安全问题，原理就是在声明类的时候通过某个某个标识表示类中的某个属性的类型或者某个方法的返回值及参数类型。则在实例化的时候或者声明类的时候指定所需类型即可泛型的格式：访问权限class类名称{}访问权限泛型类型标识变量名称；访问权限泛型类型标识方法名称（）；访问权限
  • android tcp socket框架_2020年迷茫不知学什么？Android 技能图谱走起 weixin_39630813 androidtcpsocket框架获取androidwebview离线调试工具
    Java基础JavaObject类方法HashMap原理，Hash冲突，并发集合，线程安全集合及实现原理HashMap和HashTable区别HashCode作用，如何重载hashCode方法ArrayList与LinkList区别与联系GC机制Java反射机制，Java代理模式Java泛型Synchronized原理Volatile实现原理方法锁、对象锁、类锁的意义和区别线程同步的方法：Sync
  • 线程的生命周期及其六种状态的转换 Java柚子
    线程的六种状态线程的生命周期主要有以下六种状态：New（新创建）Runnable（可运行）Blocked（被阻塞）Waiting（等待）TimedWaiting（计时等待）Terminated（被终止）在我们程序编码中如果想要确定线程当前的状态，可以通过getState()方法来获取，同时我们需要注意任何线程在任何时刻都只能是处于一种状态。需要更多Java知识点和面试题的朋友可以加q群：11038
  • Java学习day28：线程池Pool（知识点非常非常的详解） 凌~风 java从0到1学习开发语言javaintellij-ideajava-ee线程池
    声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)往期回顾Java学习day27：join方法、生产者消费者模式（知识点详解）-CSDN博客Java学习day26：和线程相关的Object类的方法、等待线程和唤醒线程（知识点详解）-CSDN博客Java学习day25：守护线程、死锁、线
  • 通配符详解 extends super 那时青菜
    在java泛型中，？表示通配符，代表未知类型，表示上边界限定通配符，表示下边界限定通配符。通配符与T的区别T：作用于模板上，用于将数据类型进行参数化，不能用于实例化对象。?：在实例化对象的时候，不确定泛型参数的具体类型时，可以使用通配符进行对象定义。等同于等同于上界通配符？extendsListsList=ArrayList;extends代表Bird和他的子类都适用。可以取出，不可以添加，因为不
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象