Java-内部类

Java内部类定义 格式 分类

当一个事物的内部,还有一个部分需要完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类

 当一个类内部的成员也需要用属性和行为描述时,就可以定义成内部类了

在java中允许一个类的定义位于另外一个类内部,前者就称之为内部类,后者称之为外部类
  class A{
      class B{
          
      }
  }
  A就是B的外部类
  B就是A的内部类

分类:
  成员内部类(静态,非静态)
  局部内部类
  匿名内部类(重点) -> 匿名内部类属于局部内部类一种

1 静态成员内部类

1.格式:直接在定义内部类的时候加上static关键字即可
  public class A{
      static class B{
      }
  }

2.注意:
  a.内部类中可以定义属性,方法,构造等
  b.静态内部类可以被final或者abstract修饰
    给final修饰,不能被继承
    被abstract修饰,不能new
  c.静态内部类不能调用外部的非静态成员
  d.内部类还可以被四种权限修饰符修饰
3.调用静态内部类成员:
  外部类.内部类 对象名 = new 外部类.内部类()

public class Person {
    public void eat(){
        System.out.println("人要干饭");
        //new Heart().jump();
    }

    
    static class Heart{          //静态成员内部类
        public void jump(){
            System.out.println("心脏会跳");

        }
    }
}


public class Test01 {
    public static void main(String[] args) {

        //外部类.内部类 对象名 = new 外部类.内部类()
        Person.Heart heart = new Person.Heart();
        heart.jump();
    }
}

2 非静态成员内部类

1.格式:
  public class 类名{
      class 类名{
      }
  }

2.注意:
  a.内部类中可以定义属性,方法,构造等
  b.静态内部类可以被final或者abstract修饰
    给final修饰,不能被继承
    被abstract修饰,不能new
  c.静态内部类不能调用外部的非静态成员
  d.内部类还可以被四种权限修饰符修饰
3.调用非静态成员内部类
  外部类.内部类 对象名 = new 外部类().new 内部类()

public class Person {
    public void eat(){
        System.out.println("人要干饭");
        //new Heart().jump();
    }

     class Heart{       //非静态成员内部类
        public void jump(){
            System.out.println("心脏跳");

        }
    }
}

public class Test01 {
    public static void main(String[] args) {
        //外部类.内部类 对象名 = new 外部类().new 内部类()
        Person.Heart heart = new Person().new Heart();
        heart.jump();
    }
}

3.局部内部类

3.1.局部内部类基本操作

可以定义在方法中,代码块中,构造方法中

3.2.接口类型作为方法参数传递和返回

接口作为方法参数,应该传递实现类对象

接口作为方法返回值,应该返回实现类对象

public interface USB {
    public abstract void open();
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        method01(mouse);
        USB usb = method02();//多态
        usb.open();
    }

    /**
     * 接口类型做方法参数,传递的是实现类对象
     * @param usb
     */
    public static void method01(USB usb){//USB usb = mouse
        usb.open();
    }

    /**
     * 接口类型作为方法返回值
     * 返回的是实现类对象
     * @return
     */
    public static USB method02(){
        Mouse mouse = new Mouse();
        return mouse;
    }
}

3.3.抽象类作为方法参数和返回值

1.抽象类作为方法的参数传递,传递的是子类对象

2.抽象类作为方法的返回值,返回的是子类对象

3.4.普通类做方法参数和返回值

1.普通类做方法参数传递,传递的是对象

2.普通类做方法返回值返回,返回的是对象

4.匿名内部类(重点)

1.之前定义局部内部类的时候,都显式声明出来这个局部内部类叫啥,这种局部内部类叫做有名的局部内部类
  那么如果定义局部内部类的时候,没给这个内部类取名字,就可以理解为匿名内部类
  而且之前写过的有名的局部内部类做了接口的实现类或者抽象类的子类使用了,所以匿名的局部内部类也是做接口的实现类或者抽象类的子类使用
2.匿名内部类怎么学:将匿名内部类看成是一种格式,这个格式代表的是匿名内部类的对象,而这个对象都是作为实现类或者子类使用 
3.格式1:以匿名对象的形式将匿名内部类的对象new出来了
  new 接口/抽象类(){
      重写方法
  }.重写的方法();
  好比是: new Dog().eat()
4.格式2:以有名对象的形式将匿名内部类的对象new出来
   接口/抽象类 对象名 = new 接口/抽象类(){
      重写方法
   }  

   对象名.重写方法();

4.1.匿名内部类基本使用

public interface USB {
    void open();
}
public static void main(String[] args) {
      
        new USB(){
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        }.open();
USB usb = new USB(){
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        };
        usb.open();
    }
}

4.2 匿名内部类复杂用法_当参数传递

public interface USB {
    void open();
}
public class Test01 {
    public static void main(String[] args) {
        method(new USB() {      //做为method方法的参数
            @Override
            public void open() {
                System.out.println("usb打开了");
            }
        });
    }

    public static void method(USB usb){
        usb.open();
    }
}

4.3 匿名内部类复杂用法_当返回值返回

public interface USB {
    void open();
}
public class Test02 {
    public static void main(String[] args) {
        USB usb = method();
        usb.open();
    }

    public static USB method(){
        return new USB() {       //作为返回值
            @Override
            public void open() {
                System.out.println("usb开起来");
            }
        };
    }
}