Java内部类

目录

一、内部类是什么

二、什么情况下写内部类

三、内部类的分类

---

一、内部类是什么

1.内部类就是在一个类中再定义了一个类，作为外面的这个类的一个大的属性来看待。

2.内部类必须依托外部类的实例。

二、什么情况下写内部类

1.你写的这个类只会在另一个类中使用，不会再其他类中使用，那么就可以将这个类作为另一个类的内部类。

三、内部类的分类

1.常规内部类

（1）放在类中的类

public class Student {
    private int uid;
    private String uname;
    public void outClassMethod(){
        getBookInstance().innerClassMethod();
        System.out.println("outClassMethod");
    }

    public Book getBookInstance(){
        return new Book();
    }
	//常规内部类
    public class Book{
        private int bid;
        private String bname;

        public void innerClassMethod(){
//            outClassMethod();
            System.out.println("innerClassMethod");
        }

        public int getBid() {
            return bid;
        }

        public void setBid(int bid) {
            this.bid = bid;
        }

        public String getBname() {
            return bname;
        }

        public void setBname(String bname) {
            this.bname = bname;
        }
    }
    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }
}

（2）使用常规内部类的格式

• 外部类.内部类 变量名 = 外部类的实例名.new 内部类()

• public class Demo {
      public static void main(String[] args) {
          Student stu = new Student();
          stu.setUid(1);
          stu.setUname("张三");
          Student.Book book = stu.new Book();
          book.setBid(2);
          book.setBname("Java编程思想");
          book.innerClassMethod();
          stu.outClassMethod();
      }
  }

（3）外部类和常规内部类的关系

• 内部类可以直接调用外部类的属性和方法(因为本身就是外部类的一部分)，但是外部类不能直接调用内部类的属性和方法，外部类可以通过内部类的实例(new对象)来调用内部类的属性和方法。
• 所以，我们通常的做法是再外部类中定义一个获得内部类的实例的方法，当我们要访问内部类的时候，直接先调用方法获得内部类的实例再调用内部类的方法，这样外面要访问内部类都会通过外部类的方法作为一个中介。

• public class Student {
      //获取内部类的实例
      public Book getBookInstance(){
          return new Book();
      }
      
      public void outClassMethod(){
          getBookInstance().innerClassMethod();
          System.out.println("outClassMethod");
      }
  	//常规内部类
      public class Book{
          public void innerClassMethod(){
  //            outClassMethod();
              System.out.println("innerClassMethod");
          }
      }
  }

2.局部内部类

（1）放在类中某个方法中的类

public class Student { 
    //方法
    public void outClassMethod(){
        //局部内部类
        public class Book{
            public void innerClassMethod(){
                System.out.println("innerClassMethod");
            }
        }
    }
}

3.静态内部类

（1）在定义内部类的时候加static

public class Singleton{//外部类
    //静态内部类
    public static class SingletonHodler{
        
    }
}

（2）静态内部类可以用来实现单例模式

/**
* 单例模式
*/
public class Singleton {
    private Singleton(){

    }

    /**
     * 静态的内部类保证只会有一个对象
     */
    private static class SingletonHodler{
        static Singleton singleton = new Singleton();
    }

    /**
     * 静态的方法不被延迟加载
     * @return
     */
    public static Singleton getInstance(){
        return SingletonHodler.singleton;
    }
}

4.匿名内部类

(1)在new对象时创建一个类

public abstract class Animals {
    public abstract void eat();

    public abstract void sleep();
}

public class Demo {
    public static void main(String[] args) {
        //匿名内部类
        Animals animals = new Animals() {
            @Override
            public void eat() {
                System.out.println("猫吃鱼");
            }

            @Override
            public void sleep() {
                System.out.println("猫一边睡觉一边磨牙");
            }
        };
        animals.eat();
        animals.sleep();
    }
}

(2)匿名内部类什么时候创建

• 比如：你当前需要创建一个类，但是这个类你只在这里使用一次，那么我们就会把这个类创建为一个匿名内部类。

5.四个内部类中，匿名使用最多，静态使用最少