例4.22
JOutTest.java

class JOut  
{
    static class JInner1
    {
        final static String InnerClassName = "JInner1";

        double calculate(double i)
        {
            return i * i;
        }
    }

    class JInner2
    {
        static final String InnerClassName = "JInner2";

        double calculate(double i, double j)
        {
            return i * j;
        }
    }
}

public class JOutTest  
{

    public static void main(String args[])
    {
        JInner1 i1 = new JOut.JInner1();
        JOut o = new JOut();
        JInner2 i2 = o.new JInner2();
        JInner2 i3 = new JOut().new JInner2();
        System.out.println(JOut.JInner1.InnerClassName);
        System.out.println(i1.calculate(10.0));
        System.out.println(JOut.JInner2.InnerClassName);
        System.out.println(i2.calculate(10.0, 20.0));
    }
}

例4.23
JOuter.java

interface JInnerInterface  
{
    void SayHello();
}

public class JOuter  
{
    private int num = 10;

    public class JInner3
    {
        private int num = 100;

        public void show(int num)
        {
            num++; // 方法传递的参数
            this.num++; // 内部类的成员变量
            JOuter.this.num++; // 外部类JOuter的成员变量
            System.out.println("现在的num值是: " + num);
            System.out.println("现在的this.num值是: " + this.num);
            System.out.println("现在的JOuter.this.num值是: " + JOuter.this.num);
        }
    }

    JInner3 i = new JInner3(); // 成员变量i是JInner3内部类的实例对象

    public void increaseSize(int n)
    {
        i.show(n); // 调用JInner3内部类的方法
    }

    public JInnerInterface makeJInner4()
    {
        class JInner4 implements JInnerInterface
        {
            public void SayHello()
            {
                System.out.println("Hello");
            }
        }
        return new JInner4(); // 方法JInner4()返回JInnerInterface接口对象
    }

    public static void main(String[] a)
    {
        JOuter o = new JOuter();
        o.increaseSize(1000);
        JInnerInterface i = o.makeJInner4();
        i.SayHello();
    }
}

例4.24
JInnerClass.java

//定义一个抽象类JClass，JInnerClass类中生成的匿名内部类是其子类
abstract class JClass  
{
    int num;

    public JClass(int i)
    {
        num = i;
    }

    public abstract void showNum();
}

public class JInnerClass  
{
    public static void main(String args[])
    {
        //匿名内部类定义与实例化过程，最后返回的是JClass类对象c
        JClass c = new JClass(5)
        {
            public void showNum()
            {
                System.out.println("num = " + num);
            }
        };
        c.showNum();
    }
}

例4.25
JInnerTest.java

class SuperA  
{
    public String SayHello(String s)
    {
        return s + "  Hello";
    }
}

class SuperB  
{
    public int calculation(int i)
    {
        return ++i;
    }
}

public class JInnerTest  
{
    private class JInnerTest1 extends SuperA
    {

    }

    private class JInnerTest2 extends SuperB
    {
        public int calculation(int i)
        {
            return super.calculation(i);
        }
    }

    public String SayHello(String s)
    {
        return new JInnerTest1().SayHello(s);
    }

    public int calculation(int i)
    {
        return new JInnerTest2().calculation(i);
    }

    public static void main(String args[])
    {
        JInnerTest test = new JInnerTest();
        System.out.println(test.SayHello("张三"));
        System.out.println(test.calculation(100));
    }
}

例4.26
JCat6.java

interface JPet6  
{
    void name();
}

class JSmallAnimal  
{
    public void name()
    {
        System.out.println("class: JSmallAnimal---method: name");
    }
}

public class JCat6 extends JSmallAnimal  
{
    private class JCatInner implements JPet6
    {
        public void name()
        {
            System.out.println("class: JCat6.JCatInner---method: name");
        }
    }

    public static void main(String args[])
    {
        JCat6 cat = new JCat6();
        cat.name();
        cat.new JCatInner().name();
    }
}

例4.27
JGeneric.java

class Hello  
{
    public String toString()
    {
        return "3";
    }
}

public class JGeneric<T1, T2, T3>  
{
    public String test(T1 a, T2 b, T3 c)
    {
        return (a.toString() + b.toString() + c.toString());
    }

    public T1 getT1(T1 a)
    {
        return a;
    }

    public static void main(String args[])
    {
        JGeneric<Integer, String, Hello> j = new JGeneric<Integer, String, Hello>();
        Integer a = new Integer(1);
        String b = new String("2");
        Hello c = new Hello();
        System.out.println(j.test(a, b, c));
    }
}

例4.28
JGeneric2.java

class Hello2  
{
    public String toString()
    {
        return "Hello";
    }

    public int GetNum()
    {
        return 0;
    }
}

class SubHello2 extends Hello2  
{

    private int num;

    SubHello2(int num)
    {
        this.num = num;
    }

    public int GetNum()
    {
        return num;
    }
}

public class JGeneric2<T extends Hello2>  
{
    public String test(T t)
    {
        return (t.toString() + " , Number is  " + t.GetNum());
    }

    public static void main(String args[]) 
    {
        JGeneric2<SubHello2> j = new JGeneric2<SubHello2>();
        SubHello2 t = new SubHello2(100);
        System.out.println(j.test(t));
    }
}

例4.30
JClassTest.java

import java.lang.reflect.Constructor;  
class Class1  
{

}

class SubClass1 extends Class1  
{

}

class JClassTest  
{
    public Object process()
    {
        Class1 c1 = new SubClass1();
        return findClass(c1);
    }

    public Object findClass(Class1 class1)
    {
        return class1;
    }

    public static void main(String args[]) throws SecurityException, ClassNotFoundException
    {
        JClassTest c = new JClassTest();
        Object c2 = c.process();
        Class realClass = c2.getClass();
        Class realClass2 = SubClass1.class;
        System.out.println(realClass == realClass2);
        /**
        Constructor [] constructors = Class.forName("chap4.SubClass1").getConstructors();
        for(Constructor x:constructors)
        {
            System.out.println(x.toString());
        }
        */
    }
}