Java内部类

内部类：在一个类中定义的类即为内部类,可以直接访问外部类的成员，

包括私有

格式

public class Outer{
    public class Inner{
    }
}

外部类：外部类想要访问内部类成员，必须创建对象

package 内部类;

public class Outer {
    private int num=10;
    public class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
     Inner i=new Inner();
     i.show();
    }
}

 

成员内部类

package heima;

public class Outer {
private int num=10;
public class Inner{
    public void show(){
      System.out.println(num);
    }
}
public void method(){
    Inner i=new Inner();
    i.show();
    }
}

package heima;
//测试类
public class OuterDemo {
    public static void main(String[] args) {
        //Inner i=new Inner();不能这样定义
Outer.Inner k=new Outer().new Inner();
k.show();
Outer o=new Outer();
o.method();

    }
}

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类成员，也可以访问方法内的局部变量

package heima;

public class Outer {
private int num=10;
    public void method(){
        int num2=20;
        class Inner{
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i=new Inner();
        i.show();
    }

}

 

package heima;
//测试类
public class OuterDemo {
    public static void main(String[] args) {
   Outer o=new Outer();
    o.method();
    }
}

静态内部类

所谓静态内部类，就是使用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字,但在功能上,静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部类成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员。

创建静态内部类对象的基本语法格式如下:

外部类名.静态内部类  变量名=new 外部类.静态内部类名（）；
 

 

package heima;

public class Outer {
    static int m=0;
    static class Inner{
     void show(){
         //静态内部类访问外部类静态成员
         System.out.println("外部静态变量m="+m);
     }
    }
}
 class kkk{
    public static void main(String[] args) {
        //静态内部类可以通过外部类创建
        Outer.Inner inner=new Outer.Inner();
        inner.show();
    }
}

匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 格式

new类名或者接口，这里的类可以是具体类也可以是抽象类

• 范例

new Inter(){public void show(){}}

本质：是一个继承了该类或者实现了该接口的子类匿名对象

package heima;

public interface inter {
    void show();

}

package heima;

public class Outer {
public void method(){
    /*  new inter(){

        @Override
        public void show() {
            System.out.println("匿名内部类");
        }
    };*/
  /*  new inter(){

        @Override
        public void show() {
            System.out.println("匿名内部类");
        }
    }.show();*/
    inter i=new inter(){

        @Override
        public void show() {
            System.out.println("匿名内部类");
        }
    };
i.show();
i.show();
}

}

package heima;
//测试类
public class OuterDemo {
    public static void main(String[] args) {
   Outer o=new Outer();
    o.method();
    }
}

匿名内部类在开发中的使用

package heima;
//跳高接口
public interface Jumpping {
    void jump();
}

package heima;
// *** 作类接口，里面有一个方法，方法的参数是接口名
public class JumppingOperator {
    public void method(Jumpping j){//new Cat();new Dog();
        j.jump();
    }
}

package heima;

public class Cat implements Jumpping{
    @Override
    public void jump(){
        System.out.println("猫可以跳高了");
    }
}

package heima;

public class Dog implements Jumpping{
    @Override
    public void jump() {
        System.out.println("狗也跳高了");
    }
}

package heima;
//测试类
public class JumppingDemo {
    public static void main(String[] args) {
        //需求，创建接口 *** 作类的对象，调用method对象
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();
        jo.method(j);
    Jumpping j2=new Dog();
    jo.method(j2);
        System.out.println("-------------------");
     //匿名内部类
jo.method(new Jumpping() {
    @Override//把猫删了都没关系
    public void jump() {
        System.out.println("猫可以跳过了111");
    }
});
jo.method(new Jumpping() {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了111");
    }
});


    }
}