一、内部类
内部类是类中的五大成分之一(成员变量、方法、构造器、代码块、内部类);
如果一个类定义在另一个类的内部,这个类就是内部类;
场景:当一个类的内部,包含了一个完整的事物,且这个事物没有必要单独设计时,就可以把这个事物设计成内部类。
内部类分为四种
成员内部类:位于一个类里面成员位置的类
静态内部类:使用static修饰的成员内部类
局部内部类:在方法里面定义的类
匿名内部类[重要]:一种特殊的局部内部类
1、成员内部类
定义在一个类中成员位置的类叫做成员内部类,在内部类中也可以定义成员属性和方法
成员内部类中创建对象的格式:
示例
public class Outer {
// 成员内部类
public class Inner {
// 成员属性和方法
}
}
创建对象:
外部类名.内部类名 对象名 = new 外部类(...).new 内部类(...);
Outer.Inner in = new Outer().new Inner();
成员内部类访问其他成员的特点:
1、成员内部类中可以定义实例成员,静态成员 (注意: 静态成员从JDK16开始支持)
2、成员内部类中的实例方法中,可以直接访问外部类的实例成员,静态成员
3、如果内部类和外部类出现了重名的成员,可以通过(外部类名.this.xxx) 强行访问外部类的成员
2、静态内部类
即为用static修饰的成员内部类
public class Outer{
// 静态内部类
public static class Inner{
}
}
创建对象的格式
外部类名.内部类名 对象名 = new 外部类.内部类(…);
Outer.Inner in = new Outer.Inner();
静态内部类中访问外部类成员的特点:
可以直接访问外部类的静态成员,不可以直接访问外部类的实例成员。
3、局部内部类
局部内部类是定义在方法中、代码块中、构造器等执行体中
格式:
class 外部类名 {
数据类型 变量名;
修饰符 返回值类型 方法名(参数列表) {
// …
class 内部类 {
// 成员变量
// 成员方法
}
}
}
4、匿名内部类
一种特殊的局部内部类,是内部类的简化写法,是一个隐含了名字的内部类。
格式:
new 类名或者接口名() {
重写方法;
};
//举例子:
new Animal(){
@Override
public void cry() {
}
};
tips:从语法上来讲,这个new出来的整体其实是匿名内部类的对象
作用:更方便的创建一个子类对象(简化操作类、接口的代码);
本质:匿名内部类本质就是一个子类,并会立即创建出一个子类对象;
tips:或者是一个接口的实现类,在new的后面必须跟它的父类或者接口
场景: 通常作为一个参数传输给方法。
举个例子,以接口为例:
interface Swim {
public abstract void swimming();
}
public class Demo {
public static void main(String[] args) {
// 使用匿名内部类
new Swim() {
@Override
public void swimming() {
System.out.println("自由泳...");
}
}.swimming();
// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
@Override
public void swimming() {
System.out.println("蛙泳...");
}
};
s2.swimming();
}
}
可以看出,接口Swim定义了一个抽象方法swimming(),匿名内部类实际上是接口的实现类,所以必须重写接口中的抽象方法。
从下往上看,创建了一个对象s2,如果是传统的方法想要调用swimming方法,首先要单独定义并命名一个Swim接口的实现类(假设名字为SwimImpl),然后用多态的写法创建s2对象:Swim s2 = new SwimImpl(); 然后再用s2.swimming() 调用方法。
很麻烦对吧?所以用匿名内部类就可以避免定义实现类,还有起名字等等过程。请看上面给出的代码里,定义匿名内部类时只需在new的后面先写上你想要创建的匿名内部类的父类或接口名,然后打一个大括号,在大括号里直接重写父类或接口中的方法即可。
再往上面看,有一个直接new Swim() 的东西,这里想要说明的是new出来的这一整块东西其实就是匿名内部类的一个对象。用我刚才举的例子中的名字来说,这一块东西便是子类(接口实现类)SwimImpl的对象,所以你可以看到在后面直接 .swimming() 来调用方法,因为他就是一个对象。
二、泛型
定义类、接口、方法时,同时声明的类型变量(如:<E>) ,称为泛型。
tips:把E想象成数学方程中的x就行。
作用:泛型提供了在编译阶段约束所能操作的数据类型,并自动进行检查的能力!这样可以避免强制类型转换,及其可能出现的异常。
本质:把具体的数据类型作为参数传给类型变量
分类:泛型类、泛型接口、泛型方法
1、泛型类
格式:
public class ArrayList<E>{
. . .
}
泛型类在声明时使用类型参数来指定类可以接受的类型,这样在使用类时可以传入具体的类型实参
举例子:
public class Demo {
public static void main(String[] args) {
//1、创建MyList对象
MyList<String> list = new MyList<>();
//2、向MyList中存放数据
list.add("丁真");
System.out.println(list.get(0));
}
}
//自定义一个泛型类, 模仿ArrayList的add和get功能,只能存放10条数据
class MyList<E> {
//1、定义一个长度为10的数组
private Object [] arr = new Object[10];
//2、定一个当前存放元素的索引位置
private int index = 0;
//方法1:添加元素
public void add (E e) {
arr[index] = e;
//索引加+1
index ++ ;
}
//方法2:根据索引查询元素并返回
public E get(int index) {
return (E) arr[index];
}
}
注意:类型变量建议用大写的英文字母,常用的有:E、T、K、V 等
2、泛型接口
泛型接口的定义与泛型类相似,只是在接口声明时使用类型参数来指定接口可以接受的类型。
格式:
public interface A<E>{
. . .
}
3、泛型方法
格式:
public static <T> void test(T t){
}
举例子:
public class Demo {
public static void main(String[] args) {
//需求: 编写一个将两个相同类型的对象放入一个集合的方法
ArrayList<String> list1 = add("hello", "world");
//将两个Teacher放入一个集合
Teacher t1 = new Teacher();
Teacher t2 = new Teacher();
ArrayList<Teacher> list2 = add(t1, t2);
//将两个Student放入一个集合
Student s1 = new Student();
Student s2 = new Student();
ArrayList<Student> list3 = add(s1, s2);
System.out.println(list3.size());
}
//泛型方法
public static <T> ArrayList<T> add(T t1,T t2) {
ArrayList<T> list = new ArrayList<>();
list.add(t1);
list.add(t2);
return list;
}
}
class Teacher {
}
class Student {
}
本例中,泛型方法add()的类型变量为T,返回值是一个T类型的集合ArrayList<T>,参数列表是两个T类型的参数。
对于Teacher和Student两个类所创建的对象,Teacher的对象调用add()泛型方法时,传入的参数的数据类型为Teacher,那么本次调用中,add方法的所有类型变量T都变为Teacher来供其使用,Student同理。
4、通配符上下限
通配符就是 “?” ,可以在“使用泛型”的时候代表一切类型; E T K V 是在定义泛型的时候使用。
通配符上下限:
泛型上限: ? extends Car: ? 能接收的必须是Car或者其子类 。
泛型下限: ? super Car : ? 能接收的必须是Car或者其父类。
5、泛型的擦除问题和注意事项
泛型是工作在编译阶段的,一旦程序编译成class文件,class文件中就不存在泛型了,这就是泛型擦除。
泛型不支持基本数据类型,只能支持对象类型(引用数据类型)。