Thinking In Java学习总结.docx

第2章 一切都是对象1.若类的某个成员是基本数据类型，即使没有进行初始化，java也会确保它获得一个默认值，但是这种初始化不包括局部变量。例:public class Test int x;(被初始化为0)public void testX()int x;(不会被初始化为0,会报错)2.System.out是一个静态的PrintStream对象。第3章 操作符1.Random random=new Random(x);传入的参数x是一个种子，创建两个实例可以输入相同的种子，这样在调用的时候如果调用步骤相同就会产生相同的随机数。random.nextInt(y);产生0值 + day.getDay(); WeekDay.printDay(5); Mon=MondayTue=TuesdayWed=WednesdayThu=ThursdayFri=FridaySat=SaturdaySun=SundayFri第六章 访问权限控制1.每个编译单元都必须有一个后缀名为.java，而在编译单元内则可以有一个public类，该类的名称必须与文件的名称相同（包括大小写，但不包括文件的后缀名.java）。每个编译单元只能有一个public类，否则编译器就不会接受。如果在该编译单元之中还有额外的类的话，那么在报之外的世界是无法看到这些类的，这是因为他们不是Public类，而且他们主要是用来为主public类提供支持。第七章 复用类1.可以为每个类都设置一个main()方法，可使每个类的单元测试都变得简单易行。2.为了继承，一般将数据成员都设为private，将方法都设置成public.3.对于基本类型，final使数值恒定不变，而对于对象使用final,final使引用恒定不变。好比，final a=new Object(),在程序中，不能再使用a=new Object来创建对象或者将a指向别的对象。4.必须在域的定义处或者每个构造器中用表达式对final进行赋值，这正是final域在使用前是被初始化的原因所在。class Poppet private int i;Poppet(int k) i = k; public String toString() return (Poppet + i); public class BlankFinalEx private final Poppet p; / Blank final reference/ Blank finals MUST be initialized in the constructor:public BlankFinalEx() p = new Poppet(1); / Initialize blank final referencepublic BlankFinalEx(int x) p = new Poppet(x); / Initialize blank final referencepublic static void main(String args) BlankFinalEx b1 = new BlankFinalEx();BlankFinalEx b2 = new BlankFinalEx(47);/ b1.p = new Poppet(2); / Errors: cannot assign values / b2.p = new Poppet(3); / to final variables pSystem.out.println(b1.p: + b1.p);System.out.println(b2.p: + b2.p);5.继承的初始化：有一个类Beetle extends Insect，在Beetle上运行java时，所发生的第一件事就是试图访问Bettle.main()(一个static方法)，于是加载器开始启动并找出Beetle类的编译代码（在名为Bettle.class的文件中）。在对它进行加载的过程中，编译器注意到它有一个基类（这是由关键字extends得知的），于是它继续进行加载。不管你是否打算产生一个该基类的对象，这都要发生。如果该基类还有其自身的基类，那么第二个基类就会被加载，如此类推，接下来，根据基类中的static初始化机会被执行，然后是下一个导出类，以此类推。这种方式很重要，因为导出类的static初始化可能会依赖于基类成员能否被正确初始化。至此为止，必要的类都已经加载完毕，对象就可以被创建了。首先对象中所有的基本类型都会被设为默认值，对象引用被设为null这是通过将对象内存设为二进制零值而一举生成的。然后，基类的构造器会被调用。基类构造器和导出类的构造器一样，以相同的顺序来经历相同的过程。第八章 多态1.只有普通的方法调用可以多态的，如果你直接访问某个域(变量，域等)，这个访问就在编译期进行了解析。例：class Super public int field = 0; public int getField() return field; class Sub extends Super public int field = 1; public int getField() return field; public int getSuperField() return super.field; public class FieldAccess public static void main(String args) Super sup = new Sub(); / Upcast System.out.println(sup.field = + sup.field + , sup.getField() = + sup.getField(); Sub sub = new Sub(); System.out.println(sub.field = + sub.field + , sub.getField() = + sub.getField() + , sub.getSuperField() = + sub.getSuperField(); /* Output: sup.field = 0, sup.getField() = 1 sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0当sub转型为super引用时，任何域访问操作都将由编译器解析，因此不是多态的。在本例中，为super.field和sub.field分配了不同的存储空间。这样，sub实际上包含两个称为field的域；它自己的和它从super处得到的。2.基类的构造器总是在导出类的构造器过程中被调用，而且按照继承层次逐渐向上链接，以使每个基类的构造器都能得到调用。这样做是有意义的，因为构造器具有一项特殊任务：检查对象是否被正确地构造。导出类只能访问它自己的成员，不能访问基类中的成员（基类成员通常是private类型）。只有基类的构造器才具有恰当的知识和权限来对自己的元素进行初始化。因此必须令所有的构造器都得到调用，否则就不能正确地构造完整的对象。这正是编译器为每个导出类部分都必须调用构造器的原因。3.使用引用计数来跟踪仍旧访问着共享对象的对象数量。示例：import static net.mindview.util.Print.*;class Shared private int refcount = 0;private static long counter = 0;private final long id = counter+;public Shared() print(Creating + this);public void addRef() refcount+; protected void finalize() if(refcount 0)print(Error: + refcount + Shared + id + objects in use);protected void dispose() if(-refcount = 0)print(Disposing + this);public String toString() return Shared + id; class Composing private Shared shared;private static long counter = 0;private final long id = counter+;public Composing(Shared shared) print(Creating + this);this.shared = shared;this.shared.addRef();protected void dispose() print(Disposing + this);shared.dispose();public String toString() return Composing + id; public class ReferenceCounting13 public static void main(String args) Shared shared = new Shared();Composing composing = new Composing(shared),new Composing(shared), new Composing(shared),new Composing(shared), new Composing(shared);for(Composing c : composing)c.dispose();Composing compTest = new Composing(shared);Composing compTest2 = new Composing(shared);/ Test finalize():shared.finalize();Shared sharedTest = new Shared();Composing compTest3 = new Composing(sharedTest);/ Test sharedTest finalize():sharedTest.finalize();Creating Shared 0Creating Composing 0Creating Composing 1Creating Composing 2Creating Composing 3Creating Composing 4Disposing Composing 0Disposing Composing 1Disposing Composing 2Disposing Composing 3Disposing Composing 4Disposing Shared 04.实例：import static net.mindview.util.Print.*; class Glyph void draw() print(Glyph.draw(); Glyph() print(Glyph() before draw(); draw(); print(Glyph() after draw(); class RoundGlyph extends Glyph private int radius = 1; RoundGlyph(int r) radius = r; print(RoundGlyph.RoundGlyph(), radius = + radius); void draw() print(RoundGlyph.draw(), radius = + radius); public class PolyConstructors public static void main(String args) new RoundGlyph(5); /* Output: Glyph() before draw() RoundGlyph.draw(), radius = 0 Glyph() after draw() RoundGlyph.RoundGlyph(), radius = 5当glyph的构造器调用draw()方法的时候，radius不是默认初始的1，而是0。初始化的实际过程：1.在其它任何事物发生之前，将分配给对象的存储空间初始化为二进制零。2.如前所述调用基类的构造器。此时，调用覆盖后的draw()方法,由于步骤1的缘故，我们此时会发现radius的值为0。3.按照声明的顺序调用成员的初始化方法。4.调用导出类的构造器主体。编写构造器时有一条有效的原则：“用尽可能简单的方法使对象进入正常的状态；如果可以的话，避免调用其它的方法”。在构造器内唯一能够安全调用的那些方法是基类的final和private方法。5.协变返回类型:它表示在导出类的被覆盖方法可以返回基类方法的返回类型的某种导出类型。第9章 接口1.使用接口的核心原因：为了能向上转型为多个基类类型（以及由此而来的灵活性）。然而，使用接口的第二个原因却是与使用抽象基类相同；防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口。我们应该使用接口还是抽象类？如果要创建不带任何方法定义和成员变量，那么就是选择接口而不是抽象类。2.在打算组合的不同接口中使用相同的方法名通常会造成代码的可读性的混乱，请尽量避免这种情况。3.可以在任何现有类之上添加新的接口，所以这样意味着让方法接受接口类型，是一种让任何类都可以对该方法进行适配的方式。这就是使用接口而不是类的强大之处。4.放入接口中的任何域都是final和static的。第 10 章 内部类1.内部类与组合是完全不同的概念。2.如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须像在main()方法中那样，具体只能这个对象的类型：OuterClassName.InnerClassName.例：public class Parcel2 class Contents private int i = 11; public int value() return i; class Destination private String label; Destination(String whereTo) label = whereTo; String readLabel() return label; public Destination to(String s) return new Destination(s); public Contents contents() return new Contents(); public void ship(String dest) Contents c = contents(); Destination d = to(dest); System.out.println(d.readLabel(); public static void main(String args) Parcel2 p = new Parcel2(); p.ship(Tasmania); Parcel2 q = new Parcel2(); / Defining references to inner classes: Parcel2.Contents c = q.contents(); Parcel2.Destination d = q.to(Borneo); /* Output: Tasmania3.内部类还拥有其外围类的所有元素的访问权。4.内部类需要生成对外部类对象的引用，可以使用外部类的名字后面紧跟圆点和this.例：public class DotThis void f() System.out.println(DotThis.f(); public class Inner public DotThis outer() return DotThis.this; / A plain this would be Inners this public Inner inner() return new Inner(); public static void main(String args) DotThis dt = new DotThis(); DotThis.Inner dti = dt.inner(); dti.outer().f(); /* Output: DotThis.f()第 11 章 持有对象1. 数组是保存一组对象的有效的方式，如果你想保存一组基本类型的数据，也推荐使用这种方式。2. List必须按照插入的顺序保存元素，而Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序。3. Collection构造器可以接受另一个Collection，用它来将自身初始化，因此你可以使用Arrays.List（）来为这个构造器产生输入。但是Collection.addAll()方法运行起来要快得多，而且构建一个不包含元素的Collection,然后调用Collection.addAll这种方式很方便，因此他是首选方式。例：import java.util.*; public class AddingGroups public static void main(String args) Collection collection = new ArrayList(Arrays.asList(1, 2, 3, 4, 5); Integer moreInts = 6, 7, 8, 9, 10 ; collection.addAll(Arrays.asList(moreInts); / Runs significantly faster, but you cant / construct a Collection this way: Collections.addAll(collection, 11, 12, 13, 14, 15); Collections.addAll(collection, moreInts); / Produces a list backed by an array: List list = Arrays.asList(16, 17, 18, 19, 20); list.set(1, 99); / OK - modify an element / list.add(21); / Runtime error because the / underlying array cannot be resized. /:4. 基本的ArrayList，它长于随机访问元素，但是在List的中间插入和移除元素时较慢。LinkedList，它通过代价较低的在List中间进行插入和删除元素操作，提供了优化顺序的访问。LinkedList在随机访问方面相对比较慢，但是它的特性集较ArrayList更大。5. 输出行18-20展示了isEmpty和clear方法。import typeinfo.pets.*; import java.util.*; import static net.mindview.util.Print.*; public class ListFeatures public static void main(String args) Random rand = new Random(47); List pets = Pets.arrayList(7); print(1: + pets); Hamster h = new Hamster(); pets.add(h); / Automatically resizes print(2: + pets); print(3: + pets.contains(h); pets.remove(h); / Remove by object Pet p = pets.get(2); print(4: + p + + pets.indexOf(p); Pet cymric = new Cymric(); print(5: + pets.indexOf(cymric); print(6: + pets.remove(cymric); / Must be the exact object: print(7: + pets.remove(p); print(8: + pets); pets.add(3, new Mouse(); / Insert at an index print(9: + pets); List sub = pets.subList(1, 4); print(subList: + sub); print(10: + pets.containsAll(sub); Collections.sort(sub); / In-place sort print(sorted subList: + sub); / Order is not important in containsAll(): print(11: + pets.containsAll(sub); Collections.shuffle(sub, rand); / Mix it up print(shuffled subList: + sub); print(12: + pets.containsAll(sub); List copy = new ArrayList(pets); sub = Arrays.asList(pets.get(1), pets.get(4); print(sub: + sub); copy.retainAll(sub); print(13: + copy); copy = new ArrayList(pets); / Get a fresh copy copy.remove(2); / Remove by index print(14: + copy); copy.removeAll(sub); / Only removes exact objects print(15: + copy); copy.set(1, new Mouse(); / Replace an element print(16: + copy); copy.addAll(2, sub); / Insert a list in the middle print(17: + copy); print(18: + pets.isEmpty(); pets.clear(); / Remove all elements print(19: + pets); print(20: + pets.isEmpty(); pets.addAll(Pets.arrayList(4); print(21: + pets); Object o = pets.toArray(); print(22: + o3); Pet pa = pets.toArray(new Pet0); print(23: + pa3.id(); /* Output: 1: Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug 2: Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Hamster 3: true 4: Cymric 2 5: -1 6: false 7: true 8: Rat, Manx, Mutt, Pug, Cymric, Pug 9: Rat, Manx, Mutt, Mouse, Pug, Cymric, Pug subList: Manx, Mutt, Mouse 10: true sorted subList: Manx, Mouse, Mutt 11: true shuffled subList: Mouse, Manx, Mutt 12: true sub: Mouse, Pug 13: Mouse, Pug 14: Rat, Mouse, Mutt, Pug, Cymric, Pug 15: Rat, Mutt, Cymric, Pug 16: Rat, Mouse, Cymric, Pug 17: Rat, Mouse, Mouse, Pug, Cymric, Pug 18: false 19: 20: true 21: Manx, Cymric, Rat, EgyptianMau 22: EgyptianMau23: 14输出行22-23展示了你可以如何通过使用toArray()方法，将任意的Collection转化为一个数组。这是一个重载方法，其无参数版本返回的是Object数组，但是如果你向这个重载版本传递目标类型的数据，那么它将产生指定类型的数据。如果参数数组太小，存放不下List的所有元素，那么，toArray()方法将创建一个具有合适尺寸的数组。6.iterator例：import typeinfo.pets.*; import java.util.*; public class SimpleIteration public static void main(String args) List pets = Pets.arrayList(12); Iterator it = pets.iterator(); while(it.hasNext() Pet p = it.next(); System.out.print(p.id() + : + p + ); System.out.println(); / A simpler approach, when possible: for(Pet p : pets) System.out.print(p.id() + : + p + ); System.out.println(); / An Iterator can also remove elements: it = pets.iterator(); for(int i = 0; i 6; i+) it.next(); it.remove(); System.out.println(pets); /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster Pug, Manx, Cymric, Rat, EgyptianMau, Hamster */:Iterator还可以移除next()产生的最后一个元素，这意味着在调用remove()之前必须调用next.7.创建一个display()方法，他不必知晓容器的确切类型：import typeinfo.pets.*; import java.util.*; public class CrossContainerIteration public static void display(Iterator it) while(it.hasNext() Pet p = it.next(); System.out.print(p.id() + : + p + ); System.out.println(); public static void main(String args) ArrayList pets = Pets.arrayList(8); LinkedList petsLL = new LinkedList(pets); HashSet pets