JavaSE基础部分

1.数据类型

基本数据类型：

数值型：

• 整数类型：byte short int long
• 浮点类型：float double

字符型：char

布尔型：boolean

引用数据类型：

class类

interface接口

数组

switch是否能作用在byte上，是否能作用long上，是否能作用在String上？

在Java5以前，Switch(expr)中，expr只能是byte shrot char int ，从java5开始，java中引入了枚举类型，expr也可以是enum类型，从java7开始，expr还可以是字符串String，但是是长整型long在目前的版本中都是不可以的

2.final关键字

1.final修饰类时，该类是不能被继承的

• 例如：String StringBuffer [线程安全] StringBuilder[线程不安全] 八大包装类

2.final修饰方法时，该方法不能被重写，但是可以被继承，可以被重载

• 例如Object中getClass方法就是使用了final关键字修饰的，比如：当我们希望某个类中的某个方法，不被重写时，就可以使用final关键字修饰的

3.final可以修饰变量，1》如果是基本数据类型的变量，则数值一旦在初始化后就不能被修改了，一般情况下我都会使用static和final来修饰基本数据类型变量，达到常量的效果，2》如果 是引用类型变量，则在对其初始化之后便不能再指向另一个对象，但是是指向的内容是可以被修饰的【例如：一个学生对象是final修饰的，所以它就是不能重新指定另一个学生对象，但是学生对象中有name属性，指，但是学生对象中name属性的值是可以被修改的【前提这个name属性是没有使用final修饰的】】

• 例如：在String类中的value就是使用value修改的private final char value[];
• final修饰变量可以在初始化直接进行赋值，也可以在代码块中赋值，也在构造器中赋值[String类的value属性就是在构造器进行赋值的]，如果这个属性同时也使用static修饰，那么这个属性赋值只能在静态代码中或定义时直接赋值，final在局部代码块修饰变量的话必须可以在声明时直接赋值，也在后面的代码块中赋值【这个可以省略不答】

4.当一个类使用final了关键字修饰，就没有必须又在方法中使用final关键字修饰了

3.final finally finalize区别

• final可以修饰类，变量，方法，修饰类表示该类不能被继承，修饰方法表示该方法不能被重写，修饰变量表示该变量是一个常量不能被重新赋值
• finally一般作用在try-catch代码块中，在处理异常处理的时候，通常我们将一定要执行的代码放到finally代码块中，表示不管是否出现异常，该代码都会被执行，一般用来关闭资源
• finalize是一个方法，属于Object类中一个方法，而Object类是所有类的基类，该方法一般由垃圾回收器来调用，当我们调用system.ge()方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收最后判断

4.this关键字

this关键字代表是该类对象的引用，就是指向该对象本身，this是每个对象都有的并且是隐藏的【谁调用代表谁】

使用this注意事项和细节（必须掌握，记住）

1. this关键字可以用来访问本类的属性，方法，构造器
2. this用于区分当前类的属性（全局变量）和局部变量
3. 访问成员方法的语法：this.方法名(参数列表)
4. 访问构造器语法：this(参数列表);注意是只能在构造器中使用，并且要放在构造器的第一条语句，不能在普通方法中使用(注意是在构造器中使用必须放在第一条语句，)
5. this不能在类定义的外部使用，只能在类定义的方法中使用（意思就是只能在本类中使用）

5.Super关键字

super关键字代表是父类引用 ，用于访问父类的属性，方法，构造器

基本语法 记住

1.访问父类的属性，但不能访问父类的private属性 super.属性名;

2.访问父类的方法，不能访问父类的private方法 super.方法名(参数列表);

3.访问父类的构造器 super(参数列表); 只能放在构造器的第一语句，只能出现一句！

super关键字细节（记住）

1.调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）

2.当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super，this直接访问是一样的效果

3.super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则。

A->B->C->...->Object，当然也需要遵守访问权限的相关规则

super和this比区别记下

6.异常处理

• getMessage()返回异常发生时详细信息
• toString()返回异常发生时简要描述
• getLocalizedMessage()返回异常对象本地化信息

1》 请介绍Java异常接口

参考答案：

Throwable是异常的顶层父类，代表所有的非正常情况。它有两个直接子类，分别是Error Exception

Error是错误，一般是指系统崩溃，如：StackOverflowError【栈溢出】和内存不足OOM（out of memory）,Error是严重错误，程序会崩溃，并且不能使用try-catch块来捕获Error对象，也不需要使用throws子句声明该方法可能抛出Error及其任何子类

Exception是异常，它被分为两类，分别是checked异常【编译时异常】和Runtime异常【运行时异常】，所有的RuntimeException类及其子类的实例被称为Runtime异常，不是RuntimeException类及其子类的异常实例则被称为checked异常【编译时异常】，在java中编译时异常，是必须处理的，否则无法通过编译。而Runtime异常则更加灵活，Runtime异常无须显式声明抛出或使用try-catch来捕获

2》Java异常处理机制

关于异常处理：在Java中有两种方式：方式一是：try-catch-finally 方式二是：throws抛出

在Java中，处理异常的语句由try-catch-finally三部组分组成，其中，try块用于处理业务的，catch块用于捕获并处理异常的，而finally是用于回收资源，并且不管是否发生异常finally块一定被执行

使用throws抛出异常，当程序出现错误时，系统自动抛出异常。一般在java中判断某项错误的条件成立时，可以使用throw关键字向外抛出异常，让调用者来处理该异常，可以一直向上抛出异常让JVM处理【JVM处理方式一般只是打印异常信息】，使用方式是：如果当前方法不知道该如何处理这个异常时就可以将异常抛出，让调用者来处理

3》finally是无条件执行的吗？

不管在try中的代码是否现出异常，也不管哪个catch块被执行，甚至在try块或catch块中执行了finally块总会被执行

注意事项：

如果在try或catch块中使用System.exit()方法，来退出java虚拟机，则finally块将不会被执行，我们一般不会退出java虚拟机，因为我们想要程序一直正常的执行下去

4》在finally中return会发生什么？

参考答案

在通常情况下，不要在finally块中使用return、throw等导致方法终止的语句，一旦在finally块中使用了return、throw语句，将会导致try块、catch块中的return、throw语句失效。

详细解析

当Java程序执行try块、catch块时遇到了return或throw语句，这两个语句都会导致该方法立即结束，但是系统执行这两个语句并不会结束该方法，而是去寻找该异常处理流程中是否包含finally块，如果没有finally块，程序立即执行return或throw语句，方法终止；如果有finally块，系统立即开始执行finally块。只有当finally块执行完成后，系统才会再次跳回来执行try块、catch块里的return或throw语句；如果finally块里也使用了return或throw等导致方法终止的语句，finally块已经终止了方法，系统将不会跳回去执行try块、catch块里的任何代码。

5》常见的运行时异常

1. NullPointerException：空指针异常
2. ArithmeicException：数学运算异常
3. ArrayIndexOutOfBoundsException：数组下标越界异常
4. ClassCastException：类型转换异常
5. NumberFormatException：数字格式不正确异常

6》编译异常

介绍：编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译

常见的编译异常：

SQLException：操作数据库时，查询表可能发生异常

IOException：操作文件时，发生的异常

FileNotFoundException：当操作一个不存在的文件时，发生异常

ClassNotFoundException：加载类，而该类不存在时，异常

EOFException：操作文件，到文件未尾，发生异常

ILLegaIArguementException：参数异常

7.包装类

1》为什么有包装类？

在Java语言面向对象语言，其设计理念是一切皆对象，但是8种基本数据类型却出现了例外，它们不具备对象的特性，所以Java每一个基本数据类型都定义了一个对应的引用类型，就是包装类

2》包装类和基本数据的转换

演示：包装类和基本数据类型的相互转换，这里以int 和 Integer演示：

1. jdk5前的手动装箱和拆箱方式，**装箱：**基本类型 --》包装类型，反之，拆箱
2. jdk5以后（包含jdk5）的自动装箱和拆箱方式
3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf()
4. 自动拆箱底层调用的是intValue方法，比如对象名.intValue()
5. 其它的包装类用法类似

valueOf源码：
public static Integer valueOf(int i) {
	//low：范围是：-128
	//high：范围是：127
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
1
2
3
4
5
6
7
8

题目：

示例1：引用数据类型
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1==i2);//false

示例2：引用数据类型
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3==i4);//false

示例3：引用数据类型：底层调用了 Integer.valueOf();
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5==i6);//true

示例4：引用数据类型
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7==i8);//false

示例5：引用数据类型
Integer i9 = 127;
Integer i10 = new Integer(127);
System.out.println(i9==i10);//false

示例6：一个基本数据类型一个引用数据类型 == 号比较就是值
Integer i11 = 127;
int i12 = 127;
System.out.ptintln(i11==i12);//true

示例7：一个基本数据类型一个引用数据类型 == 号比较就是值
Integer i13 = 128;
int i14 = 128;
System.out.println(i13==14);//true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

只要是基本数据类型，"=="号判断是值是否相等

只要是引用数据类型，"=="号判断是地址值是否相等

如果一个是基本数据类型，另一个是引用数据类型，则判断还是值是否相等

8.String

1. String对象用于保存字符串，也就是一组字符序列
2. String是一个final类，代表不可变的字符序列
3. 字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的
4. 字符串的字符使用unicode字符编码，一个字符【不区分字母还是汉字】占两个字节
5. String类中有一个非常重要的属性是private final char value[];的value指向的地址是不可以改变的 ，而的存在的单个字符是可以改变的
6. String类中的value值是存在常量池中地址的，就是说value值是用于维护常量池的地址，是不能改变的，改变的只能是常量池的内容，如用new的方式创建对象【才有用value属性维护常量池的地址】

创建String对象的两种方式

方式一：直接赋值 String s = "hsp";

方式二：调用构造器String s = new String("hsp");

两种创建String对象的区别

1.方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有重新创建，然后指向。s(对象引用名)最终指向的是常量池的空间地址

2.方式二：先在堆中创建空间，里面维护了一个value属性值【是用于存在常量的空间地址的】,指向常量池的hsp空间。如果常量池没有hsp，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

重要规则：
String c = “ab”+“cd”;常量相加，看的是常量池
String c = a + b;变量相加，是在堆中【一个变量一个常量相加，也是堆中】

题1：

String  a = "hello" + "abc";
创建了几个对象？只有1对象。
因为是: String a = "hello" + "abc";//底层优化成 String a = "helloabc";

分析是：
1.底层编译器做一个优化，判断创建的常量池对象，是否有引用指向
2.String a = "hello"+"abc"; => String a = "helloabc";
1
2
3
4
5
6
7

题2

String  a = "hello";//创建了对象a
String  b = "abc";//创建了b对象
String c = a + b;//创建了几个对象？画出内存图？
关键就是分析String  c = a + b;到底是如何执行的
一共有3对象，如图。

总结：底层是:1.StringBuilder sb = new StringBuilder();
2.sb.append(a);
3.sb.append(b);
4.sb是在堆中，并且append是在原来字符串的基础上追加的
5.再调用StringBuilder类中的toString方法
    【所以指向的地址是指向堆中的，堆有一个value维护着常量池的属性】

重要规则：
String c = "ab"+"cd";常量相加，看的是常量池
String c = a + b;变量相加，是在堆中【一个变量一个常量相加，也是堆中】
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

String常用方法

equals

equalslgnoreCase

length

indexOf

lastIndexOf

substring

trim

charAt：获取某个索引处字符，注意是不能使用str[index]的方式，必须使用charAt获取单个字符

toUpperCase

toLowerCase

replace：替换

split：分割

concat：拼接字符串

compareTo：比较两个字符串

toCharArray：转换字符数组

format：格式字符串

9.StringBuffer和StringBuilder

StringBuffer和StringBuilder的区别：

StringBuffer和StringBuilder都代表可变的字符串对象，它们共同的父类是AbstractStringBuilder，并且两个类构造器和方法也是相同的，只是StringBuffer是线程安全的，而StringBuilder是线程不安全的，效率更高

StringBuffer和StringBuilder是可变的字符串对象，因为是：在父类中 AbstractStringBuffer有属性 char[] value，不是final 该 value 数组存放在字符串内容，引出存在在堆中的

StringBuffer和StringBuilder常用方法：

append

delete

replace

indexOf

insert

length

1》使用字符串时，new 和""推荐使用哪种方式？

先看hello和new String("hello")的区别：

• 当java直接使用hello字符串直接量时，jvm将使用常量池管理这个字符串
• 当使用new String("hello")时，jvm先使用常量池来管理hello直接量，再调用String类的构造器创建一个新的String对象，新创建的String对象保存在堆内存中

显然，采用new的方式会多创建一个对象，会占用更多的内存，所以一般建议使用直接量方式创建字符串

2》 String 和 StringBuffer 和 StringBuilder

1.StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样的

2.String：是不可变字符序列，效率低，但是复用率高

3.StringBuffer：可变字符序列，效率较高【增删】，线程安全，看源码

4.StringBuilder：可变字符序列，效率最高，线程不安全

5.String使用注意说明

• String s = "a";//创建了一个字符串
• s += "b";//实际上原来的a字符串已经丢弃了，现在又产生了一个字符串s+b【也就是"ab"】。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能 ==》结论：如果我们对String做大量修改，不要使用String

3》 String 和 StringBuffer 和 StringBuilder的选择

1. 如果字符串存在大量的修改操作，一般使用 StringBuffer【多线程情况下】或 StringBuilder【单线程情况下】
2. 如果字符串存在大量的修改，并在单线程的情况下，使用StringBuilder
3. 如果字符串存在大量的修改，并在多线程的情况下，使用StringBuffer
4. 如果我们字符串很少修改，被多个对象引用，使用String，比如配置文件等

String StringBuffer StringBuilder区别：

String底层是使用final修饰的char[]代表是不可变的字符序列，只要每次操作String字符串，则每次都会生成新的对象，消耗内存

StringBuffer和StringBuilder都代表可变的字符串对象，它们共同的父类是AbstractStringBuilder，并且两个类构造器和方法也是相同的，只是StringBuffer是线程安全的，而StringBuilder是线程不安全的，效率更高

从效率上：StringBuilder大于StringBuffer大于String

10.Math工具类

ceil
floor
round
sqrt
random

11.Arrays类

Arrays类常见方法案例

Arrays里面包含了一系列静态方法，用于管理或操作数组【比如排序和搜索】

1.toString 返回数组的字符串形式
	Arrays.toString(arr);

2.sort 排序【自然排序和定制排序】[重点]

3.binarySearch 通过二分搜索法进行查找，要求必须排好序
int index = Arrays.binarySearch(arr,3);

4.copyOf 数组元素的复制
Integer newArr = Arrays.copyOf(arr,arr.length);

5.fill数组元素的填充
Integer[] num = new Integer[]{9,6,3};
Arrays.fill(num,8);//将数组num中的所有元素都替换成8

6.equals 比较两个数组元素内容是否完全一致
boolean equals = Arrays.equals(arr,arr2);//如果数组arr和arr2完全一样返回true，否则返回false

7.asList 将一组值，转换成List集合
List<Integer> asList = Arrays.asList(2,3,43,5,6,78,168);
System.out.println("asList="+asList);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

12.System类

System类常见方法和案例

1.exit: 退出当前程序

2.arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组

int[] scr = {1,2,3};

int[] dest = new int[3];

System.arraycopy(src,0,dest,0,3);

3.currentTimeMillens ：返回当前时间距离1970-1-1的毫秒数

4.gc：运行垃圾回收机制System.gc();

JavaSE补充部分

1.构造器

1. 构造器必须顺序与类名字相同，并且不能有返回值（返回值也不能为void）
2. 每个类可以有多个构造方法，形成构造器的重载，当我们没有编写构造器系统默认会提供一个无参构造器
3. 构造器的作用是完成对成员变量的初始化
4. 构造器总是随着new操作被系统调用，并且对于一个对象而言，只会被调用一次，所以说构造器是系统调用的
5. 构造器不能被继承，所以倒致构造器不能被重写
6. 子类可以通过super关键字来显式调用父类构造器，完成对父类的初始化，默认情况下调用是父类无参构造器，当父类没有无参构造器时，子类必须使用super关键字指定调用父类那个构造器完成父类初始化

2.多态的实现机制

多态就是代码重用的一种机制，表示当同一个对象操作在不同的对象的时候，会产生不同的结果

1)重载

重载是指同一个对象中有多个同名的方法时，但是这些方法参数不同，在通过不同的参数调用不同的方法，就是可以体现方法的多态性

2)重写

子类可以重写父类的方法，可以看出同样的方法会在父类与子类中有着不同的表现形式，比如：父类的引用可以指向子类实例对象，同时接口引用也可以指向子类实例对象，在程序运行时运行期才确定调用是哪个方法【这种该用方法的方式就是动态绑定机制】，就是可以体现重写实现多态

3.重载(Overload)和重写(Override)

重载:

• 方法名必须相同
• 形参列表必须不同，可以是形参类型不同，个数不同，顺序不同
• 与返回值无关

重写：

• 1.子类的方法的参数和方法名必须要和父类方法的参数，方法名完全一样
• 2.子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
• 比如：父类返回是Object，子类方法可以返回类型是String
• 3.子类方法不能缩小父类方法的访问权限，但是可以相同或扩大

方法重载overLoad和方法重写override

3.abstract抽象和interface接口

相同点：

• 抽象类和接口都不能被实例化
• 都可以包含抽象方法
• 都生成.Class文件

抽象类：

• 抽象类不一定要包含有abstract方法，也就是说，抽象类可以没有abstract方法，并且抽象方法可以有构造器

• 一旦类中包含有abstract方法，则这个类必须声明成abstract

• abstract只能修饰类和方法，不能修饰属性

• 抽象类可以有任意成员【因为抽象类本质还是类，只是多了抽象方法】

• 抽象方法不能有方法体

• 如果一个类继承了抽象类，要么将所有抽象方法都实现，要么将自己声明为abstract类

• 抽象类是单继承关系

接口：

• 在jdk7前接口里的所有方法都没有方法体，即都是抽象方法，并且变量必须是public static final修饰的，方法都是public abstract修饰也是默认的
• 在jdk8以后可以有静态方法，默认方法default修饰的，也就是说接口中可以有方法具体实现
• 注意：接口不能成员属性，只有常量，由于jdb8.0后有默认方法，但是可以在默认方法中定义局部变量
• 接口是多继承关系

4.hashCode和equals及==关系

hashCode用于获取哈希码（散列码），equals是用于比较两个对象是否相等，

• 如果两个对象相等，则它们必须有相同的哈尔码
• 如果两个对象相同的哈希码，则它们未必相等

==运算符

• 如果比较是基本数据类型，是比较两个数值是否相等
• 如果比较是引用数据类型，比较是两个对象内存地址是否相等，判断它们是否是同一个对象

equals方法

• 没有重写时，默认是Object中的equals方法是以==来实现的，比较两个对象内存地址是否相同，往往我们都进行重写，用于判断两个对象的内容是否相同，如果相同则认为对象相等，否则不相等

为什么equals方法和hashCode方法一起重写？

原因是对于hashCode相同对象，才会进一步比较是否equals来判断他们是否相等，这是实现快速查找的关键

5.浅拷贝和深拷贝

步骤克隆方法的步骤：

第一步：实现Cloneable接口

第二步：重写clone方法

浅拷贝：

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象，就是说：浅拷贝仅仅复制了所有考虑的对象，而不是复制它所引用的对象

深拷贝：

被复制对象的所有变量都含有与原来的对象相同的值，而那些引用其他对象的变量将指向被复制边的新对象，而不再是原有的那些被引用 的对象，就是说：深拷贝把要复制的对象所引用的对象都复制了一遍

6.面向对象特征有哪些？

抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的 细节是什么。

继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类 被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让 变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要 手段。

封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问 只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写 一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西， 只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别， 明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是 封装得足够好的，因为几个按键就搞定了所有的事情）。

多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。 简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分 为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的 服务，那么运行时的多态性可以解释为：当 A 系统访问 B 系统提供的服务时，B 系统有多种提供服务的方式，但一切对 A 系统来说都是透明的（就像电动剃须 刀是 A 系统，它的供电系统是 B 系统，B 系统可以使用电池供电或者用交流电， 甚至还有可能是太阳能，A 系统只会通过 B 类对象调用供电的方法，但并不知道 供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载 （overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override） 实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的 东西，要实现多态需要做两件事：1). 方法重写（子类继承父类并重写父类中已 有的或抽象的方法）；2). 对象造型（用父类型引用引用子类型对象，这样同样 的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为。

7.数组有没有 length()方法？String 有没有 length()方法？

答： 数组没有 length()方法，有 length 的属性。String 有 length()方法。JavaScript 中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。

泛型介绍【都是引用数据类型】

1.泛型又称为参数化类型，是jdk5出现的新特性，解决数据类型的安全性问题

2.在类声明或实例化时只要指定好需要的具体的类型即可

3.java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时，代码更加简洁，健壮

4.泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回国值的类型，或者是参数类型【重要点】

泛型是作用范围是：

1.标识类中某个属性

2.某个方法返回值类型

3.参数类型

特别注意是：E类型在编译时就已经确定了，才能起到检查数据类型的作用

package collection_.collectionP.generic_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Generic03 {
    public static void main(String[] args) {
//       注意是： E 此类型是在编译期间就确定了，所以才能起到检查数据安全性
        Person<Integer> integerPerson = new Person<>(100);
        integerPerson.show();
        /**
         * 加入泛型代码相当于下面
         * class Person {// E表示是标识某个属性的类型，即在编译期间就确定了，所以才能起到检查数据安全性
         *
         *     Integer  e;// E 此类型是在编译期间就确定了，所以才能起到检查数据安全性
         *
         *     public Person(Integer e){ // 泛型可以作为一个参数
         *         this.e = e;
         *     }
         *
         *     public Integer f(){
         *         return e;// 泛型可以作为一个返回值类型
         *     }
         *
         *     public void show() {
         *         System.out.println(e.getClass());//查看e运行类型
         *     }
         * }
         */
    }
}

/**
 * 泛型的作用是：可以在类声明时通过一个标识表示某个属性的类型，
 * 或者是某个方法返回值的类型，或者是参数类型
 * @param 
 */
class Person<E> {// E表示是标识某个属性的类型，即在编译期间就确定了，所以才能起到检查数据安全性

    E  e;// E 此类型是在编译期间就确定了，所以才能起到检查数据安全性

    public Person(E e){ // 泛型可以作为一个参数
        this.e = e;
    }

    public E f(){
        return e;// 泛型可以作为一个返回值类型
    }

    public void show() {
        System.out.println(e.getClass());//查看e运行类型
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

泛型的好处：

1. 编译时，检查添加元素的类型，提高了数据安全性
2. 减少类型转换的操作，提高效率

面试回答：

1. 泛型是jdk5出现的新特性，解决向下强转的操作，达到解决数据类型的安全性问题
2. 在类声明或实例化时只要指定好需要的具体类型即可，并且泛型都是引用数据类型的
3. 泛型可以保证在编译就是数据类型，达到检查数据类型的作用
4. 如果某个类或方法或参数需要指定泛型，当我们没有指定泛型时默认就是Object类型
5. 并且在给泛型指定具体类型后，可以传入该类型或子类类型
6. 泛型使用形式可以使用菱形泛型形式
7. 泛型不支持继承

自定义泛型类

基本语法：

class  类名<T,R,...>{// 表示可以有多个泛型
	成员
}
1
2
3

注意细节：

1.普通成员可以使用泛型【属性，方法，返回值类型】

2.使用泛型的数组，不能初始化【就是不能直接new，因为不能确定数据类型，无法分配空间，可以声明不能new】

3.静态方法和静态属性中不能使用类的泛型【静态方法和静态属性是随着类加载而加载的】

4.泛型类的类型，是在创建对象时确定的【因为创建对象时，需要指定确定类型】

5.如果在创建对象时，没有指定类型，默认是Object

自定义泛型接口

基本语法：

interface 接口<T,R,...>{
	成员
}
1
2
3

注意细节：

1.接口中，静态成员【静态成员方法和静态成员属性，但是接口中的属性都是静态的所以属性不能使用泛型】不能使用泛型【和泛型类规定一样】

2.泛型接口的类型，在继承接口或实现接口时确定

3.没有指定类型，默认为Object

必须理解下面代码：

package collection_.collectionP.generic_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Generic05 {
    public static void main(String[] args) {

    }
}

interface IUsb<T,R> {
    //普通成员方法中，可以使用泛型
//    T num ; 错误的，因为在接口中的属性不能使用泛型

    // 普通方法中使用泛型
    T getT();

    default R method(){//默认方法使用泛型
        return null;
    }
}

// 泛型接口的类型，在继承接口或实现接口时确定
// 在继承接口时，确定泛型
// String会自己替换T Integer会自己替换R
interface myInt extends IUsb<String,Integer>{}
class myClass implements myInt{
    @Override
    public String getT() {
        return null;
    }
}
// 实现接口类指定泛型
class A implements IUsb<String ,Integer>{
    @Override
    public String getT() {
        return null;
    }
}

// 如果没有指定泛型默认是Object
class B implements IUsb{
    @Override
    public Object getT() {
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

自定义泛型方法

在调用泛型方法时，传入的参数，编译器就可以确定类型

基本语法：

修饰符<T,R...>返回类型 方法名(参数列表){}
1

注意细节：

1.泛型方法中，可以定义在普通类中，也可以定义在泛型类中

2.当泛型方法被调用时，类型会确定

3.一定要理解下面的细节

如果在泛型类定义了泛型方法，一般泛型类的泛型标识符是和泛型方法的泛型标识符是不一样的【也可以一样】

一般在泛型方法中使用的参数要和泛型方法标识一致

public void eat(T t){}   修饰符后没有泛型占位符<T,R>，说明eat方法不是泛型方法，只是使用了泛型
1

非常注意是：一般泛型方法要传入参数，而传入的参数一般是泛型方法的标识 ，如果是在泛型类中定义的泛型方法也可以传入泛型类的标识【但是一般会的都是泛型方法的标识 】

一定要理解下面的代码

package collection_.collectionP.generic_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class CustomMethodGeneric {
    public static void main(String[] args) {

    }
}
// 泛型方法可以定义在普通类中，也可以定义在泛型类中
class myGeneric {
    // 定义泛型方法【定义在普通类中】
    public <T,R> void fi(T t,R r){}//一般泛型方法的泛型和传入的参数的泛型一致
    // 【就是 和 fi(T t,R r)】
}

// 在泛型类中定义泛型方法
class MG<T,R>{

    //定义泛型方法
    public <K,V> void getKV(K k,V v){//一般泛型方法的标识和泛型类的标识是不一致的
        // 一般使用的泛型参数就泛型方法标识 ，也可以使用泛型类的标识
    }
    public <K,V> void getKV2(T t,V v){//一般泛型方法的标识和泛型类的标识是不一致的
        // 一般使用的泛型参数就泛型方法标识 ，也可以使用泛型类的标识
    }

    // 注意下面的方法不是泛型方法，只是使用了泛型
    public void get(T t){}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

package com.hspedu.customgeneric;

import java.util.ArrayList;

/**
 * 泛型方法的使用
 */
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型

        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1.  就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型类
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法

    }
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

泛型的继承和通配符说明【必须理解重点】

1.泛型不具备继承性

List