本文主要是介绍Java学习第三十五天＜内部类简介＞＜局部内部类＞＜成员内部类＞＜匿名内部类＞＜静态内部类＞＜练习题＞，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

内部类简介

package chapter11;
​
public class InnerClass01 {//外部其他类
    public static void main(String[] args) {
​
    }
}
class Outer{//类的构成：属性，方法，构造器，代码块，内部类
    private int n1=100;
    public Outer(int n1){
        this.n1=n1;
    }
    public void m1(){
        System.out.println("m1()");
    }
    {
        System.out.println("代码块...");
    }
    class Inner{//内部类
​
    }
}

package chapter11;
​
public class InnerClassExercise01 {
    public static void main(String[] args) {
​
        //当实参直接传递，简洁高效
    f1(new IL() {//只用一次
        @Override
        public void show() {
            System.out.println("这是一幅名画");
        }
    });
    f1(new Picture());//传统方法
    }
    public static void f1(IL il){//形参是接口类型
        il.show();
    }
}
interface IL{
    void show();
}
//传统方法实现接口，硬编码
class Picture implements IL{
​
    @Override
    public void show() {
        System.out.println("这是一幅名画..");
    }
}

package chapter11;
​
public class InnerClassExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        cellPhone.alarmclock(new Bell() {//传递的是实现Bell接口的匿名内部类，重写了ring
            /*
            Bell bell =new Bell(){ 匿名内部类运行类型InnerClassExercise02$
              @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
            }
             */
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellPhone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("上课了");
            }
        });
​
    }
}
interface Bell{
    void ring();
}
class CellPhone{
    public void alarmclock(Bell bell){
        System.out.println(bell.getClass());//运行类型 InnerClassExercise02$ 断点可看
        bell.ring();//动态绑定到InnerClassExercise02$里
    }
}

局部内部类

package chapter11;
​
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println(outer02);
​
    }
}
class Outer02{//外部类
    private int n1=100;
    private int n2=100;
    private void m2(){
        System.out.println("m2执行");
    };
    public void m1(){
        class Inner02{ //局部内部类，定义在外部类的局部位置，通常在方法中，可访问外部类所有成员（包含私有），不能加修饰符除了final（不能被继承），作用域在该方法体内
            private int n2=123;
            public void f1(){
                System.out.println("n1="+n1);
                System.out.println(n2+"外部类n2"+Outer02.this.n2);//就近原则n2 Outer02.this就是外部类对象
                System.out.println(Outer02.this);
                m2();
            }
        }
        class Inner03 extends Inner02{//局部内部类可继承
​
        }
        new Inner02().f1();//方法体内调用内部类方法，new类
    }
​
}

成员内部类

package chapter11;
​
public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.ti();
        Outer01.Inner01 inner01=outer01.new Inner01();//第一种方式 把 new Inner01()看作outer01成员
        inner01.say();
        Outer01.Inner01 inner01Instance = outer01.getInner01Instance();//第二种 在外部类中编写方法，返回Inner01对象
        inner01Instance.say();
​
    }
}
class Outer01{
    private int n1=10;
    public String name="张三";
    private void hi(){
        System.out.println("666");
    }
    public class Inner01{//成员内部类，在外部类的成员位置上，可加任意修饰符（无static），作用域为整个类体
        public double sal=99.8;
        public void say(){
            //成员内部类，可直接访问外部类所有成员，包含私有的，但遵循就近原则（Outer01.this.访问外部类属性）
            System.out.println("Outer01的n1="+n1+"\touter01的name="+name);
            hi();
        }
    }
​
    public void ti(){
        //使用成员内部类
        Inner01 inner01 = new Inner01();
        inner01.say();
        System.out.println(inner01.sal);//外部类创建对象再访问内部类属性
    }
    //返回一个Inner01实例
    public Inner01 getInner01Instance(){
        return new Inner01();
    }
}

匿名内部类

package chapter11;
​
public class AnonymousInnerClass {
    public static void main(String[] args) {
      new Outer04().method();
    }
}
class Outer04{//外部类
    private int n1=10;//属性
    public void method(){//方法
        //基于接口的匿名内部类
        Tiger tiger = new Tiger();//想要实现接口并创建对象，传统方法时写类实现接口并创建对象
        tiger.cry();
        IA dog =new IA(){//只用一次，基于接口的匿名内部类简化开发 编译类型IA，运行类型是匿名内部类
            //创建匿名内部类 Outer04$1 立马就创建了Outer04$1实例，并把地址给了dog
            /*
          class xxx implements IA{  xxx=Outer04$1 分配类名
         @Override
         public void cry() {
         System.out.println("小狗叫了"); }
                                    }
             */
            @Override
            public void cry() {
                System.out.println("小狗叫了");
            }
        };
        System.out.println("tiger运行类型"+tiger.getClass());
        dog.cry();
        System.out.println("dog运行类型"+dog.getClass());
        Father father = new Father("jack") {//基于类的匿名内部类（不打大括号是创建对象） 编译类型Father 运行类型Outer04$2 没有大括号则变Father
            /*
            class Outer04$2 extends Father{
               @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
            }
             */
​
            @Override//不重写相当于上边也没重写方法
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型="+father.getClass());
        father.test();
        //基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("抽象类的匿名内部类");
            }
        };
        animal.eat();
    }
}
interface IA{
    public void cry();
}
class Tiger implements IA{
​
    @Override
    public void cry() {
        System.out.println("老虎叫了");
    }
}
class Father{
    public Father(String name){
        System.out.println("接收name="+name);
    }
    public void test(){
​
    }
}
abstract  class  Animal{
    abstract void eat();
}

package chapter11;
​
public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.fi();
        System.out.println(outer05);
    }
}
class Outer05{
    private int n1=99;
    private int n2=97;
    public void fi(){
        //创建一个基于类的匿名内部类，作用域仅仅在定义它的方法或代码块中
        Person p =new Person(){
            private  int n2=98;
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法"+n1);//可以直接访问外部类所有成员
                System.out.println("就近原则访问"+n2);//外部类和内部类属性重名，按就近原则
                System.out.println("外部类的n1="+Outer05.this.n1);//访问外部类的同名属性+Outer05.this.n1 它就是调用fi对对象
                System.out.println(Outer05.this);
            }
        };
        p.hi();//动态绑定，运行类型是 Outer05$1 不会输出原来的hi
        //也可以直接调用
        new Person(){//新的匿名内部类 也是个对象，可直接调用hi
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法 haha");
            }
​
            @Override
            public void ok(String str) {
                super.ok(str);//class 匿名内部类 extends Person
            }
        }.ok("666");
​
    }
}
class Person{
    public void hi(){
        System.out.println("Person hi()");
    }
    public void ok(String str){
        System.out.println("Person ok()"+str);
    }
}

静态内部类

package chapter11;
​
public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.m1();
        Outer03.Inner03 inner03 = new Outer03.Inner03();
        inner03.say();
        Outer03.Inner03 inner031 = outer03.getinner03();
        inner031.say();
        Outer03.Inner03 inner032 = outer03.getinner03();
        inner032.say();
​
​
    }
}
class Outer03{
    private int n1=10;
    private static String name="张三";
    private static void cry(){
        System.out.println("外部类成员方法");
    };
    //静态内部类 放在外部类成员位置 static修饰 作用域整个类体
    //可直接访问外部类所有静态成员，包括私有，但不能访问非静态成员
    static class Inner03{ //可加任意修饰符
        private static String name="李四";
        public void say(){
            System.out.println(name);//就近原则
            System.out.println("外部类name="+Outer03.name);//静态不用在this
            cry();
        }
​
    }
    public void m1(){
        Inner03 inner03 = new Inner03();//外部类创建对象访问内部类
        inner03.say();
    }
    public Inner03 getinner03(){
        return new Inner03();
    }
    public static Inner03 getInner03(){
        return new Inner03();
    }
}

练习题

package chapter11;
​
public class Test {
    public Test() {
        Inner s1=new Inner();
        s1.a=10;
        Inner s2 = new Inner();
        System.out.println(s2.a);//5
    }
    class Inner{
        public int a=5;
    }
​
    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();
        System.out.println(r.a);//5
    }
​
}

这篇关于Java学习第三十五天＜内部类简介＞＜局部内部类＞＜成员内部类＞＜匿名内部类＞＜静态内部类＞＜练习题＞的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！