内部类
定义:内部类就是定义在一个类里面的类,里面的类可以理解成==“寄生”,外部类可以理解成“宿主”==。
使用场景、作用
- 当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只能为外部事物提供服务,那么整个内部的完整结构可以选择内部类来设计(汽车&发动机)
- 内部类通常可以方便地访问外部类的成员,包括私有成员
- 内部类提供了更好的封装性,内部类本身就可以用private、protected等修饰,封装性可以得到更多控制(外部类只能用public修饰)
内部类的分类
- 静态内部类(了解)
- 成员内部类(非静态内部类,了解)
- 局部内部类(了解)
- 匿名内部类(重点!!!)
静态内部类
- 有static修饰,属于外部类本身(相当于外部类的成员)
- 它的特点和使用与普通类完全一样,类有的成分它都有,只是位置在别人里面而已
注意事项
- 静态内部类里可以访问外部类的静态成员
- 不能直接访问外部类的实例成员,只能通过外部类对象来访问
- 静态内部类创建对象的方式:外部类.内部类 对象名 = new 外部类.内部构造器
例如下面的例子:外部类Outer、内部类Inner
package innerclass;
/**
* 静态内部类
*/
public class Outer {
public static int num = 100;
private String hobby;
public static class inner{//可以用private、protected等修饰
private String name;
private int age;
private String schoolName;
public void show(){
System.out.println(num);//可以访问外部类的静态成员
// System.out.println(hobby);//不能直接访问外部类的实例成员,只能通过外部类对象来访问
}
public inner() {
}
public inner(String name, int age, String schoolName) {
this.name = name;
this.age = age;
this.schoolName = schoolName;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
}
}
package innerclass;
/**
* 静态内部类
*/
public class TestMain {
public static void main(String[] args) {
Outer.inner in = new Outer.inner();//对象创建方式
in.setName("小敏");
System.out.println(in.getName());
}
}
成员内部类
- 无static修饰,属于外部类的对象
- JDK16之前,成员内部类中不能定义静态成员,从16开始可以定义了
注意事项
- 成员内部类的实例方法可以直接访问外部类的变量,因为必须有外部类对象,才能有内部类对象
- 成员内部类属于外部类对象
- 在成员内部类中访问外部类的同名成员变量时,外部类名.this.变量名
- 成员内部类对象创建方式:外部类.成员内部类 对象名称 = new 外部构造器.new 内部构造器;
Outer.Inner inner = new Outer().new Inner();
代码举例:外部类Outer、成员内部类Inner
package innerclass1;
/**
* 成员内部类
*/
public class Outer {
private String kind;//内部类的实例方法可以直接访问,因为必须有外部类对象,才能有内部类对象
public static int age = 100;//内部类可以直接访问
public class Inner{//属于外部类对象
private String name;
private int age;
// public static int number;//16开始支持
public void show(){
System.out.println(kind);
System.out.println(this.age);
System.out.println(Outer.this.age);//在成员内部类中访问外部类对象,外部类名.this.变量名
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
}
package innerclass1;
public class Test {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();//创建对象方式,寄生与外部类对象
inner.setName("老六");
System.out.println(inner.getName());
}
}
局部内部类
基本用不到,这里不做介绍
匿名内部类
-
本质上是一个没有名字的局部内部类,定义在方法中、代码块中等等
-
作用:方便创建子类对象,最终目的是为了简化代码编写
-
格式:
new 类/抽象类名/接口名(){
重写方法;
} -
特点:
- 匿名内部类是一个没有名字的内部类
- 匿名内部类写出来就会产生一个匿名内部类的对象
- 匿名内部类的对象类型相当于是当前new的那个类型的子类类型
-
开发中不是我们主动去定义匿名内部类的,而是别人需要我们写或者我们可以写的时候才使用。匿名内部类的代码可以实现代码进一步的简化
场景举例
如今有一个父类Animal类,每个动物跑的特点不一样,即run方法在子类中表现出不一样的特征
现在我想创建一个Tiger类对象(当然它继承Animal),然后执行一下Tiger的run方法
一般思路:创建一Tiger类继承Animal,重写run方法,再Animal animal = new Tiger();
多态创建对象来调用run方法
public class Test {
public static void main(String[] args) {
Animal animal = new Tiger();
animal.run();
}
}
class Tiger extends Animal{
@Override
public void run() {
System.out.println("老虎跑的快");
}
}
abstract class Animal{
public abstract void run();
}
运行结果
老虎跑得快
不爽的地方:自己还要再写一个Tiger类,代码相对多
而使用匿名内部类的写法
public class Test {
public static void main(String[] args) {
Animal animal = new Animal() {//不是Animal对象,它不能创建对象
@Override
public void run() {
System.out.println("老虎跑的快");
}
};
animal.run();
}
}
abstract class Animal{
public abstract void run();
}
跑出来的结果一样
老虎跑得快
这样的代码显然比之前的更简洁
另外
匿名内部类可以作为方法的实际参数进行传输
因为上面用了抽象类举例,现在用一下接口来举例
场景:游泳课上,将老师下水游泳和学生下水游泳视为不同的特征
写法一
/**
* 掌握匿名内部类的使用形式(语法)
*/
public class Test1 {
public static void main(String[] args) {
Swimming person1 = new Swimming() {
@Override
public void swim() {
System.out.println("老师来游泳");
}
};
go(person1);
}
public static void go(Swimming s){//对象回调
System.out.println("开始。。。。");
s.swim();
System.out.println("结束。。。");
}
}
interface Swimming{
void swim();
}
运行结果
开始。。。。
老师来游泳
结束。。。
写法二
/**
* 掌握匿名内部类的使用形式(语法)
*/
public class Test1 {
public static void main(String[] args) {
Swimming person1 = new Swimming() {
@Override
public void swim() {
System.out.println("老师来游泳");
}
};
go(person1);
go(new Swimming() {//匿名内部类可以作为方法的实际参数进行传输
@Override
public void swim() {
System.out.println("学生来游泳");
}
});
}
public static void go(Swimming s){//对象回调
System.out.println("开始。。。。");
s.swim();
System.out.println("结束。。。");
}
}
interface Swimming{
void swim();
}
运行结果
开始。。。。
老师来游泳
结束。。。
开始。。。。
学生来游泳
结束。。。
匿名内部类还可以用lambda表达式继续简化,后面会介绍
待续~~~~