Java编程思想 (1~10)

    public static void main(String[] args) {
        int[] test = new int[3];//基本数据类型数组
        for (int i : test) {
            System.out.println(i);
        }
        Integer[] tem = new Integer[3];//引用类型数组
        for (Integer integer : tem) {
            System.out.println(integer);
        }
    }

   /**
     * Returns the cause of this throwable or {@code null} if the
     * cause is nonexistent or unknown.  (The cause is the throwable that
     * caused this throwable to get thrown.)
     *
     * <p>This implementation returns the cause that was supplied via one of
     * the constructors requiring a {@code Throwable}, or that was set after
     * creation with the {@link #initCause(Throwable)} method.  While it is
     * typically unnecessary to override this method, a subclass can override
     * it to return a cause set by some other means.  This is appropriate for
     * a "legacy chained throwable" that predates the addition of chained
     * exceptions to {@code Throwable}.  Note that it is <i>not</i>
     * necessary to override any of the {@code PrintStackTrace} methods,
     * all of which invoke the {@code getCause} method to determine the
     * cause of a throwable.

     *示例：{@link #getClass()}
     * @return  the cause of this throwable or {@code null} if the
     *          cause is nonexistent or unknown.
     * @since 1.4
     */
    public synchronized Throwable getCause() {
        return (cause==this ? null : cause);
    }

        public class Parcel{
            class Contents{
                private int =1;
                public int value(){return i;}
            }
            //Using inner classes looks just like
            //using any other class,within parcel
            public c ship(){
                Contents c=new Contents();
                return c;
            }
            public static void main(String[] args){
                Parcel p=new Parcel();
                Parcel.Contents=p.ship();
            }
            
        }

public class Sequence{
        private Object[] items;
        private int next=0;
        public Sequence(int size){
            items=new Object[size];
        }
        private class SequenceSelector{
            private int i=0;
            public boolean end(){
                return i=items.length;//
            }
            public void next(){
                i++;
            }
        }
        public SequenceSelector selector(){
            return new SequenceSelector();
        }
        
        public static void main(String[] args){
            Sequence seq=new Sequence();
            Sequence.SequenceSelector=seq.selector();
        }        
    }

    public class DotThis{
        void f(){}
        public class Inner{
            public DotThis outer(){
                return DotThis.this;
            }
        }
        public Inner inner(){return new Inner();}
        public static void main(String[] args){
            DotThis dt=new DotThis();
            DotThis.Inner dti=dt.new Inner();
            dti.outer().f();
        }
    }

public interface Destination{
    String readLabel();
}
public interface Contents{
    int value();
}

class Parcel{
    private class PContents implements Contents{
        public int value(){return 10;}
    }
    
    protected class PDestination implements Destination{
        public String readLabel(){
            return "Hello word";
        }
    }
    
    public PContent contents(){
        return new PContents();
    }
    public PDestination destination(){
        return new PDestination();
    }
}
public class TestParcel{
    public static void main(String[] args){
        Parcel p=new Parcel();
        Contents c=p.contents();
        Destination d=p.destination();
    }
}

//方法内部类(又称局部内部类)
public class Parcel{
    //方法
    public Destination destination(){
        //方法内部类
        class PInner implements Destination{
            public String say(){
                return "Hello word!";
            }
        }
        return new PInner();
    }
    
    public static void main(String[] args){
        Parcel p=new Parcel();
        Destination d=p.destination();
    }
}

//作用域内部类
public class Parcel{
    public void fun(boolean b){
        if(b){
            //作用域内部类
            class Inner{
                private String id;
                Inner(String id){
                    this.id=id;
                }
                public String say(){}
            }
            new Inner().say();
        }
    }
    public static void main(String[] args){
        Parcel p=new Parcel();
        p.fun(true);
    }
}

abstract class Base{
        public Base(int i){
            print("Base constructor ");
        }
        public abstract void f();
    }
    public class Anonymous{
        public static Base getBase(int i){//这里的i参数传递给了匿名类的基类构造函数,
        //并没有在匿名类内部使用
            return new Base(i){
                public void f(){
                    print("Anonymout f()");
                }
            }
        }
        
        public Destination destination(final String dest,final float price){
            return new Destination(){
                private int cost;
                {
                    cost=Math.round(price);//当直接在匿名类直接使用参数时必须加final                    
                }
                private String str=dest;
            }
            
        }
        
        public static void main(String[] args){
            Base base=getBase(4);
            base.f();
        }
    }

interface Game{boolean move();}
interface GameFactory{Game getGame();}

class Checker implements Game{
    public boolean move(){...}
    public static GameFactory factory=new GameFactory(){
        public Game getGame(){return new Checker()};
    };
}
class Chess implements Game{
    public boolean move(){....}
    public static GameFactory factory=new GameFactory(){
        public Game getGame(){return new Chess()};
    };
}
public class TestGames{
    public static void playGame(GameFactory g){
        Game game=g.getGame();
        g.move();
    }
    
    public static void main(String[] args){
        playGame(Checker.factory);
        playGame(Chess.factory);
    }    
}

    class Outer{
        static class Inner{}
    }
    class Test {
        public static void main(String[] args){
            Outer.Inner n = new Outer.Inner();
        }
    }

    public interface Outter{
        void fun();
        class Inner implements Outter{
            public void fun(){}
            public static void main(String[] args){
                new Inner().fun();
            }
        }
    }

class Outter1{
    private void f(){}
    class Outter2{
        private void g(){}
        class Inner{
            void h(){
                g();
                f();
            }
        }
    }    
}
public class Test{
    public static void main(String[] args){
        Outter1 o1=new Outter1();
        Outter1.Outter2 o2=o1.new Outter2();
        Outter1.Outter2.Inner i=o2.new Inner();
        i.h();
    }
}

package com.test.demo;

interface Incrementable {
    void increment();
}

class Callee1 implements Incrementable {
    private int i = 0;

    public void increment() {
        i++;
        System.out.println(i);
    }
}

class MyIncrement {
    public void increment() {// 注意这里已经有了一个increment方法
        System.out.println("\nOther operation");
    }

    static void f(MyIncrement mi) {
        mi.increment();
    }
}
//因为Callee2继承MyIncrement中已经又increment方法了
//如果Callee2想要implements(实现) Incrementable
//那么就需要使用内部类
class Callee2 extends MyIncrement {
    private int i = 0;

    public void increment() {
        super.increment();
        i++;
        System.err.println(i);
    }

    private class ClosureDe implements Incrementable {
        @Override
        public void increment() {
            Callee2.this.increment();//这里调用外部类的increment方法
        }
    }

    Incrementable getCallbackReference() {
        return new ClosureDe();
    }
}

class Caller {
    private Incrementable callbackreference;

    public Caller(Incrementable inc) {
        this.callbackreference = inc;
    }

    void go() {
        callbackreference.increment();
    }
}

public class Closure {
    public static void main(String[] args) {
        Callee1 c1 = new Callee1();
        Caller caller1 = new Caller(c1);
        caller1.go();
        caller1.go();

        Callee2 c2 = new Callee2();
        MyIncrement.f(c2);
        Caller caller2 = new Caller(c2.getCallbackReference());
        caller2.go();
        caller2.go();
    }
}

package com.test.demo;
class WithInner {
class Inner {}
}

public class InheritInner extends WithInner.Inner {
　　public InheritInner(WithInner wi) {
  wi.super();
 }
public InheritInner() {
new WithInner().super();
}
public static void main(String[] args) {
　　 WithInner wi = new WithInner();
　　 InheritInner ii = new InheritInner(wi);
　　}
}