Thinking in java Chapter10

最新推荐文章于 2020-04-16 15:37:39 发布
最新推荐文章于 2020-04-16 15:37:39 发布
阅读量340 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Purnell/article/details/78777468
版权

练习题：

exercise1:

package Chapter10;

public class Outer {
    class Inner{
    }

    public Inner inner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outer o = new Outer();
        Inner i = o.inner();
    }

}

exercise2：

没有使用迭代器模式。。。可以参考http://blog.csdn.net/qq_35396447/article/details/52541547?locationNum=2&fps=1

package Chapter10;

public class Sequence {
    private StringItem[] items;
    private int next = 0;
    public Sequence(int size) {
        items = new StringItem[size];
    }
    public void add(StringItem st) {
        if(next<items.length)
            items[next++]= st;
    }
    public StringItem getStringItem(String item) {
        return new StringItem(item);
    }

    class StringItem{
        String item;
        public StringItem(String item) {
            this.item = item;
        }
        public String  toString() {
            System.out.println( item.toString());
            return item.toString();
        }
    }

    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        s.add(s.getStringItem("si0"));
        s.add(s.getStringItem("si1"));
        s.add(s.getStringItem("si2"));
        s.add(s.getStringItem("si3"));
        s.add(s.getStringItem("si4"));
        s.add(s.getStringItem("si4"));
        s.add(s.getStringItem("si4"));


        for(int i=0;i<s.items.length;i++) {
            if(s.items[i]!=null)
            s.items[i].toString();
        }
    }

}

exercise3:

package Chapter10;

public class Outer {

    private String str;
    public Outer(String str) {
        this.str =str;
    }
    class Inner{

        public String toString() {
            System.out.println(str);
            return super.toString();
        }

    }

    public Inner inner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outer o = new Outer("Outer");
        Inner i = o.inner();
        i.toString();
    }

}

exercise4：

注释部分

package Chapter10;

interface Selector{
    boolean end();
    Object current();
    void next();
}

public class Sequence {
    private Object[] items;
    private int next = 0;
    public Sequence(int size) {
        items = new Object[size];
    }
    public void add(Object o) {
        if(next<items.length)
            items[next++]= o;
    }
     public Selector selector() {
            return new SequenceSelector();
        }

    private class SequenceSelector implements Selector {
        private int i = 0;

        public Sequence getSequence() {  //外部类名字.this
            return Sequence.this;
        }

        public boolean end() {
            return i == items.length;
        }

        public Object current() {
            return items[i];
        }

        public void next() {
            if (i < items.length) {
                i++;
            }
        }
    }

    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        for(int i=0;i<10;i++) {
            s.add(Integer.toString(i));
        }
        Selector ss = s.selector();
        while(!ss.end()) {
            System.out.print(ss.current()+" ");
            ss.next();
        }

    }

}

exercise5：

package Chapter10;

public class Exercise5 {
    public static void main(String[] args) {
        class1 c1 = new class1();
        class1.Inner ci = c1.new Inner();
    }
}

class class1{
    class Inner{

    }
}

exercise6:

protected的类需要有一个public的构造器，第三个包才能创建这个类。以上是全部发现，不是很清楚这个题想要干嘛。。

package Chapter10.exercise6.pakage1;

public interface Interface1 {
    void f();
}
package Chapter10.exercise6.pakage2;

import Chapter10.exercise6.pakage1.Interface1;

public class Class {
    protected class ProtectedClass implements Interface1{


         public ProtectedClass() {
            // TODO Auto-generated constructor stub
        }

        public void f() {
            // TODO Auto-generated method stub

        }


    }
}
package Chapter10.exercise6.pakage3;

import Chapter10.exercise6.pakage1.Interface1;
import Chapter10.exercise6.pakage2.Class;

public class Class3 extends Class{
    public ProtectedClass getProtectedClass() {
        //return this.new  ProtectedClass();
        return new ProtectedClass();
    }
}

exercise7:

内部类可以修改外部类的私有成员并且可以调用其方法。

package Chapter10;

public class Exercise7 {
    private int i=0;
    private void f() {
        i++;
        System.out.println("i="+i);
    }

    void f1() {
        Inner in = new Inner();
        in.modify();
    }
    class Inner{

        void modify() {

            i++;
            System.out.println(" i="+i);
            f();
        }
    }



    public static void main(String[] args) {
        Exercise7 e = new Exercise7();
        //e.f();
        e.f1();
    }

}

exercise8:

在7的基础上 增加加了注释的两行代码。

package Chapter10;

public class Exercise7 {
    private int i=0;
    private void f() {
        i++;
        System.out.println("i="+i);
        //a++;  报错
    }

    void f1() {
        Inner in = new Inner();
        in.modify();
        in.a++;//通过， 说明不能直接访问 但是可以通过 内部类的引用调用其private的变量
    }
    class Inner{
        private int a=0;
        void modify() {

            i++;
            System.out.println(" i="+i);
            f();
        }
    }



    public static void main(String[] args) {
        Exercise7 e = new Exercise7();
        //e.f();
        e.f1();
    }

}

exercise9:

package Chapter10;


interface Interface{
    void f();
}

public class Exercise9 {
    public Interface Method() {
        class Inner implements Interface {

            @Override
            public void f() {
                System.out.println("f()");

            }

        }
        return new Inner();
    }
    public static void main(String[] args) {
        Exercise9 e = new Exercise9();
        Interface a = e.Method();
        a.f();
    }

}

exercise10:

感觉和第九题没有区别啊。。。。。不懂。。

exercise11:

package Chapter10;

public class Exercise11 {
    private class Inner implements Interface{

        @Override
        public void f() {
            System.out.println("f()");
        }
        public void f2() {

        }
    }

    Interface f1() {
        Interface i = new Inner();
        return i;
    }

    public static void main(String[] args) {
        Exercise11 e= new Exercise11();
        Interface i= e.f1();
        //i.f2();
        i.f();
    }

}

exercise12:

匿名类的实现需要有一个接口或者其他的类作为其基类。

package Chapter10;
interface Inner{
    void modify();
}
public class Exercise7 {
    private int i=0;
    private void f() {
        i++;
        System.out.println("i="+i);
        //a++;  报错
    }

    public Inner f1() {
        return  new Inner(){

            private int a=0;
            public void modify() {
                i++;
                System.out.println(" i="+i);
                f();
            }
            };

    }



    public static void main(String[] args) {
        Exercise7 e = new Exercise7();
        //e.f();
        Inner i = e.f1();
        i.modify();
    }

}

exercise13:

package Chapter10;


interface Interface{
    void f();
}

public class Exercise9 {

    public Interface Method() {
        return new Interface (){

            @Override
            public void f() {
                System.out.println("f()");

            }

        };
    }

    public static void main(String[] args) {
        Exercise9 e = new Exercise9();
        Interface a = e.Method();
        a.f();
    }

}

exercise14:

package Chapter10;

public class Exercise14 {
    public Monster getDangerousMonster() {
        return new Monster() {

            @Override
            public void menace() {
                System.out.println("menace");
            }
            public void destroy(){//扩展的方法
                System.out.println("destroy");
            }
        };
    }
    public Lethal getVampire() {
        return new Lethal() {

            @Override
            public void kill() {
                System.out.println("kill");
            }

             public void drinkBlood(){
                    System.out.println("dringkBlood");
                }
        };
    }
    public static void main(String[] args) {

    }

}

interface Monster{
    void menace();
}
interface Lethal{
    void kill();
}

exercise15:

package Chapter10;

public class Exercise15 {
    private int i;

    public Exercise15(int i) {
    this.i = i;
    System.out.println("i="+i);
    }

    static class Class2{
        public Exercise15 f() {
            return new Exercise15(5) {
            };
        }
    }
    public static Class2 x() {
        Class2 c2 =new Class2();
        return c2;
    }
    public static void main(String[] args) {
        Class2 c2 = x();
        Exercise15 e = c2.f();
    }

}

erercise16:

package Chapter9;


interface Cycle{
    void move();
}
interface CycleFactory{
    Cycle getCycle();
}

class Unicycle implements Cycle{
    public void move() {
        System.out.println("Unicycle move!");
    }

    public static CycleFactory factory() {
        return new CycleFactory() {

            @Override
            public Cycle getCycle() {
                return new Unicycle();
            }
        };

    }
}
//class UnicycleFactory implements CycleFactory{
//
//  
//  public Cycle getCycle() {
//      return new Unicycle();
//  }
//  
//}



class Tricycle implements Cycle{

    public void move() {
        System.out.println("Tricycle move!");
    }
    public static CycleFactory factory() {
        return new CycleFactory() {

            @Override
            public Cycle getCycle() {

                return new Tricycle();
            }
        };
    }
}
//class TricycleFactory implements CycleFactory{
//
//  
//  public Cycle getCycle() {
//      return new Tricycle();
//  }
//  
//}



class Bicycle implements Cycle{

    public void move() {
        System.out.println("Bicycle move!");
    }
    public static CycleFactory factory() {
        return new CycleFactory() {

            @Override
            public Cycle getCycle() {

                return new Bicycle();
            }
        };

    }
}

//class BicycleFactory implements CycleFactory{
//
//  
//  public Cycle getCycle() {
//      return new Bicycle();
//  }
//  
//}


public class Cycles {
    public static void moveCycle(CycleFactory cf) {
        Cycle c = cf.getCycle();
        c.move();
    }

    public static void main(String[] args) {
        moveCycle(new Bicycle().factory());
        moveCycle(new Tricycle().factory());
        moveCycle(new Unicycle().factory());
    }

}

exercise17:

package Chapter9;

import java.util.Random;

interface CoinAndDice{
    void Throw();
}
interface CoinAndDiceFactory{
    CoinAndDice getCoinAndDice();
}

class Coin implements CoinAndDice{
    Random rand = new Random();
    public void Throw() {
        if(rand.nextInt(2)==0)
            System.out.println("Coin:"+"head");
        else 
            System.out.println("Coin:"+"tail");
    }

    public static  CoinAndDiceFactory factory() {
        return new CoinAndDiceFactory() {

            @Override
            public CoinAndDice getCoinAndDice() {

                return new Coin();
            }
        };
    }
}

//class CoinFactory implements CoinAndDiceFactory{
//
//  public CoinAndDice getCoinAndDice() {
//      return new Coin();
//  }
//  
//}

class Dice implements CoinAndDice{
    Random rand = new Random();
    public void Throw() {
        System.out.println("Dice:"+(rand.nextInt(6)+1));
    }
    public static CoinAndDiceFactory factory() {
        return  new CoinAndDiceFactory() {

            @Override
            public CoinAndDice getCoinAndDice() {
                return new Dice();
            }
        };
    }
}

//class DiceFactory implements CoinAndDiceFactory{
//  
//  public CoinAndDice getCoinAndDice() {
//      return new Dice();
//  }
//  
//}


public class CoinsAndDices {
    public static void Throws(CoinAndDiceFactory cdf) {
        CoinAndDice cd =cdf.getCoinAndDice();
        cd.Throw();
    }
    public static void main(String[] args) {
        Throws(new Coin().factory());
        Throws(new Coin().factory());
        Throws(new Coin().factory());
        Throws(new Dice().factory());
        Throws(new Dice().factory());
        Throws(new Dice().factory());
    }

}

exercise18:

package Chapter10;

public class Exercise18 {
    public static class Inner{

    }
    public static void main(String[] args) {
        Inner i = new Inner();
    }

}

exercise19:

类的内部类的内部类不能直接创建需要下面一样通过第一个嵌套类来创建引用。

package Chapter10;

public class Exercise19 {
    public static class Inner1{
        public static class Inner2{
            void f() {
                System.out.println("f()");
            }
        }
    }
    public static void main(String[] args) {
        Inner1.Inner2 i2 = new Inner1.Inner2(); //不能直接创建Inner2
        i2.f();
    }
}

exercise20:

package Chapter10;

public class Exercise20 implements includeInner{
    public static void main(String[] args){
        Test t = new  Test();
        t.f();
    }

}



interface includeInner{
    class Test {

        public void f() {
            System.out.println("f()");          
        }


    }
}

exercise21:

package Chapter10;

public class Exercise20 implements includeInner{
    public static void main(String[] args){
        Test t = new  Test();
        t.f();
    }

    @Override
    public void f1() {
        // TODO Auto-generated method stub

    }

}



interface includeInner{
    void f1();
    static class Test implements includeInner{

        public static void f() {
            new Test().f1();
        }

        @Override
        public void f1() {
            System.out.println("f1()");

        }


    }
}

exercise22:

package Chapter10;

interface Selector{
    boolean end();
    Object current();
    void next();
}

public class Sequence {
    private Object[] items;
    private int next = 0;
    public Sequence(int size) {
        items = new Object[size];
    }
    public void add(Object o) {
        if(next<items.length)
            items[next++]= o;
    }
     public Selector selector() {
            return new SequenceSelector();
        }

     public Selector reverseselector() {
         class reverseSelector implements Selector{
             private int i =items.length-1;

            public Sequence getSequence() {  //外部类名字.this
                return Sequence.this;
            }

            public boolean end() {
                return i == -1;
            }

            public Object current() {
                return items[i];
            }

            public void next() {
                if (i >=0) {
                    i--;
                }
            }

         }
         return new reverseSelector();
     }
    private class SequenceSelector implements Selector {
        private int i = 0;

        public Sequence getSequence() {  //外部类名字.this
            return Sequence.this;
        }

        public boolean end() {
            return i == items.length;
        }

        public Object current() {
            return items[i];
        }

        public void next() {
            if (i < items.length) {
                i++;
            }
        }
    }

    public static void main(String[] args) {
        Sequence s = new Sequence(10);
        for(int i=0;i<10;i++) {
            s.add(Integer.toString(i));
        }
        Selector ss = s.selector();
        Selector rs = s.reverseselector();
        while(!ss.end()) {
            System.out.print(ss.current()+" ");
            ss.next();
        }
        while(!rs.end()) {
            System.out.print(rs.current()+" ");
            rs.next();
        }
    }

}

exercise23:

回调所有A的对象是什么意思。。。 没有看懂。。 后面哪个移除某些U的引用，，我感觉是第二个方法，可是我直接设置成移除所以，所以就不改了。。。

package Chapter10;

interface U{
    void Method1();
    void Method2();
    void Method3();
}

class A{
    U f() {
        return new U() {

            @Override
            public void Method3() {
                System.out.println("A.f().Method3");
            }

            @Override
            public void Method2() {
                System.out.println("A.f().Method2");
            }

            @Override
            public void Method1() {
                System.out.println("A.f().Method1");
            }
        };
    }
}

class B{
    U[] ua = new U[20];
    void acceptU(U u) {
        for(int i=0;i<ua.length;i++) {
            if(ua[i]==null) {
                ua[i]=u;
                break;
            }
        }
    }

    void setNull() {
        for(int i=0;i<ua.length;i++)
            ua[i]=null;
    }


    void callMethod() {
        for(int i=0;i<ua.length;i++)
            if(ua[i]!=null) {
                System.out.println("ua["+i+"]");
                ua[i].Method1();
                ua[i].Method2();
                ua[i].Method3();
            }
    }
}
public class Exercise23 {

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        A a4 = new A();
        A a5 = new A();
        A a6 = new A();
        A a7 = new A();
        B b = new B();
        b.setNull();
        b.acceptU(a1.f());
        b.acceptU(a2.f());
        b.acceptU(a3.f());
        b.acceptU(a4.f());
        b.acceptU(a5.f());
        b.acceptU(a6.f());
        b.acceptU(a7.f());
        b.callMethod();
//      b.setNull();
//      b.callMethod();
    }

}

exercise24:

不是很懂这个Event的原理，然后整个程序也没怎么看懂。但是Event封装的很好，以至于不需要理解也可以添加其他想要添加的事件。

package Chapter10.controller;

import java.util.*;

public class Controller {
    private List<Event> eventlist = new ArrayList<Event>();

    public void addEvent(Event e) {
        eventlist.add(e);
    }

    public void run() {
        while(eventlist.size()>0) {
            for(Event e: new ArrayList<Event>(eventlist))
                if(e.ready()) {
                    System.out.println(e);
                    e.action();
                    eventlist.remove(e);
                }
        }
    }
}
package Chapter10.controller;

public abstract class Event {
    private long eventTime;
    protected final long delayTime;
    public Event(long delayTime) {
    this.delayTime = delayTime;
    start();
    }
    public  void start() {
        eventTime = System.nanoTime()+delayTime;
    }
    public boolean ready() {
        return System.nanoTime() >= eventTime;                                
    }
    public abstract void action();
}
package Chapter10.controller;
import Chapter10.controller.*;

public class GreenhouseController {

    public static void main(String[] args) {
        GreenhouseControls gc = new GreenhouseControls();
        gc.addEvent(gc.new Bell(900));
        Event[] eventList = {
                gc.new ThermostatNight(0),
                gc.new LightOn(200),
                gc.new LightOff(400),
                gc.new WaterOn(600),
                gc.new WaterOff(800),
                gc.new ThermostatDay(1400),
                gc.new Fan(300)
        };
        gc.addEvent(gc.new Restart(2000, eventList));
        if(args.length==1)
            gc.addEvent(new GreenhouseControls.Terminate(new Integer(args[0])));
        gc.run();
    }

}
package Chapter10.controller;

public class GreenhouseControls extends Controller{
    private boolean fan = false;
    public class Fan extends Event{

        public Fan(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            if(fan == true) {
                fan = false;
            }else {
                fan =true;
            }
        }

        @Override
        public String toString() {
            if(fan==true) {
                return "fan is on";
            }else {
                return "fan is off";
            }
        }

    }
    private boolean light = false;
    public class LightOn extends Event{

        public LightOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = true;
        }

        @Override
        public String toString() {
            return "Light is on";
        }
    }
    public class LightOff extends Event{

        public LightOff (long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = false;

        }
        @Override
        public String toString() {
            return "Light is off";
        }
    }

    private boolean water = false;
    public class WaterOn extends Event{

        public WaterOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water = true;

        }

        @Override
        public String toString() {
            return "Greenhouse water is on";
        }

    }
    public class WaterOff extends Event{

        public WaterOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water = false;
        }

        @Override
        public String toString() {
            return "Greenhouse water is off";
        }

    }

    private String thermostat = "Day";
    public class ThermostatNight extends Event{

        public ThermostatNight(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "Night";
        }
        @Override
        public String toString() {
            return "ThermostatNight on night setting";
        }
    }
    public class ThermostatDay extends Event{

        public ThermostatDay(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "Day";
        }
        @Override
        public String toString() {
            return "ThermostatNight on day setting";
        }
    }

    public class Bell extends Event{

        public Bell(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            addEvent(new Bell(delayTime));
        }
        @Override
        public String toString() {
            return "Bing!";
        }
    }

    public class Restart extends Event{
        private Event[] eventList;
        public Restart(long delayTime,Event[] eventList) {
            super(delayTime);
            this.eventList = eventList;
            for(Event e : eventList)
                addEvent(e);
        }

        @Override
        public void action() {
            for(Event e : eventList) {
                e.start();
                addEvent(e);
            }
            start();
            addEvent(this);
        }
        @Override
        public String toString() {
            return "Restarting system";
        }
    }

    public static class Terminate extends Event{

        public Terminate(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            System.exit(0);

        }
        @Override
        public String toString() {
            return "Terminatsing";
        }
    }

}

exercise25:

package Chapter10.controller;
import Chapter10.controller.*;

public class GreenhouseController {

    public static void main(String[] args) {
        GreenhouseControls2 gc = new GreenhouseControls2();
        gc.addEvent(gc.new Bell(900));
        Event[] eventList = {
                gc.new ThermostatNight(0),
                gc.new LightOn(200),
                gc.new LightOff(400),
                gc.new WaterOn(600),
                gc.new WaterOff(800),
                gc.new Fan(300),
                gc.new SprinklerOn(300),
                gc.new SprinklerOff(400),
                gc.new ThermostatDay(1400),

        };
        gc.addEvent(gc.new Restart(2000, eventList));
        if(args.length==1)
            gc.addEvent(new GreenhouseControls.Terminate(new Integer(args[0])));
        gc.run();
    }

}
package Chapter10.controller;

public class GreenhouseControls extends Controller{
    private boolean fan = false;
    public class Fan extends Event{

        public Fan(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            if(fan == true) {
                fan = false;
            }else {
                fan =true;
            }
        }

        @Override
        public String toString() {
            if(fan==true) {
                return "fan is on";
            }else {
                return "fan is off";
            }
        }

    }
    private boolean light = false;
    public class LightOn extends Event{

        public LightOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = true;
        }

        @Override
        public String toString() {
            return "Light is on";
        }
    }
    public class LightOff extends Event{

        public LightOff (long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            light = false;

        }
        @Override
        public String toString() {
            return "Light is off";
        }
    }

    private boolean water = false;
    public class WaterOn extends Event{

        public WaterOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water = true;

        }

        @Override
        public String toString() {
            return "Greenhouse water is on";
        }

    }
    public class WaterOff extends Event{

        public WaterOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            water = false;
        }

        @Override
        public String toString() {
            return "Greenhouse water is off";
        }

    }

    private String thermostat = "Day";
    public class ThermostatNight extends Event{

        public ThermostatNight(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "Night";
        }
        @Override
        public String toString() {
            return "ThermostatNight on night setting";
        }
    }
    public class ThermostatDay extends Event{

        public ThermostatDay(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            thermostat = "Day";
        }
        @Override
        public String toString() {
            return "ThermostatNight on day setting";
        }
    }

    public class Bell extends Event{

        public Bell(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            addEvent(new Bell(delayTime));
        }
        @Override
        public String toString() {
            return "Bing!";
        }
    }

    public class Restart extends Event{
        private Event[] eventList;
        public Restart(long delayTime,Event[] eventList) {
            super(delayTime);
            this.eventList = eventList;
            for(Event e : eventList)
                addEvent(e);
        }

        @Override
        public void action() {
            for(Event e : eventList) {
                e.start();
                addEvent(e);
            }
            start();
            addEvent(this);
        }
        @Override
        public String toString() {
            return "Restarting system";
        }
    }

    public static class Terminate extends Event{

        public Terminate(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            System.exit(0);

        }
        @Override
        public String toString() {
            return "Terminatsing";
        }
    }

}

class GreenhouseControls2 extends GreenhouseControls{
    private boolean sprinkler = false;
    public class SprinklerOn extends Event{

        public SprinklerOn(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            sprinkler = true;
        }
        @Override
        public String toString() {

            return "Sprinkler is on";
        }
    }
    public class SprinklerOff extends Event{

        public SprinklerOff(long delayTime) {
            super(delayTime);
        }

        @Override
        public void action() {
            sprinkler = false;
        }
        @Override
        public String toString() {

            return "Sprinkler is off";
        }
    }
}

exercise26:

package Chapter10;
class WithInner{
    class Inner{
        private int i;
        public Inner(int i) {
            this.i = i;
        }
    }
}
public class Exercise26 {
    class Inner2 extends WithInner.Inner{

        public Inner2(WithInner withInner, int i) {
            withInner.super(i);
        }

    }0000000000000
    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}
Purnell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java getitem方法_java getitemcount
weixin_31238109的博客
02-27 1691
Item item) 菜单增加菜单选项 item add(String s) 向菜单增加选项 s getItem(int n) 获取 n 处的选项 getItemCount() 获取选项数目 insert(MenuItem item,......(list.getItemCount()-1); 10 taskInput.se...getClickCount() 获取鼠标被单击的次数。 getSou...
Thinking_in_java(chapter10).pdf
10-24
Thinking_in_java(chapter10).pdf的答案，与练习题的答案一样
循序渐进学J2Me，第四步
netscaner的专栏
03-22 464
原来只有一个Form，现在增加一个，选Next命令就可以进入下一画面了。不解释了，注意代码的变化。这回的Form里面加StringItem我就不套getStringItem了。import javax.microedition.midlet.*;import javax.microedition.lcdui.*;/** * @author netscaner */public class
commons-fileupload组件中的FileItem中getString()方法乱码问题
04-02 7514
1.当form中设置method="post" enctype="multipart/form-data"时才能正常上传。 2.commons-fileupload上传中如果form中的参数有中文，此时用item.getString()会出现乱码，必须用item.getString("UTF-8")，UTF-8为编码方式。
getString()方法用法详解
热门推荐
Thinkingcao的专栏
04-10 7万+
String getString(intcolumnIndex) 以 Java 编程语言中String的形式获取此ResultSet对象的当前行中指定列的值。 getString String getString(intcolumnIndex)throws SQLException 以 Java 编程语言中String的形式获取
Thinking+In+Java.chm
01-12
"Thinking in Java should be read cover to cover by every Java programmer, then kept close at hand for frequent reference. The exercises are challenging, and the chapter on Collections is superb! Not ...
Thinking in Java Fourth Edition
08-26
Thinking in Java should be read cover to cover by every Java programmer, then kept close at hand for frequent reference. The exercises are challenging, and the chapter on Collections is superb! Not ...
Thinking_in_java(chapter8).pdf
04-10
电子书，很好的国内翻译版本，希望能帮助到大家。。
Thinking in Java Annotated Solutions Guide, Revision 1.0 - Contents
07-11
Thinking in Java Annotated Solutions Guide, Revision 1.0 - Contents Thinking in Java, 2nd edition, Annotated Solution Guide Revision 1.0 by Bruce Eckel ©2002 MindView, Inc. [ Table of Contents ] [ ...
getString（）和toString（） 的区别
piaopiaoxiaoshuaige的博客
03-22 2万+
  刚开始写代码的时候对这两个方法有混淆，现在咱们就来屡屡，    getString()  :这个适用取数据用的，前台传过来的和数据库查出来的都可以，要是单独的一个字符串就可以往里面赋值                        比如前端传过来一个 ID，经过解析完成后，getString（“ID”）就可以得到，在定义一个对象，就可以传值了单个对象的话就不用取在遍历了，就可以直接String...
Dom4j中getStringValue()和getText()用法和区别
王俊的博客
05-08 1万+
这两个方法的左右都是获取文本,但是区别是: getText(方法是)获取当前节点的文本内容。是当前节点.如果当前节点是一个element元素,那返回值就是null. 而getStringValue()则是获取当前节点的子孙节点中所有文本内容连接成的字符串. 也就是说,是包括getText()的.
Android基础：获取手机联系人工具类
Java技术博客，不再更新Android内容
04-21 2229
Android基础：获取手机联系人工具类
PB GetItemString函数详解
duanwenzhi00的专栏
11-16 1万+
GetItemString 函数作用：从数据窗口或者 DataStore 控件的指定缓冲区中获取指定单元的 String 类型的数 据。通过参数的设置，还可以获取指定单元的最初数据，也就是最初 Retrieve 或者最近 Update 成功之后的该单元的取值。需要注意的是，该函数获取的是被 数据窗口中字段接受的数据，是触发完 AcceptText 之后列中的数据，是通过了 校验规则的数据；当用户
Android 中 getString() 方法的小知识点
夏洛克的猫
10-21 7846
最近经常看到为了获取类似如下的字符串hello %s采用下面的代码String formatStr = String.format(getString(R.string.test), "Android");其实 Android 中 Activity ，Fragment 等中其实已经给我封装了更简便的方法，我们可以直接采用如下方法String
Dom4j中getStringValue()和getText()用法的区别
weixin_30307267的博客
04-14 903
这两个方法都是获取文本的，区别是： getText()-----获取当前节点的文本内容，如果当前节点下是一个element元素，那返回的就是null. getStringValue------获取当前节点的子孙节点中的所有文本内容连接成的字符串. 例子： 1 package XML; 2 3 import org.dom4j.Document; 4 import ...
ommons-fileupload组件中的FileItem中.getString()方法乱码问题
qq_36754535的博客
04-16 1147
String value = item.getString(); //value为乱码 解决方法: String value = item.getString("UTF-8"); //value为正常
getString()方法
jiaxr007的专栏
09-07 3万+
   String getString(int columnIndex)           以 Java 编程语言中 String 的形式获取此 ResultSet 对象的当前行中指定列的值。 getStringString getString(int columnI
thinking in java练习题
最新发布
07-16
《Thinking in Java》是一本经典的Java编程入门教材，其中包含了大量的练习题，帮助读者巩固和应用所学的知识。在练习题中，读者需要通过编写代码来解决具体问题，并通过自己的思考和分析来理解Java语言的各种特性和用法。 通过完成《Thinking in Java》中的练习题，读者可以提高自己的编程能力和思考能力。这些练习题覆盖了Java的各个方面，包括基本语法、面向对象编程、异常处理、集合框架、多线程等等。通过解决这些练习题，读者可以逐步掌握Java的核心概念和常用技巧，并在实践中提升自己的编程水平。 在解决练习题时，读者需要运用自己的思维能力，理解题目的要求，分析问题的解决方案，并用Java编写代码实现。这个过程不仅是对Java知识的回顾和巩固，同时也是训练自己的逻辑思维和问题解决能力的过程。 总之，《Thinking in Java》中的练习题提供了一个很好的机会，让读者通过实际的编程练习来巩固和应用所学的知识。通过解决这些练习题，读者可以进一步提升自己的编程能力，并培养自己的逻辑思维和问题解决能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值