内部类

首先来了解一下方法的调用和对象的初始化方式：

class ShiZi{//另一个类
    String color="黄色";
    public void pao(){
        System.out.println("正在以1.5米每秒的速度奔跑");
    }
    public String jiao(){
        String lzq="吼";
        return lzq;
    }
    public String yanse(){
        return color;
    }
    public String show(){
        return "这是一个"+yanse()+"的玩具狮子";
    }
    }
public class SiZi {//主类
    public static void main(String[] args) {
        ShiZi pwd=new ShiZi();//初始化一个pwd对象
        System.out.println(pwd.show());//调用另一个类的“show（）”方法
        pwd.pao();//调用另一个类的“跑”方法
        System.out.println(pwd.jiao());//调用另一个类的“叫”方法
    }

}

import java.util.Scanner;

class JiSuan{//用于计算的类
    int java;
    int gaoshu;
    int yingyu;
public int zon(){//计算总成绩
    int zoncengji=java+gaoshu+yingyu;
    return zoncengji;
}
public void zon1(){//打印总成绩
    System.out.println("总成绩是："+zon());
}
public double pinjun(){//计算平均分
    double lzq=(java+gaoshu+yingyu)/3;
    return lzq;
}
public void pinjun1(){//打印平均分
    System.out.println("平均成绩："+pinjun());//方法之间的调用
}
}
public class ChengJi {

    public static void main(String[] args) {
        Scanner pwd=new Scanner(System.in);//创建一个对象
        JiSuan oye=new JiSuan();
        System.out.print("请输入java成绩：");
        oye.java=pwd.nextInt();
        System.out.print("请输入高数成绩：");
        oye.gaoshu=pwd.nextInt();
        System.out.print("请输入英语成绩：");
        oye.yingyu=pwd.nextInt();
        oye.zon1();
        oye.pinjun1();
    }

}

然后再来了解内部类及其初始化方式：

实例内部类

实例内部类就是类里面嵌入的类，实例内部类依赖于外部类对象

import study.OuterClass.InnerClass;
class OuterClass{//外部类
    int a = 100;
    public OuterClass(){
        System.out.println("进入外部类构造函数");
    }
    public void show(){
        System.out.println("进入外部类show()方法");
    }

    class InnerClass{//内部类
        private int a = 10;
        public InnerClass() {
            System.out.println("进入内部类构造函数");
        }
        public void show(){
       System.out.println(a);
       System.out.println(OuterClass.this.a);//通过外部类名.this.参数 
            //访问实例数据
        }
    } 
}
public class TestDemo9 {

    public static void main(String[] args) {
        OuterClass lzq=new OuterClass();
        OuterClass.InnerClass lzq1=lzq.new InnerClass();
        lzq1.show();

    }

}

那么为什么实例内部类中不能定义一个编译期间可以确定的立即数呢，这是因为实例内部类的设计意义必须依赖一个外部类对象，拥有static的话就会破坏其结构性，实例内部类还可以拥有外层的this，实例内部类和外部类一样会消耗内存，造成额外开销。

静态内部类

静态内部类与实例内部类不同的就是用static关键字修饰，即用static修饰的内部类就是静态内部类，反之就是实例内部类，静态内部类依赖于外部类，

class OuterClass1{//外部类
    private int a=10;
    private static int b=20;
    public OuterClass1(){
        System.out.println("进入外部类构造函数");
    }
    public void show(){
        System.out.println("进入外部类方法");
    }
static class InnerClass{//静态内部类
        private OuterClass1 outer=null;//
        public InnerClass(OuterClass1 lzq){//
            outer=lzq;
            System.out.println("进入静态内部类构造函数");
        }
        public void show2(){
            System.out.println(outer.a);//
            //不能访问外部类的实例变量，必须通过传入后调用
            System.out.println(b);//可以直接访问外部类的静态成员变量
            System.out.println("内部类方法");
        }
    }
}
public class TestDemo7 {//主类
     public static void main(String[] args) {
        OuterClass1 pwd=new OuterClass1();
        OuterClass1.InnerClass i=new OuterClass1.InnerClass(pwd);
        i.show2();
    }
}

静态内部类怎么访问外部类的实例成员变量：
1.因为实例成员依赖外部类对象
2.所以我们能否传入一个外部类对象，构造函数，传入。
3.主函数内，new外部类。
4.构造方法传入。
5.接收外部类的对象
6.内部类拿到对象
7.输出

匿名内部类

匿名内部类相当于当前类的子类

本地内部类

class Ren{
    private int age;
    private String name;
public Ren(){
    System.out.println("构造方法！");
}
public void show(){
    System.out.println("name: "+name+" age: "+age);
}
}
public class Niming {
public static void lzq(Ren n){
          n.show();
          class Bendi{//本地内部类
                private int a = 10;
                private static final int c = 20;//立即数
                public Bendi(){
                    System.out.println("本地内部类的构造函数");
                }
                public void show(){
                    System.out.println("a :"+a);
                    System.out.println("c :"+c);

    }
}
          Bendi in = new Bendi();
            in.show();

}
    public static void main(String[] args) {
        lzq(new Ren(){//匿名内部类
            public void show(){
                System.out.println("匿名内部类！");
            }
        });

    }

}