java基础----内部类

/*
内部类：一个类定义在另外一个类的内部，那么该类就称作为内部类
内部列的class文件名：外部类$内部类。好处：便于区分该class文件是属于哪个外部类的。


内部类的类别：
    1.成员内部类：


成员内部类的访问方式：


    访问方式一：在外部类提供一个方法创建内部类的对象进行访问.
访问方式二：在其他类直接创建内部类的对象。  格式：外部类.内部类 变量名 = new 外部类().new 内部类()
   
   注意：1.如果是一个静态内部类，那么在其他类创建的格式：


         外部类.内部类  变量名 = new 外部类.内部类();


         2.私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象了
   
   内部类的应用场景：我们在描述A事物的时候，发现描述的A事物内部还存在另外一个比较
   复杂的事物B的时候，而且这个比较复杂事物B还需要访问A事物的属性等数据，那么这个时候
   我们就可以使用内部类描述B事物。


   比如：人---->心脏


   class 人{
  血
  氧气
  等...


  class 心脏{
  
  }
   
   }


   内部类的好处：内部类可以访问外部类的所有成员



   内部类需要注意的细节：
       1.如果外部类与内部类存在同名的成员变量时，内部类默认情况下访问内部类的成员变量。
  可以通过“外部类.this.成员变量名”指定访问外部类的成员.


  2.私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象了


       3.成员内部类一旦出现了静态的成员，那么该类也必须使用static修饰
             原因：


   2.局部内部类


*/


//外部类
class Outer
{
static int x = 100;//Outer.class文件被加载到内存的时候存在内存中。静态的成员数据是不需要对象存在才能访问的


//成员内部类
static class Inner//  Outer.Inner.i    若不加static  new Outer.Inner.i
{
static int i = 10;
int x = 200;
public void print(){
System.out.println("这个是成员内部类的print方法"+i);

}
}
//在外部类的方法中创建内部类的对象，然后调用内部的方法。
public void instance(){
Inner inner = new Inner();
inner.print();

}


}




//其他类


class Demo4 
{
public static void main(String[] args) 
{
/*
Outer outer = new Outer();
outer.instance();
System.out.println(Outer.Inner.i);



Outer.Inner inner = new Outer().new Inner();
inner.print();
*/


Outer.Inner inner = new Outer.Inner();
inner.print();
}

}

/*
局部内部类：在一个类的方法内部定义另外一个类，那么另外一个类就称作为局部内部类


局部内部类要注意的细节：




*/






class Outer
{
String name = "外部类的name";
public void test(){
final int y = 100;//局部变量  y什么时候从内存中消失？方法执行完毕之后y消失


//局部内部类
class Inner/*当test方法执行完毕之后，那么Y马上从内存中消失，而Inner对象在方法执行完毕
         的时候还没从内存中消失，而inner对象的print方法还在访问着y变量，这时候y变量已经消失了，
         那么就给人感觉y的生命周期已经被延长。
          解决方案：如果一个局部内部类访问一个局部变量的时候，那么就让该局部内部类
  访问这个局部变量的复制品。

*/
{
int x  = 10;
public void print(){
System.out.println("这个是局部内部类的print方法..."+y);

}
}
Inner inner = new Inner();//这个inner 什么时候消失？Inner对象的生命周期比y的生命周期长。


inner.print();

}
}
class Demo5 
{
public static void main(String[] args) 
{
Outer outer = new Outer();
outer.test();
}
}

/*
匿名内部类：没有类名的类就称作为匿名内部类


匿名内部类的好处：简化书写。


匿名内部类的使用前提：必须存在继承或者实现关系才能使用


匿名内部类一般用于实参。
*/


abstract class Animal
{
public abstract Animal run();
public abstract void sleep();
}


class Outer
{
public void print(){
//需求：在方法内部定义一个类继承Animal，然后调用run方法与sleep方法。
/*     //局部内部类
class Dog extends Animal
{
public void run(){
System.out.println("狗在跑。。。");

}
public void sleep(){
       System.out.println("狗在睁开眼睛水。。。");

}
}
//创建对象
Dog d = new Dog();
d.run();
d.sleep();


//匿名内部类：匿名内部类只是没有类名，其他的一概成员都是具备的。


new 类名();
*/
//匿名内部类与Animal是继承的关系  目前创建的是Animal子类的对象
Animal a = new Animal(){//多态
//匿名内部类的成员
public Animal run(){
System.out.println("狗在跑。。。");
return this;
}
public void sleep(){
System.out.println("狗在睁开眼睛睡。。。");

}

//特有的方法


//想调用特有方法就不能用匿名内部类的
public void bite(){
System.out.println("狗在咬人。。。");

}
};
a.run();
a.sleep();




}
}


class Demo6 
{
public static void main(String[] args) 
{
Outer outer = new Outer();
outer.print();
}
}

/*


实现关系下的匿名内部类
*/


interface Dao
{
public void add();
}


class Outer
{
public void print(){
//创建一个匿名内部类的对象
new Dao(){//不是接口不能创建对象吗？怎么现在又可以了？  此时创建的是接口实现类的对象而不是接口对象
public void add(){
System.out.println("添加成功");
}

}.add();

}
}




class Demo7 
{
public static void main(String[] args) 
{
/*
Outer outer = new Outer();
outer.print();
*/
test(new Dao(){
public void add(){
System.out.println("添加员工成功");

}

});
}


public static void test(Dao d){//形参类型是一个接口的引用
d.add();

}
}