在内中定义类则为内部类
访问特点：
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象；
public class inner {
public static void main(String[] args) {
Outer.Inner i=new Outer().new Inner(); //创建内部类对象
i.method();
}
}
class Outer {
class Inner {
public void method() {
System.out.println(12345);
}
}
}
运行结果
public class inner {
public static void main(String[] args) {
Outer.Inner i=new Outer().new Inner(); //创建内部类对象
i.method();
}
}
class Outer {
private int num = 10;
class Inner {
public void method() {
System.out.println(num);
}
}
}
运行结果
成员内部类私有使用
public class inner {
public static void main(String[] args) {
Outer i=new Outer();
i.print();
}
}
class Outer {
private int num = 10;
private class Inner {
public void method() {
System.out.println(num);
}
}
public void print() {
Inner n=new Inner();
n.method();
}
}
运行结果
静态成员内部类
public class inner {
public static void main(String[] args) {
Outer.Inner i=new Outer.Inner();
i.method();
}
}
class Outer {
static class Inner {
public void method() {
System.out.println(234567);
}
}
}
外部类名.内部类名 对象名 = 外部类名.内部类对象;
new之所以放在前面是因为书写习惯
public class inner {
public static void main(String[] args) {
Outer.Inner i=new Outer.Inner();
Outer.Inner.i.method();
}
}
class Outer {
static class Inner {
public static void method() {
System.out.println(234567);
}
}
}
面试题
在输出中修改使得输出30 20 10
public class inner {
public static void main(String[] args) {
Outer.Inner i=new Outer().new Inner();
i.method();
}
}
class Outer {
public int num=10;
class Inner {
public int num=20;
public void method() {
int num=30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
运行结果
局部内部类访问局部变量的
public class n {
public static void main(String[] args) {
Outerr o=new Outerr();
o.method();
}
}
class Outerr {
public void method() {
final int num=10;
class Interr {
public void print() {
System.out.println(num);
}
}
Interr i = new Interr();
i.print();
}
}
为什么num要用final修饰
为了延长num的声明周期，当调用方法时num的生命周期跟方法的声明周期是一样的，当方法弹栈，这个局部变量也会消失，那么如果局部内部类对象还没由马上消失想用这个局部变量，就没有了，但是用final修饰会加载进常量池，即使方法弹栈，常量也还在常量池，依旧可以继续使用，但是jdk1.8取消了这个事情，可以不加final了
匿名内部类：
就是内部类的简化写法、
前提：存在一个类或者接口
new 类名或者接口名() {
重写方法;
}
本质是一个继承了该类或者实现了该接口的子类匿名对象
核心重点是“父类引用指向子类对象”
public class Inter {
public static void main(String[] args) {
Outer o=new Outer();
o.method();
}
}
interface Interr {
public void print();
}
class Outer {
public void method() {
new Interr() {
public void print() {
System.out.println(2345);
}
}.print();
}
}
匿名内部类重写多个方法调用
public class NoNameInner {
public static void main(String[] args) {
Outer o =new Outer();
o.methods();
}
}
interface Inter {
public void show1();
public void show2();
}
class Outer {
public void methods() {
Inter i =new Inter() {
public void show1() {
System.out.println("show1");
}
public void show2() {
System.out.println("show2");
}
};
i.show1();
i.show2();
}
}
运行结果
匿名内部类是不能向下转型的因为没有子类类名，因此如果内部有自己的方法则无法调用
匿名内部类在开发中的应用
public class NoNameInner {
public static void main(String[] args) {
PersonDemo pd=new PersonDemo();
pd.method(new Person(){
public void show() {
System.out.println(23);
}
});
}
}
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
匿名内部类当作参数传递，本质把匿名内部类看作一个对象
面试题
//按照要求补全代码
public class Noname {
public static void main(String[] args) {
Outer.method().show();
}
}
interface Inter {
void show();
}
class Outer {
}
public class NoName {
public static void main(String[] args) {
Outer.method().show();
}
}
interface Inter {
public void show();
}
class Outer {
public static Inter method() {
return new Inter() {
public void show() {
System.out.println(123);
}
};
}
}
链式编程，每次调用方法后还能继续调用方法，证明调用方法返回的是对象
Outer.method().show(); Inter i=Outer.methods(); i.show();
他们的效果是一样的
