内部类的学习2

package oop.innerclass.a03innerclassdemo03;

public class Outer {
    private int a=10;
    class Inner{
        private int a=20;
        public void show(){
            int a=30;
            System.out.println(a);//30
            System.out.println(this.a);//20
            System.out.println(Outer.this.a);
        }
    }
}
package oop.innerclass.a03innerclassdemo03;

public class Test {
    public static void main(String[] args) {
        Outer.Inner oi=new Outer().new Inner();
        oi.show();
    }
}

静态内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。

创建静态内部类对象的格式：

外部类名.内部类名 对象名=new 外部类名.内部类名（）；

package oop.innerclass.a04innnerclassdemo04;

public class Outer {
    int a=10;
    static int b=20;
    static class Inner{
        public void show1(){
            System.out.println("非静态的方法");
           Outer o=new Outer();
            System.out.println(o.a);
            System.out.println(b);
        }
        public static void show2(){
            System.out.println("静态的方法");
            Outer o=new Outer();
            System.out.println(o.a);
            System.out.println(b);
        }
    }
}
package oop.innerclass.a04innnerclassdemo04;

public class Test {
    public static void main(String[] args) {
Outer.Inner oi=new Outer.Inner();
oi.show1();
Outer.Inner.show2();
    }
}

局部内部类:将内部类定义在方法里面就叫局部内部类，类似于方法里面的局部变量。

外界无法直接使用，需要在方法内部创建对象并使用。

该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

package oop.innerclass.a05innerclassdemo05;

public class Outer {
    int b=20;
   public void show(){
       int a=10;
       //局部内部类
       class inner{
String name;
int age;
public void method1(){
    System.out.println(a);
    System.out.println(b);
    System.out.println("局部内部类中的method1方法");
}
          // public static void method2(){
           //    System.out.println("局部内部类中的method2静态方法");
         //  }
       }
      //创建局部内部类的对象
       inner i=new inner();
       System.out.println(i.name);
       System.out.println(i.age);
       i.method1();
   }
}
package oop.innerclass.a05innerclassdemo05;

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

匿名内部类:本质上就是隐藏了名字的内部类。

格式：

new 接口名或类名(){

重写方法；

};

package oop.innerclass.a06innerclassdemo06;

public abstract class Animal {
    public abstract void eat();
}
package oop.innerclass.a06innerclassdemo06;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}package oop.innerclass.a06innerclassdemo06;

public interface Swim {
    public abstract void swim();
}
package oop.innerclass.a06innerclassdemo06;

public class Test {
    public static void main(String[] args) {
new Swim(){

    @Override
    public void swim() {
        System.out.println("重写了游泳的方法");
    }
};
//Dog d=new Dog();
//method(d);
method(
    new Animal(){

        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    }
    );
new Animal(){

    @Override
    public void eat() {
        System.out.println("重写eat方法");
    }
};
    }
    public static void method(Animal a){
        a.eat();
    }
}
package oop.innerclass.a06innerclassdemo06;

public class Test2 {
    public static void main(String[] args) {
 Swim s=   new Swim(){

        @Override
        public void swim() {
            System.out.println("重写之后的swim方法");
        }
    };
 s.swim();
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写之后的swim方法");
            }
        }.swim();
    }
}

使用场景：

当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只要使用一次，就可以用匿名内部类简化代码。