内部类，匿名内部类
- 一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类，嵌套其他类的类称为外部类。是类的第五大成员（属性，方法，构造器，代码块，内部类），内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。
package com.hspedu.external_;public class InnerClass01 {public static void main(String[] args) {} } class Outer{//外部类private int n1 = 100;//属性public Outer(int n1) {this.n1 = n1;}public void m1(){System.out.println("m1().....");}{//代码块System.out.println("代码块...");}class Inner{//内部类,在Outer内部} } class Outer01{//其他外部类，}内部类和外部类的位置描述
- 内部类的分类（局部，匿名，成员，静态）
- 局部内部类，定义在外部类的局部位置，比如方法中，并且有类名。
package com.hspedu.external_;/* 演示局部内部类的使用*/ //6.外部其它类不能访问局部内部类(因为局部内部类地位是一个局部变量) public class LocalInnerClass {//外部其他类public static void main(String[] args) {Outer02 outer02 = new Outer02();outer02.m1();} } class Outer02{//外部类private int n1 = 100;private void m2(){System.out.println("Outer02里有一个m2()");};//私有方法public void m1(){//局部内部类是定义在外部类的局部位置，通常在方法//2.不能添加访问修饰符，但是可以用final修饰，//final修饰后不能被继承//3.作用域：仅仅在定义它的方法或者代码块中class Inner02{//局部内部类(本质仍是一个类)//1.可以直接访问外部类的所有成员，包含私有的。private int n1 = 200;//外部类和局部内部类的成员重名时public void fi(){//4.局部内部类可以直接访问外部类的成员//7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员// 使用外部类名.this.成员,去访问System.out.println("内部类的n1="+n1);//直接访问外部类的私有的n1属性//Outer02.this本质就是外部类的对象，然后调用外部类的n1System.out.println("外部类的n1="+Outer02.this.n1);m2();}}//5.外部类在方法中，可以创建Inner02对象，然后调用方法即可Inner02 inner02 = new Inner02();inner02.fi();//内部类可以继承，没有finalclass Inner03 extends Inner02{}} } /* 内部类的n1=200 外部类的n1=100 Outer02里有一个m2()*/局部内部类是定义在外部类的局部位置，通常在方法
- 匿名内部类的使用（重要！！！！！！！！）
- 本质是类，内部类，该类没有名字（其实有，但你看不到，系统规定的），同时还是一个对象
- 匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
package com.hspedu.external_;/* 演示匿名内部类的使用*/ public class Anonymous {public static void main(String[] args) {//传统方式Outer04 outer04 = new Outer04();outer04.method();} } class Outer04{//外部类private int n1 = 10;public void method(){//基于接口的匿名内部类//1.需求：想使用IA接口，实现该接口，并创建对象//2.传统方式，写一个类，实现该接口，并创建对象 // Tiger tiger = new Tiger(); // tiger.cry();//3.需求Tiger类只是用一次，后面再不使用，创建一个对象有点浪费空间。//4.可以使用匿名内部类来简化开发IA tiger = new IA(){@Overridepublic void cry() {System.out.println("老虎叫...");}};System.out.println(tiger.getClass());//class com.hspedu.external_.Outer04$1tiger.cry();tiger.cry();//5.tiger的编译类型？等号左边，IA//6.tiger的运行类型？就是匿名内部类XXXX =>Outer04$1/*其实底层是实现了这个的class XXXX implements IA{@Overridepublic void cry() {System.out.println("老虎叫...");}}*///7.jdk底层在创建匿名内部类Outer04$1，立即马上就创建了Outer04$1实例，并且把地址// 返回给tiger//8.匿名内部类使用一次，就不能再使用，tiger对象是可以反复使用的。//演示基于类的匿名内部类//1.father编译类型Father//2.father运行类型 Outer04$2//3.底层会创建匿名内部类/*class Outer04$2 extends Father{@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}}*///4.同时也直接返回了，匿名内部类Outer04$2的对象//Father father = new Father("jack");这个是创建对象的方式OOPFather father = new Father("jack"){//这就是不用创建对象@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}};System.out.println("father对象的运行类型="+father.getClass());//Outer04$2father.test();//演示基于抽象类的匿名内部类Animal animal = new Animal(){@Override//抽象类的匿名内部类这个方法必须要实现void eat() {System.out.println("小狗出骨头...");}};animal.eat();} } interface IA{//接口public void cry(); } //class Tiger implements IA{//传统方式 // @Override // public void cry() { // System.out.println("老虎叫..."); // } //} class Father{public Father(String name) {//构造器}public void test(){//方法}} abstract class Animal{//抽象类abstract void eat();} /*输出 class com.hspedu.external_.Outer04$1 老虎叫... 老虎叫... father对象的运行类型=class com.hspedu.external_.Outer04$2 匿名内部类重写了test方法 小狗出骨头...*/基于接口的匿名内部类的使用是实现，基于类的匿名内部类的使用是继承
-
匿名内部类使用细节：匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征。
package com.hspedu.external_;public class Anonymous01 {public static void main(String[] args) {Outer05 outer05 = new Outer05();outer05.f1();} } class Outer05{private int n1 = 99;public void f1(){//创建一个基于类的匿名内部类//不能添加访问修饰符，因为它的地位就是一个局部变量Person person = new Person(){@Overridepublic void hi() {System.out.println(n1);//可以直接访问外部类的所有成员，包含私有的System.out.println("匿名内部类重写了 hi 方法");}};person.hi();//动态绑定//也可以直接调用new Person(){//这本身就是一个对象@Overridepublic void hi() {System.out.println("应用对象的特征...");}}.hi();} } class Person{public void hi(){System.out.println("Person hi()");} } /*输出 99 匿名内部类重写了 hi 方法 应用对象的特征...*/ //抽象类/接口匿名内部类的两种语法
-
可以直接访问外部类的所有成员，包含私有的
-
不能添加访问修饰符，因为它的地位就是一个局部变量。
-
作用域：仅仅在定义它的方法或代码块中
-
匿名内部类-->访问-->外部类成员【直接访问 4.】
-
外部其它类不能访问匿名内部类（因为匿名内部类地位是一个局部变量）
-
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
-
匿名内部类应用场景
-
package com.hspedu.external_;public class Anonymous02 {public static void main(String[] args) {//匿名内部类，当做实参直接传递，简洁高效f1(new IL() {@Overridepublic void show() {System.out.println("这是一幅名画");}});}//静态方法，形参是接口类型public static void f1(IL il){il.show();} }//接口 interface IL{void show(); } -
package com.hspedu.external_;public class InnerClassExercise02 {public static void main(String[] args) {Cellphone cellphone = new Cellphone();/*1.传递的是实现了Bell接口的匿名内部类2.重写ring3.Bell bell = new Bell() {//运行类型是匿名内部类@Overridepublic void ring() {System.out.println("懒猪起床了...");}}*/cellphone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("懒猪起床了...");}});cellphone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("小伙伴上课了...");}});} } class Cellphone{public void alarmclock(Bell bell){//形参是Bell接口类型bell.ring();} } interface Bell{void ring(); }动态绑定机制
-
-
成员内部类：成员内部类是定义在外部类的成员位置，并且没有static修饰。
-
可以直接访问外部类的所有成员，包含私有的
-
可以添加任意访问修饰符（public ,protected,默认,private）因为它的地位就是一个成员。
-
作用域：和外部类的其他成员一样，为整个类体
-
成员内部类访问外部类成员【直接访问】
-
外部类访问成员内部类【创建对象，在访问】
-
外部其他类访问成员内部类【二种方法】
-
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
-
package com.hspedu.external_;public class MemberInner01 {public static void main(String[] args) {Outer08 outer08 = new Outer08();outer08.t1();//外部其他类访问成员内部类【二种方法】//1.普通类就是外部类创建对象是new Outer08这样，但下面这个成员内部类// 是一个外部类的成员，所以它的语法应该变一下。Outer08.Inner08 inner08 = outer08.new Inner08();//2.第二种方式，在外部类中，编写一个方法，可以返回Inner08对象Outer08.Inner08 inner08Instance = outer08.getInner08Instance();inner08Instance.say();} } class Outer08{//外部类private int n1 = 10;public String name = "张三";//可以添加任意访问修饰符（public ,protected,默认,private）因为它的地位就是一个成员public class Inner08{//成员内部类public void say(){//可以直接访问外部类的所有成员，包含私有的System.out.println("n1="+n1+" 姓名："+name);}}//第二种方法，用方法返回一个成员内部类的实例。public Inner08 getInner08Instance(){return new Inner08();}//在外部类的成员方法中创建成员内部类对象，在调用方法public void t1(){//使用成员内部类//外部类访问成员内部类【创建对象，在访问】Inner08 inner08 = new Inner08();inner08.say();}}成员内部类的用法
-
-
静态内部类：是定义在外部类的成员位置，并且有static修饰
-
package com.hspedu.external_;public class StaticInner01 {public static void main(String[] args) {Outer10 outer10 = new Outer10();//外部其他类 使用静态内部类//方式1//因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)Outer10.Inner10 inner10 = new Outer10.Inner10();inner10.say();//方式2//编写一个方法，可以返回静态内部类的对象实例Outer10.Inner10 inner101 = outer10.getInner10();System.out.println("========");inner101.say();} }class Outer10{int n2 = 200;private int n1 = 100;private static String name = "zhangsan";//Inner10就是静态内部类//1.放在外部类的成员位置//2.使用static修饰//3.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员//4.可以添加任意访问修饰符(public，protected，默认,private)，// 因为它的地位就是一个成员//5.作用域：同其他成员，为整个类体//6.静态内部类访问外部类【直接访问所有静态成员】//7.外部类访问静态内部类【创建对象，在访问(同成员内部类一样)】static class Inner10{public void say(){System.out.println(name);//name私有的,静态的可以直接访问//System.out.println(n1);//不能从静态上下文引用非静态字段“n1”//n2;//不能从静态上下文引用非静态字段“n2”}}public void m1(){Inner10 inner10 = new Inner10();inner10.say();}public Inner10 getInner10(){return new Inner10();} }成员内部类，静态内部类是放在外部类的成员位置，本质就是一个成员。
-
