泛型,匿名内部类和集合
1. 泛型
1.1 什么是泛型,为什么引入泛型
目前的项目中,我们的功能代码是可以考虑之后的复用!!!当前代码有且只支持Student类型,如果需要更换数据类型,按照目前的技术,只能重新完成对应数据类型的功能代码。有可能出现各式各样的类型,工作是重复的!!!
这里不单单是对于功能模块的要求封装。同时需要对数据类型进行统一的约束!!!根据用户的要求对应数据类型。
Java的泛型就是来解决对应的问题
格式:
<自定义泛型无意义大写英文字母占位符>
<T> <E> <K> <V>
泛型可以在方法中使用
泛型可以在类中使用
泛型可以在接口中使用
1.2 泛型可以在方法中使用
使用静态方法举例说明泛型在方法中的使用格式
格式:
public static <T> 返回值类型[自定义泛型] 方法名(必须存在一个对应泛型的参数) {
方法体内可以使用自定义泛型
}
使用注意事项:
1. 自定义泛型声明在返回值之前,已保证方法的参数和返回值都可以使用对应的泛型
2. 方法声明的泛型,在方法的参数中必须有一个参数是对应声明的自定义泛型。当前参数是用于约束方法内所有使用到泛型的位置对应的具体数据类型是什么。
package com.qfedu.a_genericity;
import java.util.Arrays;
public class Demo1 {
public static void main(String[] args) {
Integer test = test(123);
String test2 = test("你好");
Demo1 test3 = test(new Demo1());
String[] arr1 = { "烤羊排", "土豆牛肉", "黄焖鸡米饭", "烤羊肉串", "烤韭菜", "烤蒜" };
printArray(arr1);
System.out.println("-----------------------");
Integer[] arr2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
printArray(arr2);
System.out.println("-----------------------");
Demo1[] arr3 = {new Demo1(), new Demo1(), new Demo1(), new Demo1(), new Demo1()};
printArray(arr3);
}
public static <T> T test(T t) {
return t;
}
public static <T> void printArray(T[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
1.3 泛型可以在类中使用 [有一些难点]
格式:
class 类名<自定义泛型无意义大写字母占位符> {
在类内的成员变量和成员方法都可以使用自定义泛型
建议: 成员变量不建议使用自定义泛型
}
使用注意事项:
1. 类声明自定义泛型,需要通过创建对象的方式来约束
TypeA<String> typeA = new TypeA<String>(); Eclipse标准写法
TypeA<String> typeA = new TypeA<>(); IDEA写法
2. 类声明泛型约束之后,在类内的所有成员方法中使用的泛型都是类约束的泛型具体数据类型
3. 如果没有约束类声明泛型,所有使用到泛型的位置都是Object,【不推荐】
4. 类声明的自定义泛型不能用于类内的静态方法【没有对象】
package com.qfedu.a_genericity;
class TypeA<T> {
public T test1(T t) {
return t;
}
public void test2(T t1, T t2) {
System.out.println(t1);
System.out.println(t2);
}
public static <E> E staticMethod(E e) {
return e;
}
}
public class Demo2 {
public static void main(String[] args) {
TypeA<String> typeA = new TypeA<String>();
String test1 = typeA.test1("北京烤鸭");
typeA.test2("卤煮火烧", "豆汁");
TypeA<Demo2> typeA2 = new TypeA<Demo2>();
Demo2 test12 = typeA2.test1(new Demo2());
typeA2.test2(new Demo2(),new Demo2());
TypeA typeA3 = new TypeA();
}
}
1.4 泛型可以在接口中使用
接口
interface 接口名 {
成员变量缺省属性:
public static final 定义时必须初始化,并且初始化之后无法修改
成员方法缺省属性:
public abstract 方法没有方法体
有方法体如何使用:
default修饰默认方法,非强制实现方法
}
泛型在接口中使用格式
interface 接口名<自定义泛型无意义占位符> {
问题: 接口的泛型是否可以用于成员变量中
T t
定义时必须初始化,但是当前泛型的数据类型是不明确的,无法进行初
始化过程。和final有关。
接口中的泛型有且只能用于成员方法!
}
使用注意事项:
1. 接口声明的泛型,有且只能用于类内的成员方法。
问题: default修饰的方法是否可以使用接口声明的自定义泛型
2. 遵从带有自定义泛型的接口的类,一种可以遵从过程中明确告知泛型具体类型,一种是在创建类对象是明确泛型具体数据类型。
3. class TypeA<T> implements A<String>
正确
接口的泛型明确接口中的方法,使用泛型对应的具体数据类型
类声明的泛型用于自定义约束自己类内的方法
4. class TypeA<E> implements A<T>
错误
接口中的泛型没有明确数据类型,也无法通过类创建对象的过程中明确
泛型对应的具体数据类型,无法编译
package com.qfedu.a_genericity;
interface A<T> {
void test(T t);
}
class TypeB<T> implements A<T> {
@Override
public void test(T t) {
System.out.println("自由模式");
}
}
class TypeC<T> implements A<String> {
@Override
public void test(String t) {
System.out.println("规矩模式");
}
}
public class Demo3 {
public static void main(String[] args) {
TypeB<Integer> typeB = new TypeB<Integer>();
typeB.test(10);
TypeB<Character> typeB2 = new TypeB<Character>();
typeB2.test('A');
TypeC typeC = new TypeC();
typeC.test("比较无聊,但是很规矩");
}
}
2. 项目中引出匿名内部类
2.1 目前项目中问题
排序算法需要的条件,要求非常多,但是排序算法的格式,过程,内容是一致的,只有【核心比较方式】不同
插件式比较方式,使用插件的思想完成对于【核心比较方式的替换过程】
游戏机,可以【更换不同的卡片】,完成不同的游戏体验,但是要求卡片【接口是一致的】
从生活角度发现问题,把核心比较方式,规定成一个接口,来满足开发要求。同时使用了多态思想!!!
2.2 尝试使用接口来完成对于核心比较方法的处理
if (sortTemp[index].getAge() < sortTemp[j].getAge()) {
index = j;
}
2.3 使用接口和接口的实现类完成对于选择排序算法的普适性优化过程
2.4 过程中出现的问题
当情况下使用接口约束比较规程,使用实现类作为方法的参数完成比较,的确解决了排序算法多样的情况。
但是也出现了大量内容相似的实现类。对于代码运行而言,类文件太多了!!!
目标:
1. 使用方法来完成比较方式,从而满足复用问题!!!
2. 类名只是因为Java中所有的代码都在类内,所以需要这样的条件。
能不能有一种方式:
只完成方法,类名就不重要了,不需要了。代码符合接口规范!!!
2.5 匿名内部类
Anonymous Inner Type
没有名字的类!!!
package com.qfedu.b_anonymous;
interface A {
void test();
}
class TypeA implements A {
@Override
public void test() {
System.out.println("TypeA遵从A接口,实现A接口中的test方法");
}
}
public class Demo1 {
public static void main(String[] args) {
TypeA typeA = new TypeA();
typeA.test();
A a = new A() {
@Override
public void test() {
System.out.println("匿名内部类的对象赋值给接口的引用");
}
};
a.test();
new A() {
@Override
public void test() {
System.out.println("匿名内部类的匿名对象直接调用方法");
}
}.test();
testInterface(new A() {
@Override
public void test() {
System.out.println("匿名内部类的匿名对象直接作为方法的参数");
}
});
}
public static void testInterface(A a) {
a.test();
}
}
2.6 使用匿名内部类优化选择排序算法
3. 集合
3.1 为什么使用集合
开发中会使用大量相同数据类型的情况。如果使用数组来解决问题
1. 数组能够使用的方法非常少,功能方法需要程序员自己完成。
2. 数据类型单一化,不支持多种情况。
3. 数组容量不可以更改。
集合为解决问题而生:
1. 方法多种多样,基本功能完善
2. 数据类型支持多样化,但是又不失数据类型一致要求
3. 容量可以变,并且不用开发者操心
3.2 集合架构
Java中集合的【总接口】Collection<E>。Java中所有和集合有关的内容,都是Collection<E>接口的子接口或者实现类
interface Collection<E>
--| interface List<E> List接口,有序可重复
----| class ArrayList<E>
【重点】可变长数组结构
原码实现,了解其中的特征,性能....
----| class LinkedList<E>
【重点】双向链表结构
----| class Vector<E>
【远古时代】JDK1.0 线程安全的ArrayList<E>,如果不考虑线程安全问
题,建议使用ArrayList<E>
--| interface Set<E> Set接口,无序不可重复
----| HashSet<E> 底层存储数据的方式是采用哈希表方式
----| TreeSet<E> 底层存储数据的方式一个平衡二叉树方式
3.3 Collection接口下的常用方法
增:
boolean add(E e);
存入元素到当前集合对象中,这里要求的数据类型是E类型,也就是泛型对于
的具体数据类型
boolean addAll(Collection<? extends E> c);
class Dog extends Animal
class Cat extends Animal
class Tiger extends Animal
==> ? extends E 泛型的上限
要求存入的集合c中,存储的元素要么是E类型,要么是E类的子类
删:
void clear();
清空整个集合
boolean remove(Object obj);
删除集合中的指定元素
boolean removeAll(Collection<?> c);
删除两个集合的交集
boolean retainAll(Collection<?> c);
保留两个集合的交集
查:
int size();
返回集合中有效元素个数
boolean isEmpty();
判断当前集合是否为空
boolean contains(Object obj);
判断指定元素在当前集合中是否存在
boolean containsAll(Collection<?> c);
判断集合c是不是当前集合的子集合
package com.qfedu.c_collection;
import java.util.ArrayList;
import java.util.Collection;
public class Demo1 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("82年的拉菲");
c.add("82年的雪碧");
c.add("82年的可乐");
c.add("82年的老雪");
System.out.println(c);
Collection<String> c1 = new ArrayList<String>();
c1.add("百威");
c1.add("福佳白");
c1.add("精酿啤酒");
c1.add("修道院啤酒");
c.addAll(c1);
System.out.println(c);
c.remove("82年的雪碧");
System.out.println(c);
System.out.println("size:" + c.size());
System.out.println(c.isEmpty());
System.out.println(c.contains("百威"));
System.out.println(c.contains("哈尔滨"));
System.out.println(c.containsAll(c1));
c1.add("野格");
System.out.println(c.containsAll(c1));
}
}