public class InnerClassTest {public static void main(String[] args) {OuterClass.InnerClass inner=new OuterClass().new InnerClass();//创建内部类对象inner.innerMethod(); //外部类要使用内部类成员，必须创建对象使用
    }
}class OuterClass{//成员变量private int age=10;//构造方法public OuterClass(){}//成员内部类class InnerClass{public void innerMethod(){System.out.println("我是成员内部类，访问外部类的私有属性age:"+age);//内部类可以直接使用外部类的成员，包括私有。
       }}
}

/*成员内部类：内部类定义在成员位置内部类对象创建：Outer.Inner x = new Outer().new Inner();
*/
class Demo8
{public static void main(String[] args) {//Inner inner = new Inner();   //内部类对象不可以直接这样创建//System.out.println(new Outer().age); //调用错误
Outer out = new Outer();Outer.Inner inner = out.new Inner(); //创建内部类对象的方式1Outer.Inner inner2 = new Outer().new Inner();//创建内部类的对象的方式2
        inner.innerMethod();inner2.innerMethod();}
}class Outer
{//成员属性private int age;//成员内部类class Inner{public void innerMethod(){System.out.println("我是内部类的方法,外部类age的值为"+age); //可以直接访问外部私有属性
        }}//成员方法public void outerMethod(){Inner inner = new Inner(); //创建成员内部类对象，调用成员内部类方法
        inner.innerMethod();}
}

/*private与static修饰符的成员内部类private：外界无法直接创建内部类对象，外部类可以创建内部类对象，在此之前可以加入校验。static: 修饰内部类，不需要使用外部类对象，外部类名直接调用，修饰内部类成员，不需要内部类对象，使用内部类名直接调用。
*/
class Demo9
{public static void main(String[] args) {/*private-----------------------------------------------------------------------//当使用private修饰成员内部类，则不能使用以下两种方法创建对象//Outer out = new Outer();//Outer.Inner2 inner = out.new Inner2(); //方式1//Outer.Inner2 inner = new Outer().new Inner2();//方式2//可以在外部类的方法中创建内部类对象，可以增加数据校验，保证安全性out.outerMethod();*///static---------------------------------------------------------------------//当使用static修饰成员内部类，可以直接使用外部类名new Outer.innerMethod()的形式创建内部类对象Outer.Inner inner= new Outer.Inner();inner.innerMethod();//当使用static修饰成员内部类,同时成员内部类的方法也用static修饰时，可以直接使用外部类.内部类.方法的形式，调用内部类的方法！
        Outer.Inner.innerStaticMethod();}
}class Outer
{private static int age;static class Inner{public void innerMethod(){System.out.println("我是内部类的方法,外部类age的值为"+age);}public static void innerStaticMethod(){System.out.println("我是内部类的方法,外部类age的值为"+age);}}public void outerMethod(){//数据校验Inner inner = new Inner();inner.innerMethod();}
}class Outer2
{private int age2;private class Inner2{public void innerMethod2(){System.out.println("我是内部类的方法,外部类age的值为"+age2);}}public void outerMethod2(){//数据校验Inner inner2 = new Inner2();inner2.innerMethod2();}
}

/*匿名内部类：在通过简写形式定义一个没有类名的类。匿名内部类即将匿名定义类与创建对象的动作一起完成。    必须要有实现或者继承关系。格式：new 类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)};  //注意使用的是父类或者接口*/
class Demo11
{public static void main(String[] args) {Demo12 demo12 = new Demo12();demo12.outerMethod();}}abstract class Animal
{public abstract void eat();
}interface MyInterface
{public abstract void method();public abstract void method2();
}class Demo12
{public void outerMethod(){class Cat extends Animal  //内部类
        {public void eat(){System.out.println("舔着吃！");}}Animal cat = new Cat();cat.eat();System.out.println("============================");Animal anyAnimal = new Animal(){ //没有类名，有对象名public void eat(){System.out.println("舔着吃！");}public void method(){System.out.println("我是匿名内部类对象的方法");}};anyAnimal.eat();//anyAnimal.method();new Animal(){public void eat(){System.out.println("舔着吃！");}}.eat();//===============================以上为抽象类的内部类，以下为接口的内部类System.out.println("============================");class MyClass implements MyInterface{public void method() {System.out.println("我是内部类方法1");}public void method2() {System.out.println("我是内部类方法2");}}MyInterface mi = new MyClass();//有类名MyClass，有对象名mi
        mi.method();mi.method2();MyInterface mi2 = new MyInterface(){//没有类名，有对象名mi2public void method() {System.out.println("我是匿名内部类方法1");}public void method2() {System.out.println("我是匿名内部类方法2");}};mi2.method();mi2.method2();new MyInterface(){    //没有类名，没有对象名，即匿名对象public void method() {System.out.println("我是匿名内部类方法1");}public void method2() {System.out.println("我是匿名内部类方法2");}}.method();new MyInterface(){ //没有类名，没有对象名，即匿名对象public void method() {System.out.println("我是匿名内部类方法1");}public void method2() {System.out.println("我是匿名内部类方法2");}}.method2();}
}

package package3;/*使用匿名内部类的场景：1：提高效率2：当参数类型，返回值类型，成员变量类型为抽象类或者接口时，可以使用匿名内部类。3：增强阅读性*/
class Demo13
{public static void main(String[] args){//-----------------普通方式调用  ---------------------Demo13 demo13 = new Demo13();MyClass mc = new MyClass();demo13.method(mc);//-----------------创建匿名内部类---------------------demo13.method(new MyInerface(){public void method() {System.out.println("匿名对象匿名内部类方法一");}public void method2() {System.out.println("匿名对象匿名内部类方法二");}});MyAbsClass mac = demo13.method2();mac.eat();mac.sleep();mac.hitBeanBean();}//参数类型为接口的方法public void method(MyInerface mi) {mi.method();mi.method2();}//返回值类型为抽象类的方法public MyAbsClass method2() {// 方式1：有类名MyClass2、有对象名mac/* MyAbsClass mac = new MyClass2();return mac;*///方式2：没有类名，有对象名mac/*MyAbsClass mac = new MyAbsClass(){public void eat() {System.out.println("匿名内部类中：学完匿名内部类，就吃不下去了！");}public void sleep(){System.out.println("匿名内部类中：学完匿名内部类，就睡不着了！");}};return mac;*///方式3：没有类名，没有对象名return new MyAbsClass(){      //匿名内部类public void eat() {System.out.println("匿名内部类中：学完匿名内部类，就吃不下去了！");}public void sleep(){System.out.println("匿名内部类中：学完匿名内部类，就睡不着了！");}};}
}//---------------------------接口--------------------------------------
interface MyInerface
{public abstract void method();public abstract void method2();
}class MyClass implements MyInerface
{public void method() {System.out.println("方法一");}public void method2() {System.out.println("方法二");}
}//---------------------------抽象类--------------------------------------abstract class MyAbsClass
{public abstract void eat();public abstract void sleep();public void hitBeanBean(){System.out.println("学完匿名内部类，就开始打豆豆！");}
}//---------------------------非抽象类--------------------------------------
class MyClass2 extends MyAbsClass
{public void eat() {System.out.println("学完匿名内部类，就吃不下去了！");}public void sleep(){System.out.println("学完匿名内部类，就睡不着了！");}
}

/*** 定义并使用内部类。要求包含局部内部类，成员内部类，匿名内部类。*/
public class Main {public static void main(String[] args) {//调用成员内部类Fu.Zi zi= new Fu().new Zi();zi.sleep();//调用局部内部类Fu fu=new Fu();fu.eat();//调用匿名内部类
        fu.method().eatType();}
}

/*** 定义并使用内部类。要求包含局部内部类，成员内部类，匿名内部类。*/
public class Fu {//成员变量String string = "巴马";//成员内部类public class Zi {public void sleep() {System.out.println("睡觉");}}//局部内部类public void eat() {class EatMeat extends EatType {      //局部内部类,必须要继承抽像类或者继承接口public void eatType() {System.out.println("吃肉");}}EatMeat eatMeat = new EatMeat();eatMeat.eatType();}//匿名内部类public EatType method() {  //返回值类型或者参数类型为抽象类或者接口/*EatType type= new EatType(){public void eatType(){System.out.println("吃鱼");}};return type;*/return new EatType(){public void eatType(){System.out.println("吃鱼");}};}}

public abstract class EatType {public abstract void eatType();
}

/*匿名内部类练习：Outer.method.show();    意思为Outer类的静态成员变量method可以调用一个show方法，可以调用show方法的一定是Inter接口的子类实例Outer.method().show();  意思为Outer类的静态成员方法method()的返回值可以调用一个show方法，可以调用show方法的一定是Inter接口的子类实例
*/interface Inter{void show();
}//题目1：
class Outer{//补齐代码public static Inter method() {//方式1/* Inter inter = new Inter(){public void show(){System.out.println("hello world");}};return inter;*///方式2return new Inter(){public void show(){System.out.println("hello world");}};}
}class innerClassTest{public static void main(String[] args){Outer.method().show();}
}//题目2：
/*
class Outer{//补齐代码public static Inter method = new Inter(){public void show(){System.out.println("hello world");}};
}
class innerClassTest{public static void main(String[] args){Outer.method.show();}
}
*/