java基础内部类的种类及简单应用

基础巩固 ，都是课本上的例子

 package 内部类;
/**
 * 
 * 成员内部类
 * @author CZ
 * 在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。
 */
public class Demo1 {
    private class InnerClass{
        //...在内部类中可以随意使用外部类的成员方法以及成员变量
    }
}

 public class Demo2 {
    
    public class InnerClass{
        int y = 0;//定义内部类的成员变量
        public InnerClass() {
            //内部类的构造方法
        }
        public void inf() {
            //内部类的成员方法
        }
    }
    
    InnerClass in = new InnerClass();
    
    public InnerClass doit() {//外部类方法，返回为内部类的引用
        //y=4;        外部类不可以直接访问内部类的成员变量
        in.y = 4;
        return new InnerClass();
    }
    
    public void ouf() {
        in.inf();//在外部类中调用内部类的成员方法
    }
    
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        //内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现
        Demo2.InnerClass in = demo2.doit();
        //不能在new之前使用外部类的名称直接实例化外部类，应首先应该创建一个外部类的对象，通过外部类的对象实例化内部类对象
        Demo2.InnerClass in2 = demo2.new InnerClass();
        
    }
}

package 内部类;

//定义一个接口
interface InterFace {
    public void f();
}
public class Demo3 {
    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        InterFace inter = out.doit();
        inter.f();
        
        //运行结果
        //访问内部类的构造方法
        //访问内部类中的f()方法
        
        //隐藏f()方法的具体实现细节，只为编写子类的人提供一个接口和一个外部类，这是内部类的基本用途
    }
}
class OuterClass{
    //定义一个内部类实现InterFace接口
    private class InnerClass implements InterFace{
        public InnerClass(String s) {
            System.out.println(s);
        }
        @Override
        public void f() {//实现接口中的f()方法
            System.out.println("访问内部类中的f()方法");
        }
    }
    public InterFace doit() {
        return new InnerClass("访问内部类的构造方法");
    }
}

 

package 内部类;

public class Demo4 {
    private int x;
    private class Inner {
        private int x = 9;
        public void doit(int x) {
            x ++;    //调用的是内部类的形参x
            this.x++;    //调用的是内部类的变量x
            Demo4.this.x++;        //调用的是外部类的变量x
        }
    }
    //在内存中所有的对象都被放置在堆中
    //方法以及方法中的形参或局部变量都放置在栈中
}

 

package 局部内部类;
/**
 * 内部类不仅可以在类中进行定义，也可以在类的局部进行定义
 * 在类的方法和任何作用域中都可以定义
 * @author CZ
 *
 */

interface OutInterface{}

public class Demo1 {
    //在方法中定义的内部类只能访问方法中final类型的变量，因为在方法中定义的局部变量相当于一个常量
    public OutInterface doit(final String x) {
        //在doit方法中定义一个内部类
        class InnerClass implements OutInterface{
            public InnerClass(String s) {
                s = x ;
                System.out.println(s);
            }
        }
        return new InnerClass("doit");
    }
}

 public class Demo1 {
    int x = 100;
    static class Inner{
        void doitInner() {
            //System.out.println("外部类"+x);
            //发生编译错误，因为非静态外部类的成员变量为非静态
        }
        //实践与练习2
        public static void main(String[] args) {
            System.out.println("a");
        }
    }
    public static void main(String[] args) {
        //实践与练习3
        Inner inner = new Inner();
    }
}

package 匿名内部类;

//定义一个接口 实践与练习1
interface OutInterface{}
public class Demo1 {
    public OutInterface doit(final String x) {
        return new OutInterface() {
            private int i = 0;
            public int getValue() {
                return i;
            }
        };
    }
}

 

package 内部类的继承;

public class Demo1 extends ClassA.ClassB{
    public Demo1(ClassA a) {
        a.super();
    }
}
class ClassA{
    class ClassB{
        
    }
}