内部类：在一个类中定义的类即为内部类,可以直接访问外部类的成员，
包括私有
格式
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(){
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");
}
});
}
}
