java基础内部类（毕向东老师）

内部类
//特点：内部类可以直接访问外部类的成员，
//外部类要访问内部类中的成员必须创建内部类的对象。
//为什么要定义内部类呢？
类是用于描述事物的，而事务中如果还有具体的事物，而且这个内部的事物在访问着所属事物
中的内容，这时这个内部的事物，也需要用到类来描述。这个类就是内部类。
为什么内部类可以直接访问外部类的成员？
因为内部类都持有一个外部类的引用。外部类名。this。

static class Inner{
int num=5;
void method(){
{
int num=6;
System.out.println("method run.."+num);
}
public void show(){
System.out.println("num+"num);
Inner in=new Inner();
in.method();
System.out.println("num="+Outer.this.num);
}
}
class Haha{
class Inner{

}
}
class InnerClassDemo{
public static void main(String[] args)
{
new Outer().show();

//直接在其他类中访问一个类的内部类。
//因为Inner是一个成员，可以先创建一个对象。
Outer.Inner in= new Outer().new Inner();
in.method();
//直接new内部类对象。//调用内部类中的非静态成员method
Outer.Inner in= new Outer.Inner();
in.method();
//访问静态内部类中的静态成员，不需要对象。
Outer.Inter.function();

}
}
}

内部类也可以定义在外部类的局部位置上。
内部类定义在局部位置上，不允许访问局部中的变量。
只能访问被final修饰的局部常量。只能访问被final修饰的局部常量。。。
class Outer
{
private int num=4;
private Object obj;
public void show(final int y){
final int x=5;
class Inner{
void method(){
System.out.println("num="+num);
System.out.println("x="+x);
}
}
obj=new Inner();

class InnerClassDemo3
{
public static void main(String[] args)
{
System.out.println("Hello World:");
}
}

方法要被对象调用，X只在show方法中有效。

//匿名内部类
凡是匿名都是简写格式。
要定义匿名内部类必须有前提，内部类需要继承或者实现一个外部的类或者借口
这时才能简写成匿名内部类的形式。

匿名内部类。其实就是 Demo的一个对象。这个对象用{}结尾内部定义了成员
也就是说是一个带有成员内容的对象，这个对象有点儿胖。

abstract class Demo
{
abstract void show();
}
class Outer
{
private int num=5;
class Inner(没名字怎么办？) extends Demo//多了这一条，可以进行简写了
{
void show()
{
System.out.println("show run..."+num);

}
}
public void method(){
Inner in=new Inner();
in.show();

//在创建对象的过程中就对其进行描述。
格式：new 父类名或接口名（）.成员。

//匿名内部类：其实就是 Demo的一个匿名子类对象。Demo类型的，多态的。
new Demo()
{
void show(){
System.out.println("show run..."+num);
}
}.show();(对象调用方法。)//描述在上面，毕老师说有点儿胖。

}
}
class NoInnerClassDemo
{
public static void main(String[] args){
Outer out=new Outer();
out.method();
}

}
//interface Inter
{
void show();
void show();
}
class Outer{
class Inner implements Inter
{
public void show1()
{}
public void show2()
{}
}
public void method(){
new Inter()
{public void show1()
{}
public void show2()
{}
Inner in=new Inter();
{
private int a=3;
public void show1(){}
public void show2(){}
public void show3(){}
};
in.show1();
in.show2();
in.show3();//不可以。因为这个子类对象已经升级为了Inter接口类型，只能使用Interzhong
的方法，不能使用子类的特有方法。
}
}
}
class NoInnerClassDemo2
{
public static void main(String[] args)
{
new Object()//Object obj=new object()
{
public void show(){
System.out.println("object show run......");
}
public String toString()
{
return "object tostring";
}
};
System.out.println(obj.tostring());
obj.show();

new Inner();
}
class Inner
{
}
public void function()
{
new Inner();
}
}
主函数能直接访问的都是静态的。随类的加载而可以新建对象进行访问。