Java学习笔记XVII --内部类

1、内部类

1.1 内部类概述
内部类：就是在一个类中定义另一类
举例：一个类名为A的内部中定义了另一类名为B，类B就是内部类
1.2 内部类格式
格式： 范例：
public class 类名{ public class Outer(外部类){
修饰符 class 类名{ public class Inner(内部类){
} }
} }
1.3 内部类特点：
① 内部类可以直接访问外部类的成员，包括私有
② 外部类要访问内部类成员，必须创建对象
//外部类
public class Outer {
// 外部类定义的私有变量
_private int num = 10;
// 内部类可以直接访问外部类的成员，包括private私有成员
public class Inner{
//类没有输出语句
public void show(){ System._out.println(_num); } }
// 外部类要访问内部类成员，必须创建对象
public void method(){
// show(); 无法直接访问内部成员方法，必须创建对象
Inner i = new Inner();
i.show(); } }_

2、成员内部类

2.1 成员内部类概述,根据内部类在类中定义的位置不同，有两种形式
① 在类的成员位置：成员内部类
② 在类的局部位置(类的方法里定义的类)：局部内部类

2.2 成员内部类，外界如何创建对象使用呢？
格式： 外部类名.内部类名 对象名 = new 外部类对象.new 内部类对象；
范例： Outer.Inner oi =new Outer().new Inner();// oi是表示一个内部类对象
// 外部类
public class Outer {
// 在类的内部位置定义一个成员变量
private int num = 10;
// 在类的内部位置，成员内部类,将类写在类中主要是为了该类不能被直接访问
// public class Inner{
// // 在成员内部类定于方法，访问外部类的变量
// public void show(){
// System.out.println(num);
// }
// }
// 成员内部私有类,将类写在类中主要是为了该类不能被直接访问
private class Inner{ _public void show(){ System._out.println(_num); } }
// 因为成员内部类为私有类，外部无法访问
// 所以外部类需要创建一个类方法实例一个对象用来调用成员内部类的方法
public void method(){
Inner i = new Inner();
i.show(); } }
——————————————————
public class InnerDemo {
public static void main(String[] args) {
// 创建内部类对象，并调用方法
// Inner i = new Inner(); 报错
// 外部类名.内部类名 对象名 = 外部类对象.内部类对象；
// Outer.Inner oi =new Outer().new Inner();
// oi.show(); 针对public内部类对象调用方法
// 因为内部类对象为私有类，定义外部类方法调用
Outer outer = new Outer();
// 通过类方法调用内部类方法
outer.method(); } }_

3、局部内部类

3.1 局部内部类概述
局部内部类是在内部方法中定义的类，所以外界无法直接访问，需要在方法内部创建内部对象并使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量
// 外部类
public class Outer {
// 在类的内部位置定义一个成员变量
private int num = 10;
// 成员方法
public void method(){
// 成员方法内部定义类—局部内部类
class Inner{
// 局部内部类方法
int num1 = 20;
// 局部内部类方法
public void show(){
// 访问外部类变量
System.out.println(_num);
System._out.println(_num1); } }
// 因为外部类Outer的方法中是一个局部内部类，输出为空，需要定义一个局部内部对象调用局部内部方法
Inner inner = new Inner();
inner.show(); } }
—————————————————————-
public class OuterDemo {
public static void main(String[] args) {
// 无法直接访问需要通过外部类的对象调用外部类的方法间接访问局部内部类方法
Outer outer = new Outer();
// 通过类方法调用内部类,执行为空，因为指向的是一个局部内部类
// 定义一个局部内部类的对象调用局部内部方法，在用外部类间接调用局部内部类方法
outer.method(); } }_

4、匿名内部类 —-没懂

匿名内部类是局部内部类的特殊形式,普通类都是class关键字,匿名内部类是new关键字
前提:存在一个类或者接口,这里的类可以是具体类也可以是抽象类(较多)
格式: 范例:
new类或者接口名(){ new Inter() {
重写方法; public void show(){
}; }
}
/ new 关键字是将内部类变成一没有具体名称(匿名)的对象
/ 重写方法说明继承了这个类
/ * 本质就是一个继承了该类或者实现了该接口的子类匿名对象

// 定义一个接口,含有一个抽象show()方法
public interface Inner { void show();// 接口方法默认为public abstract 抽象方法 }
———————————————————————————
// 定义一个外部类,里面含有特殊局部内部类,匿名内部类
public class Outer {
_public void method(){
// new了一个接口的子类匿名对象,是一种特殊的局部内部类
new Inner(){
@Override
public void show() {
System._out.println(“匿名内部类”);
}
};
// 因为其本质是一个对象所以可以通过对象调用方法
new Inner(){
@Override
public void show() {
_System._out.println(“匿名内部类”);
}
}.show();
// 多次调用方法实现 因为是一个对象,应该具有返回值类型,使用多态的方式赋值给父类接口
Inner i = new Inner(){
@Override
public void show() {
_System._out.println(“匿名内部类”);
}
};
i.show();
i.show();
i.show();
}
}
—————————————————————————————————-
public class OuterDemo {
_public static void main(String[] args) {
Outer o = new Outer();
o.method(); } }_

5、匿名内部类在开发中的使用

代码实现：
// 定义一个接口,有jump()方法
public interface Jumpping { _void jump(); }
———————————————————-
// 定义一个实现类实现接口
public class Human implements Jumpping{
@Override
public void jump() { System._out.println(“儿子跳高”); } }
—————————————————————-
// 定义另一个实现类实现接口
public class Human01 implements Jumpping{
@Override
public void jump() { System._out.println(“人跳高”); } }
—————————————————————-
// 定义一个操作类,里面有个method()方法,形参是接口类名
public class JumppingOperator {
// 如果形参是接口名(真实值是实现该接口的实现类j对象)
public void method(_Jumpping j){// new Human(),new Human_01()实现接口类的对象
j.jump(); } }
—————————————————————-
public class JumppingDemo {
public static void main(String[] args) {
// 需求:创建接口操作类的对象,调用method()方法
JumppingOperator jo = new JumppingOperator();
// 该方法需要接口类的实现类对象
// Jumpping j = new Human();
// Jumpping j1 = new Human_01();
// jo.method(j);
// jo.method(j1);
// System.out.println(“—————————-“);
// 每次操作都要新建一个实例类去实现接口的方法，该操作过于繁琐
// 使用匿名局部类，该类本质上是实现一个继承了接口类的子类的匿名对象
jo.method(new Jumpping() {@Override
public void jump() {_System._out.println(“男人跳高”);} });
jo.method(_new Jumpping() {@Override
public void jump() {_System._out.println(“女人跳高”);} });
} }

_