├── 01 第一章.java ├── 02 第二章.java ├── 03 第三章.java ├── 04 第四章.java ├── 05 第五章.java ├── 06 第六章.java ├── 07 第七章.java ├── 08 第八章.java ├── 09 第九章.java ├── 10 第十章.java ├── 11 第十一章.java ├── 12 第十二章.java ├── 13 第十三章.java ├── 14 第十四章.java ├── 15 第十五章.java ├── README.md └── src ├── code_list_one ├── A2.java ├── ATypeName.java ├── Amphibian.java ├── Assignment.java ├── AutoboxingVarargs.java ├── Beetle.java ├── BlankFinal.java ├── Book.java ├── Cartoon.java ├── Chess.java ├── ConnectionManager.java ├── CovariantReturn.java ├── Cycle.java ├── DataOnly.java ├── Detergent.java ├── Dog.java ├── Employee.java ├── EmptyFinal.java ├── FieldAccess.java ├── FinalAndStatic.java ├── FinalArguments.java ├── FinalData.java ├── FinalOverridingIllusion.java ├── Frog1.java ├── HelloData.java ├── Hide.java ├── Incrementable.java ├── Jursaaic.java ├── Letter.java ├── Lunch.java ├── Music.java ├── Music2.java ├── Note.java ├── Num.java ├── Objc.java ├── ObjectA.java ├── ObjectB.java ├── ObjectC.java ├── ObjectD.java ├── ObjectE.java ├── ObjectF.java ├── ObjectG.java ├── ObjectH.java ├── ObjectI.java ├── ObjectJ.java ├── Orc.java ├── OrderOfIn.java ├── PassObject.java ├── PolyConstructors.java ├── PrivateOverride.java ├── RTTI.java ├── ReadTxt.java ├── Rodent.java ├── Sandwich.java ├── Shapes.java ├── SpaceShipControls.java ├── SpaceShipDelegation.java ├── Spiciness.java ├── StaticPolymorphism.java ├── StaticTest.java ├── StaticWord.java ├── Tank.java ├── Value.java ├── VarargType.java └── Wind.java ├── code_list_three ├── A3.java ├── ArrayListDisplay.java ├── ArrayMaker.java ├── BankTeller.java ├── BasicGenerator.java ├── CPulsPuls.java ├── ClassInit.java ├── Coffee.java ├── Concatenation.java ├── Erased.java ├── ErasedTypeEquivalence.java ├── ErasureAndInheritance.java ├── Factories.java ├── Fibonacci.java ├── FilledList.java ├── Generators.java ├── GenericClassRe.java ├── GenericMethod.java ├── GenericToy.java ├── GenericVarargs.java ├── Holder1.java ├── Immutable.java ├── InstantiateGenericType.java ├── LinkedStack.java ├── LostInformation.java ├── New.java ├── ObjectA.java ├── ObjectB.java ├── ObjectC.java ├── RamdomList.java ├── Shapes.java ├── SimpleProxyDemo.java ├── StringAPI.java ├── SweetShop.java ├── ToyTest.java ├── Tuple.java └── TwoTuple.java └── code_list_two ├── A1.java ├── AddingGroups.java ├── Adventure.java ├── AnonymousConstructor.java ├── Apply.java ├── ClassInInterface.java ├── CrossC.java ├── DotNew.java ├── DotThis.java ├── Factories.java ├── ForeachCollections.java ├── Gerbil.java ├── HorrorShow.java ├── InheritInner.java ├── InterfaceVsIterator.java ├── IterableClass.java ├── LinkedListFeatures.java ├── ListIteration.java ├── LocalInnerClass.java ├── MapMess.java ├── ModifyingArraysAsList.java ├── Months.java ├── MultiImplementation.java ├── MultiInterfaces.java ├── MultiIterableClass.java ├── MultiNestingAccess.java ├── Music4.java ├── Music5.java ├── NestingInterfaces.java ├── Object1.java ├── Object2.java ├── ObjectA.java ├── ObjectB.java ├── ObjectC.java ├── ObjectD.java ├── ObjectE.java ├── ObjectF.java ├── ObjectG.java ├── ObjectH.java ├── ObjectI.java ├── ObjectJ.java ├── ObjectK.java ├── ObjectL.java ├── ObjectM.java ├── ObjectN.java ├── ObjectO.java ├── ObjectP.java ├── ObjectQ.java ├── ObjectR.java ├── ObjectS.java ├── ObjectT.java ├── ObjectU.java ├── ObjectW.java ├── ObjectX.java ├── ObjectY.java ├── ObjectZ.java ├── Outer.java ├── Outer1.java ├── Parcel.java ├── Parcel11.java ├── Parcel5.java ├── Parcel6.java ├── Parcel7.java ├── Parcel7b.java ├── Parcel9.java ├── Parcell.java ├── PriorityQueueDemo.java ├── QueueDemo.java ├── ReversibleArrayList.java ├── Sequence.java ├── SetOfInteger.java ├── SetOperations.java ├── SimpleCollection.java ├── SimpleIteration.java ├── Snippet.java ├── Stack.java ├── TestParcel.java └── TestRandVals.java /01 第一章.java: -------------------------------------------------------------------------------- 1 | public class 第一章 { 2 | 3 | /* 4 | * 5 | * 第一章: 6 | * 7 | * ·java用三个关键字在类的内部设定边界:public,private,protected 8 | * ·public表示紧随其后的元素对任何人都是可用的 9 | * ·private除了类型的创建者和类型的内部方法之外的任何人都不可以访问的元素 10 | * ·protected与private作用相当，差别在于继承的类可以访问protected成员，但是继承的类不能访问private成员，另外protected还具有包访问权限 11 | * 12 | * 13 | * ·继承 14 | * ·在创建一个类之后，即使另一个新类与其具有相似的功能(但还是有一些不同的地方)，你还是等创建一个新类。 15 | * 如果能以现有的类为基础，复制它，然后通过添加和修改这个 副本 来创建新类就要好多了。 16 | * 通过继承就可以达到这种效果，不过也有例外，当源类(被称为基类，超类或父类)发生变动时，"被修改的副本"(被称为导出类，继承类，或子类)也会变动 17 | * 18 | * ·类型不仅仅只是描述了作用于一个对象集合上(一个类就是各种元素集合组成(也就是对象集合))，同时还有与其他类型之间的关系 19 | * ·一个基类包含其所有导出类型所共享的特性和行为，可以创建一个基类型来表示某些对象的核心概念，从基类中导出其他类型，来表示此核心可以被实现的各种不同方式 20 | * (以垃圾回收机为例)，用来归类散落的垃圾，"垃圾"是基本类型，可以通过添加额外的特征(瓶子有颜色)或行为(铁罐可以被磁化)导出更具体的垃圾类型 21 | * (以几何形为例子)，几何形可以包含圆形，多边形等，而多边形也包含正方形，长方形(所有基类就是几何形，派生出很多导出类，这样看起来非常有层次感) 22 | * ·可以通过使用继承来构建一个类型层次结构(已不仅仅是为了继承基类中的内容)，通过继承来建立一个庞大的体系，而看起来是非常有层次结构的 23 | * 24 | * ·所有可以发送给基类的信息同时也可以发送给导出类对象，导出类与基类具有相同的类型。(上面的例子，圆形和多边形(导出类)都属于几何形(基类)) 25 | * 26 | * ·两种方法是基类与导出类产生差异 27 | * ·非常直接，在导出类中添加新方法(这些方法不是基类中的一部分)，这意味中基类不能满足你的所有需求，因此必须额外添加更多额外的方法 28 | * ·但是有时候也应该仔细的考虑，是否存在可以把这些额外的方法再次抽象到基类中。(在这很大程度上就会引发使用下面的 "覆盖":重写基类的方法) 29 | * "覆盖"(在使用extends关键字表示继承的java中):改变基类中方法的行为(方法名不变，在导出类中实现)，使导出类和基类之间产生差异(使之满足导出类的需求) 30 | * 要想覆盖某个方法，可以直接在导出类中建该方法的新定义即可(因为使用extends继承并不一定要实现基类中的所有方法，而是覆盖需要改变的方法即可) 31 | * 32 | * 33 | * ·伴随多态的可互换对象 34 | * ·在处理类型的层次结构时，经常想把一个对象不当作它所属的特定类型对待，而是将其当作其基类的对象对待。这使得人们可以编写出不依赖于特定类型的代码 35 | * 36 | * ·一个非面向对象编程的编译器产生的函数调用会引起所谓的 "前期绑定"，这么做意味着编译器将产生对一个具体函数名字的调用， 37 | * 而运行时将这个调用解析到将要执行的代码的绝对地址 38 | * ·在面向对象中，程序直到运行时才能够确定代码的地址，所以当信息发送到一个泛化对象时(它并不知道具体的实现类是哪一个，调用的是那个类的方法) 39 | * 为了解决这个问题，面向对象程序设计语言使用了 后期绑定 的概念。当向对象发送消息时，被调用的代码直到运行时才能确定下来。 40 | * 编译器要确保被调用的方法存在，并对调用参数和返回值执行类型检查，但是并不知道将执行的确切代码 41 | * ·为了执行后期绑定，java使用一小段特殊的代码来代替绝对地址调用，这段代码使用在对象中存储的信息来计算方法体的地址。这样，根据这一小段代码的内容， 42 | * 每一个对象都可以具有不同的行为表现。当向每一个对象发送消息时，该对象就能够知道对这条消息应该做些什么。 43 | * 44 | * ·把导出类看作是它的基类的过程称为向上转型。 45 | * 46 | * 47 | * ·单继承结构 48 | * ·在单根继承结构中的所有对象都具有一个共用接口，所以它们归根到底都是一个基本类型(Object) 49 | * ·单根继承结构中保证所有对象都具备某些功能。因此，你知道在你的系统中每个对象有那些操作 50 | * ·单根继承结构使垃圾回收器的实现变得容易得多(这正是java相对c++的重要改进之一) 51 | * 52 | * 53 | * ·容器(也称集合) 54 | * ·在某些类库中，一两个通用的容器足够满足所有的需要，但是在其他类库中(例如java中)，具有满足不同需要的各种容器 55 | * 例如:List(用于存储序列)，Map(也称为关联数组，用来建立对象之间的关联)，Set(每种对象类型只持有一个) 56 | * 多个容器可以满足多个需求,还是需要对容器有是所选择，这里有两个原因: 57 | * ·不同容器提供了不同类型的接口和外部行为 58 | * ·不同的容器对于某些操作具有不同的效率(例如ArrayList访问元素快 ，LinkedList增删元素快) 59 | * 60 | * 61 | * ·参数化类型 62 | * ·历史原因: 63 | * 在SE5.0之前，容器存储的对象都只具有java的通用类型:Object。单根继承结构意味着所有东西都是Object类型，所有该容器可以存储任何东西 64 | * 但是由于容器只存储Object，所以当将对象引入容器时，它必须被向上转型为Object，因此它丢失了身份，将它取出时取到的是一个Object引用 65 | * 必须将该Object向下转型为更具体的类型。这种转型方式称为向下转型。向上转型是安全的，但是向下转型是不安全的(因为它不知道你具体的实现类是哪一个) 66 | * 67 | * ·那么是否能创建一个容器，它知道自己所保存的对象类型，从而不需要向下转型以及消除犯错误的可能。 68 | * 这样的解决方案被称为参数化类型机制，参数化类型就是一个编译器可以自动定制作用于特定类型上的类。例如使用参数化类型，编译器可以定制一个只接受和取出Dog对象的容器 69 | * 70 | * ·SE5.0 的重大变化之一就是增加了参数化类型，在java中称为泛型。一对<>，中间包含类型信息。例如可以用下面这样的语句来创建一个存储Dog的ArrayList的容器 71 | * ArrayList list = new ArrayList(); 72 | * 73 | * 74 | * ·对象的创建和生命周期 75 | * ·对象的数据位于何处?怎样控制对象的生命周期?C++认为 效率 控制最重要的议题，所以给程序员提供了选择的权力。 76 | * 为了追求最大的执行速度，对象的存储空间和生命周期可以在编写程序是确定，这可以通过将对象置于堆栈或静态存储区域来实现。 77 | * 这种方式将 存储空间分配和释放 放置于优先考虑的位置，在某些情况下这样的控制非常有价值。但是，也牺牲了灵活性， 78 | * 因为必须在编写程序时知道对象的确切的数量，生命周期和类型。 79 | * ·还有一种方式被称为 堆的内存池 中动态地创建对象(动态内存分配方式)。在这种方式中，直到运行时才知道需要多少对象，它们的生命周期以及类型是什么。 80 | * 这些问题只能在程序运行时相关代码被执行到的那一刻才能确定。 81 | * 如果需要一个新的对象，可以在需要的时刻直接在 堆 中创建。因为存储空间是在运行时被动态管理的，所以需要大量的时间在 堆 中分配存储空间， 82 | * 但这可能要远远大于在 堆栈 中创建存储空间的时间(C++就是采用这种时间比较快的方式) 83 | * ·java完全采用动态内存分配方式。每当想要创建新对象时，就要使用new关键字来构建此对象的动态实例 84 | * ·还有一个议题，就是对象生命周期。 85 | * 对于允许在 堆栈 上创建对象的语言，编译器可以确定对象存活时间，并自动销毁它。 86 | * 然而在 堆 上创建对象，编译器就会对它的生命周期一无所知。在C++这样的语言中，必须通过编程的方式来确定何时销毁对象，不能正确处理可能会导致内存泄漏(C++常见的问题) 87 | * java提供了"垃圾回收器"的机制，它可以自动发现对象何时不再使用，并销毁它。这种机制减少了考虑的议题和必须编写的代码，更重要是提供更高层的保障，可避免暗藏的内存泄漏 88 | * ·java的"垃圾回收器"被设计用来处理内存释放问题，它知道对象何时不再使用，并自动释放对象占用的内存 89 | * 这一点是由于 所有对象都是继承自单根基类Object 以及 只能以一种方式创建对象(在堆上创建) 这两个特性结合起来，使得用java编程的过程较之用c++要简单得多 90 | * 91 | * 92 | * ·异常处理:处理错误 93 | * ·异常是一种对象，它从出错地点被抛出，并 被 专门设计用来处理特定类型错误相应的异常处理器 "捕获"。 94 | * ·异常处理就像是 与 程序正常执行路径 并行的，在错误发生时执行的另一条路径。因为它是另一条完全分离的执行路径，不会干扰到正常的代码 95 | * 这往往使得代码代码编写的简单，因为不需要被迫定期检查错误。此外，被抛出的异常不像方法返回的错误值和方法设置的用来表示错误条件的标志位那样可以被忽略。 96 | * ·异常不能被忽略，所以它保证一定会在某处等到处理。最后需要指出的是:异常提供了一种从错误状况进行可靠恢复途径。现在不再是只能退出程序， 97 | * 你可以经常进行校正，并恢复程序的执行，这些都有助于编写出更健壮的程序。 98 | * ·java异常处理在众多的编程语言中格外引人注目，因为java一开始就内置了异常处理，并强制你必须使用它。它是唯一可接受的错误报告方式。 99 | * 如果没有编写正确的处理异常代码，那么就会得到一条编译时的出错信息。这种有保障的一致性有时会使错误处理非常容易 100 | * ·值得注意的是，异常处理不是面向对象的特征--尽管在面向对象语言中异常常被表示成为一个对象。异常处理在面向对象语言出现之前就已经存在了。 101 | */ 102 | 103 | 104 | } 105 | -------------------------------------------------------------------------------- /02 第二章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.*; 2 | 3 | import java.util.Date; 4 | 5 | public class 第二章 { 6 | 7 | /* 8 | * ·第二章：一切都是对象 9 | * 10 | * ·在java中一切都被视为对象，因此可采用单一固定的语法。尽管一切都看成对象，但操纵的标识符实际上是对象的一个"引用"。 11 | * 可以将此情形想象为"遥控器"(引用)与"电视机"(对象)，只要握住这个遥控器，就能保持与电视机连接. 12 | * 当想减少音量，实际操控的是"遥控器"(引用)，在由遥控器来控制"电视机"(对象) 13 | * 如果你想在房间里面到处走走，同时可以控制"电视机"，那么只需要携带"遥控器"(引用)，而不是电视机(对象) 14 | * ·此外，即使没有电视机，遥控器也可以独立存在，也就是说，你拥有一个引用，并不一定需要有一个对象与它关联。像这样创建一个引用:String s; 15 | * 但这里创建非只是引用，并不是对象。如果这是向s发送一个消息，就会返回一个运行时的 错误。因为这会s实际并没有与任何事物关联 16 | * 17 | * 18 | * ·必须由你创建所有对象 19 | * ·存储到什么地方 20 | * ·程序运行时，对象是怎么进行放置安排的呢?特别是内存是怎样分配的呢?有五个地方可以存储数据(java程序中的数据可能存储到的五个区域) 21 | * ·寄存器。这是最快的存储区，因为它位于不同于其他存储区的地方--处理去内部。但是寄存器的数量极其有限，所以寄存器根据需求进行分配。 22 | * 你不能控制，也不能在程序中感觉到寄存器存在的任何迹象(另一方面，C/C++允许您向编译器建议寄存器的分配地址) 23 | * ·堆栈。位于通用RAM(随机访问存储器)中，但是通过堆栈指针可以从处理器那里获得直接的支持。堆栈指针向下移动，则分配新的内存，向上移动，则释放那些内存。 24 | * 这是一种快速有效的分配存储的方法，仅次于寄存器。创建程序时，java系统必须知道存储在堆栈内所有项确切的生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性， 25 | * 所以虽然某些java数据存储于堆栈中--特别是对象引用，但是java对象并不存储于其中 26 | * ·堆。一种通用的内存池(也位于RAM区)，用于存放所有的java对象。堆不同于 堆栈 的好处是:编译器不需要知道存储的数据在堆里存活的时间。因此在堆中分配存储有很大的灵活性。 27 | * 当需要一个对象是，只需要new写一行简单的带代码，当执行这行代码的时候，会自动在对 堆 中进行存储分配。 28 | * 当然，为了这种灵活性是要付出代价的:用 堆 进行存储分配和清理比在 堆栈(栈) 中更耗时。(c/c++可以在 栈 中分配内存，但是java不行) 29 | * ·常量存储。常量值通常直接存放在程序代码内部，这样做是安全的。因为它们永远不会被改变 30 | * ·非RAM存储。 如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。其中两个基本的例子是 流对象 和 持久化对象。 31 | * ·在流对象中，对象转化成字节流，通常被发送给另一台机器。 32 | * ·在"持久化对象"中，对象被存储在磁盘上，因此，程序被终结，它们也可以保持自己的状态。 33 | * 这种存储方式的技巧在于:把对象转化为可以存放在其他媒介上的事物，在需要时，可恢复成常规，基于RAM的对象。 34 | * java提供轻量级持久化的支持，而想jdbc和hibernate这样的机制提供了更加复杂的。 35 | * ·特例:基本类型(不用由你创建的对象) 36 | * ·为什么不用你创建:在程序设计中经常用到一系列类型，它们需要特殊的对待(因为如果自己new的话，会在 堆 中存储这，这样的话聚会耗时),但是你会经常使用这些数据，所以要特殊对待 37 | * 是因为new将对象存储在"堆"里，故用new创建一个对象--一个特别小简单的变量，往往不是很有效(如果你打算把一个数字 1 new进去的话) 38 | * 因此，对于这些类型(比较简单的)，java采取C/C++相同的方法。也就是说，不用new来创建变量，而是创建一个并非是引用的变量(就是操作这个变量是不用引用的，就是不用通过遥控器进行操作)。 39 | * 这个变量直接存储"值"，并置于堆栈中，因此更加高效。 40 | * ·boolean类型所占存储空间的大小没有明确指定，仅定义为能够取字面值true或false 41 | * ·基本类型具有的包装类(包装类创建对象跟其他类是一样的，创建的一个非基本对象在 堆 中，而基本类型创建出来是在 堆栈 中的，而且是没有引用的) 42 | * 例如: 43 | * char c = 'x'; 44 | * Character ch = new Character(c); 45 | * 也可以这样用: 46 | * Character ch = new Character('x'); 47 | * java SE 5.0 的 自动包装功能 能将自动地将 基本类型 转换为 包装器类型(基本类型的数据在 堆栈 中， 包装器类型的数据在 堆 中) 48 | * Character ch = 'x'; 49 | * 并可以反向转换 50 | * char c = ch; 51 | * 52 | * ·高精度数字 53 | * ·java提供两个用于高精度计算的BigInteger和BigDecimal.虽然它们大体上属于"包装器类"的范围，但二者都没有对应的基本类型 54 | * 不过，这两个类包含的方法，提供的操作对 基本类型 所能执行的操作相似。也就是说，能作用于int或float的操作，也同样能够作用于这两个类上。 55 | * 只不过是以方法调用的方式取代了运行符方式实现。由于这么做复杂了许多，所以运行速度会比较慢。在这里以精度换取了速度 56 | * ·java中的数组 57 | * 当创建一个数组对象时，实际上就是创建了一个引用数组，并且每个引用都会自动被初始化为一个特定值，该值拥有自己的关键字null。 58 | * 一旦java看见null，就知道这个引用还没有指向某个对象。在使用任何引用之前，必须指定一个对象 59 | * 如果使用一个还是null的引用，在运行时就会报错。 60 | * 还可以创建用来存放基本类型的数组。同样，编译器也能确保这种数组的初始化，因为它会将这种数组初始化为0(基本类型没有引用) 61 | * 62 | * 63 | * ·永远不要销毁对象 64 | * ·作用域:作用域决定了在其内定义的变量名的可见性和生命周期，在C，C++,java中，作用域由花括号的位置决定的。例如: 65 | * { 66 | * int x = 12; 67 | * { 68 | * int y = 13; 69 | * } 70 | * } 71 | * 在作用域定义的变量只可用于作用域结束之前。 72 | * ·对象的作用域 73 | * ·java对象不具备和基本类型一样额生命周期。当用new创建一个对象时，它就可以存活于作用域之外。例如: 74 | * { 75 | * String s = new String("a object"); 76 | * } 77 | * 引用s在作用域的终点(也就是花括号结束，是一个引用消失，不是对象消失)就消失了。然而，s指向的对象还在内存区域中，我们也无法访问这个对象(因为对它唯一的引用已经超出了作用域范围) 78 | * ·事实证明，由new创建的对象，只要你需要，就会一直保留下去。但这不会出现对象填满内存空间吗?(这是C++经常出现的问题) 79 | * java有一个垃圾回收器，用来监视用new出来的对象，并辨别那些不会再被引用的对象，随后就会释放这些对象的内存空间。(所以你不用担心内存泄漏问题) 80 | * 81 | * ·基本成员默认值 82 | * ·如果类的某个成员是基本数据类型，即使没有进行初始化，java也会确保它获得一个默认值。 83 | * 当变量作为 类的成员变量 使用时，java才确保给定其默认值，以确保那些是基本类型的成员变量等到初始化，防止程序出错。 84 | * 但是，这些初始化的值可能是你不想要的，甚至是不合法的，所以最好对变量进行初始化。 85 | * ·注意:上述确保初始化的方法并不是适合于"局部"变量。所以，在某个方法定义中有:int x; 那么该变量等到的可能是任意值，而不会被自动初始化为零。 86 | * 所以在使用x前，应先对其赋一个适当的值。如果没有这么做，那么编译时就会返回一个错误，告诉你变量没有初始化。(这正是java优于C++的原因，C++只被视为警告，而java视为错误) 87 | * 88 | * ·java中的方法只能作为类的一部分来创建，方法只有通过对象才能被调用。(除了static,static方法并不依赖于对象的存在 ) 89 | * ·方法名和参数列表 (被称为"方法签名") 唯一地标识出某个方法 90 | * ·字段和方法:一旦定义了一个类，就可以在类中设置两种类型的元素:字段和方法 91 | * 92 | * ·static关键字: 93 | * 通过static关键字可以满足下面两个方面的需要: 94 | * ·只想为某特定域分配单一的存储空间，而不去考虑要创建多少对象，甚至根本不需要创建任何的对象 95 | * ·希望某个方法不与这个类型的任何对象相关联 96 | * 例如:static int i = 47; 97 | * ·有些面向对象语言(一个java文献也用到这些术语)使用 类数据 和 类方法 两个术语 表示使用了static关键字的数据 98 | * 99 | * 100 | * ·注释文档的语法 101 | * ·共有三种类型的注释文档(类，域，方法 )，都是位于前面(例如 类注释 在 定义类之前 要定义) 102 | * 类的注释写在这 103 | * public class Document{ 104 | * 域的注释 105 | * public int i; 106 | * 方法的注释 107 | * public void method(){} 108 | * } 109 | * ·注意:javadoc只能为public和protected成语进行文档注释。private会被忽略(非要可见的话可以使用-private注解) 110 | * 111 | * ·嵌入式HTML 112 | * javadoc通过生成的HTML文档传送HTML命令，这使你能够充分利用HTML 113 | * 114 | * ·一些标签示例 115 | * @see:引用其他类(在文档中是以一个超链接的形式导去另一个类中) 116 | * @version：版本号 117 | * @author：作者 118 | * @since：最早使用的版本号 119 | * @param：参数 120 | * @return：描述返回值的类型 121 | * @throws：对抛出的异常进行处理 122 | * @deprecated：指出一些旧特征已由改进的新特征取代 123 | */ 124 | 125 | 126 | public static void main(String[] args) { 127 | //java的基本类型数组 和 包装器类型数组 128 | array(); 129 | 130 | 131 | /* 132 | * 第一个java程序 133 | * ·在每个程序的开头，必须声明import语句(每个java文件都默认导入java.lang) 134 | * ·java.lang中没有Date类，所以必须导入另一个类库才能使用它 135 | * ·选择java.lang，在选择System类.选择out字段，可以看见out是一个静态的PrintStream类型，因为是静态所以不需要创建任何东西，out对象就可以使用。 136 | * 但是out对象可以做什么(调用什么方法)，是由它的类型PrintStream决定的，直接看PrintStream里面有什么方法可用即可。 137 | * PrintStream类中有一个println方法，可以将给你的数据打印到控制台 138 | * 139 | * 这里模拟main方法 140 | */ 141 | main(); 142 | 143 | 144 | /* 145 | * static关键字 146 | */ 147 | staticWord(); 148 | 149 | 150 | /* 151 | * 练习 152 | */ 153 | ObjectB objectB; 154 | HelloData helloData; 155 | ATypeName aTypeName; 156 | DataOnly dataOnly; 157 | ObjectC objectC; 158 | Incrementable incrementable; 159 | ObjectD objectD; 160 | ObjectE objectE; 161 | 162 | } 163 | 164 | private static void array() { 165 | int[] a = new int[8]; 166 | System.out.println("基本类型数组的初始化值是：" + a[0]); 167 | /* 168 | * 基本数据类型的数组的初始值是 0 169 | * 基本数组类型的存储区域是 堆栈 (因为在这里的数据存储速度会很快，当你要经常使用这些数据的时候就会很方便) 170 | */ 171 | Integer[] b = new Integer[8]; 172 | System.out.println("包装器类型数组的初始化值是：" + b[0]); 173 | /* 174 | * 包装器类型的数组的初始值是 null 175 | * 这是包装类型，数据的存储区域是 堆 中，(这里是与其他的对象一样的，就是存储时比存储在 堆栈 中的快) 176 | */ 177 | } 178 | 179 | private static void main(){ 180 | System.out.println("Hello,it's:"); 181 | System.out.println(new Date()); 182 | System.getProperties().list(System.out); 183 | } 184 | 185 | public static void staticWord(){ 186 | ObjectA a1 = new ObjectA(); 187 | ObjectA a2 = new ObjectA(); 188 | System.out.println("对象a1的i值是" + a1.i); 189 | System.out.println("对象a2的i值是" + a2.i); 190 | ObjectA.i++; 191 | System.out.println("对象a1将i值是" + a1.i); 192 | System.out.println("对象a2中的i值" + a2.i); 193 | } 194 | 195 | } 196 | -------------------------------------------------------------------------------- /03 第三章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.Dog; 2 | import code_list_one.ObjectG; 3 | import code_list_one.PassObject; 4 | import code_list_one.Value; 5 | 6 | public class 第三章 { 7 | 8 | /* 9 | * ·第三章：操作符 10 | * ·使用java操作符 11 | * ·基本所有的操作符都只能操作"基本类型"。但这些操作符能操作对象"="，"=="，"!="，除此之外，String类支持"+"和"+=" 12 | * 13 | * ·算术操作符 14 | * ·整数的除法会直接去掉结果的小数位，而不是四舍五入地圆整结果 15 | * ·同时进行运算与赋值操作。例如:要将x加4，并将结果赋回给x，可以这么写:x+=4 16 | * ·自动递增和递减(具体的区别可以看下面的例子): 17 | * ·前缀式:先执行运行，在赋值 18 | * ·后缀式：先赋值，再运行 19 | * ·关系操作符 20 | * ·关系操作符生成的是一个boolean结果，是计算操作数值之间的关系。 21 | * 如果关系是真实的，关系表达式会生成true,如果不真实生成false。 22 | * 有<,>,<=,>=,==,!=。 23 | * ·等于和不等于适用于所有的基本数据类型，而其他比较符不适合boolean类型(其他类型没有意义)。 24 | * ·测试对象的等价性：使用==和！=可以比较对象是不是同一个对象(基本类型和所有的对象都适合)， 25 | * equals方法(不适合基本类型)比较的是两个对象的内容是不是一样的。 26 | * 27 | * ·逻辑运算符 28 | * ·"&&"与 "||"或,"!"非 29 | * ·能根据参数的逻辑关系，生成一个布尔值(true或false) 30 | * ·短路:当 使用"&&" 运行符时，会遇到一种"短路"现象，即一旦确定表达式的值，就不再计算下面的部分了(可以将性能提高 )。 31 | * ·指数记数法:在java中看见 1.39e-43f这样的表达式，它真正的含义是1.39*10的43次方 32 | * ·三元操作符(if-else):boolean-exp ? value0 : value1 ，如果boolean-exp的值为true就计算value0，false就计算value1. 33 | * ·类型转换操作符: 34 | * ·窄化转化:将 精度高 的转换为 精度低 的，可能会面临信息丢失，必须使用强制类型转换。例如:double d = 2.2; int i = (int)d; 35 | * ·扩展转换:将 低精度 的转换为 高精度 的，不用使用强制类型转换，因为新类型肯定能容纳原来类型的信息，例如:int i = 2; double b = i;(这里不用进行强制类型转换) 36 | * ·截尾和舍入:在执行窄化转换时，，如果将一个浮点数转化为整型值。将29.7转换为int，结果会是29，要想是四舍五入使用的是Math.round(29.7)，等到的就是30了 37 | * 38 | * ·提升 39 | * ·对基本数据类型执行运算，只要类型比int小(即char，byte，short)，那么在运算之前，这些值会自动转换成int。这样一来，生成的结果就是int类型的 40 | * ·如果想把结果赋值给较小的类型，就必须使用类型转换(可能会出现信息丢失) 41 | * ·通常，表达式中出现最大的数据类型决定了表达式最终结果的数据类型。一个float与double进行运算，结果就是double(double的数据类型大，double可以容纳float，int的数据类型小) 42 | * 如果将一个int和long值相加，则结果为long(long可以包含int了) 43 | * 44 | * 45 | * ·float 与 double 的区别 46 | * ·float是单精度浮点数，内存分配4个字节，占32位，有效小数位6-7位 double是双精度浮点数，内存分配8个字节，占64位，有效小数位15位 47 | * ·java中默认声明的小数是double类型的，例如double = 4.0 。如果float = 4.0 就会报错，需要使用下面的写法:float = 4.0f或者float x = (float)4.0 48 | * 其中4.0f后面的f只是为了区别double，并没有其他的意义。 49 | * ·对于编程人员来收，double对float的区别试试：double具有更高的精度，但是double消耗的内存是float的两倍，且double运行的效率比float慢 50 | * 51 | * ·整型byte,short,int,long取值范围大小 (这几个都是整数型，上面两个是小数型) 52 | * ·byte的取值范围最小 2的7次方 -1 。(-127到127) 53 | * ·short 2的15次方-1。（-32767到32767） 54 | * ·int 2的31次方－1 。 55 | * ·long 2的63次方-1。 56 | * 57 | */ 58 | 59 | public static void main(String[] args) { 60 | charToInt(); 61 | 62 | 63 | //前缀式与后缀式的区别 64 | increment(); 65 | 66 | 67 | //测试对象的等价性 68 | objectEqual(); 69 | objectEqual2(); 70 | 71 | //注意数值过界 72 | overFlow(); 73 | 74 | /* 75 | * 练习 76 | */ 77 | PassObject passObject; 78 | Dog dog; 79 | ObjectG objectG; 80 | } 81 | 82 | private static void charToInt() { 83 | char a = 'a'; 84 | int b = a; 85 | System.out.println(b); 86 | char c = '1'; 87 | int d = (int) c; 88 | System.out.println(d); 89 | } 90 | 91 | private static void increment() { 92 | int i = 1; 93 | int a = ++i; 94 | System.out.println("前缀式是先进行运行，再将赋值给a，a=" + a); 95 | int j = 1; 96 | int b = j++; 97 | System.out.println("后缀式是先进行赋值给a，再进行运行，b=" + b); 98 | } 99 | 100 | //测试对象的等价性 101 | private static void objectEqual() { 102 | Integer n1 = new Integer(47); 103 | Integer n2 = new Integer(47); 104 | /* 105 | * == 运算符是用来比较是不是同一个对象的 106 | * 如果想比较两个对象的内容是否一样，那么就要使用所有对象都适用的方法equals()。但是这个方法不适合于基本类型，基本类型使用==和！=即可。 107 | */ 108 | System.out.println(n1 == n2); 109 | System.out.println(n1 != n2); 110 | //equals()方法是用来比较两个对象的内容是不是一样的 111 | System.out.println(n1.equals(n2)); 112 | } 113 | 114 | private static void objectEqual2() { 115 | Value v1 = new Value(); 116 | Value v2 = new Value(); 117 | v1.i = v2.i = 100; 118 | System.out.println(v1.equals(v2)); 119 | /* 120 | * 这次令人费解，结果又是false，这是由于equals()的默认行为是比较引用，所以最好在自己的新类中覆盖equals()方法，。 121 | * 上一个之所以是true是因为，大多数的java类库都实现了equals()方法，以便用来比较对象的内容，而不是比较对象的引用 122 | */ 123 | } 124 | 125 | 126 | //注意数值过界 127 | private static void overFlow() { 128 | int big = Integer.MAX_VALUE; 129 | System.out.println("big:" + big); 130 | /* 131 | * 如果两个足够大的int值执行乘法运算，结果就会溢出，等到的就不是你想要的结果了。这说明java好，但也没有那么好 132 | */ 133 | int biggger = big * 2; 134 | System.out.println(biggger); 135 | } 136 | 137 | 138 | } -------------------------------------------------------------------------------- /04 第四章.java: -------------------------------------------------------------------------------- 1 | public class 第四章 { 2 | 3 | /* 4 | * 第四章：控制流程 5 | * ·迭代： 6 | * ·while，do-while和for用来控制循环，有时将它们划分为迭代语句。语句会重复执行，直到起控制作用的布尔表达式等到"假"的结果为止。 7 | * ·java有多个关键字表示无条件分支 8 | * ·return用途有两个方面 9 | * ·指定一个方法返回的值 10 | * ·会导致当前方法的退出 11 | * ·break和continue：在任何的迭代语句的主体部分，都可以使用break和continue控制循环的流程。 12 | * 其中，break用于强行退出循环，而continue则停止执行当前的迭代(停止执行continue语句下面的代码)，然后退回循环起始处，开始下一次迭代 13 | * ·goto：java中没有goto。然而，java也能完成一些类似于跳转(goto)的方法，结合break和continue结合使用。 14 | * 标签是后面跟有冒号的标识符，就像下面这样 labell1: 15 | * 在java中，标签器作用的唯一的地方刚好是在迭代语句之前。"刚好之前"的意思表明，在标签和迭代之间置入任何语句都不好。 16 | * 而在迭代之前设置标签的唯一理由是：我们希望在其中嵌套另一个迭代或者开关。这是由于break和continue关键字通常只中断当前循环，随标签一起使用，它们就会中断循环，直到标签的地方 17 | * 例如： 18 | * labell1： 19 | * outer-iteration{ 20 | * inner-iteration{ 21 | * break;//中断内部循环，跳到外部循环 22 | * continue;//使执行点移到内部迭代的起始处 23 | * continue labell1;//同时中断内部迭代和外部迭代，直接转到labell1处，随后，它实际上上市继续迭代的过程，从外部迭代开始 24 | * break labell1;//同时中断内部和外部迭代，直接转到labell1处，但不重新进入迭代，实际上是中止两个迭代 25 | * } 26 | * } 27 | */ 28 | 29 | public static void main(String[] args) { 30 | labellWhile(); 31 | 32 | /* 33 | * switch(只能支持整数) 34 | * ·switch有时被划为一种选择语言，根据整数表达式的值，switch语句可以从一系列代码中选出一段去执行。格式如下 35 | * switch(integral-selector) {//integral-selector这个表达式产生的只能是整数 36 | * case integral-value1 : statement; break; 37 | * case integral-value1 : statement; break; 38 | * case integral-value1 : statement; break; 39 | * //... 40 | * default: statement; 41 | * } 42 | * ·其中integral-selector(只支持整数)是一个能产生整数的表达式，switch将表达式的结果与每个integral-value进行比较。相符，执行对应的语句，没有相符，执行default语句。 43 | * case语句中的break是可选的，如果省略break，会继续执行后面的case语句，知道遇到break为止。 44 | * ·注意：default后面不用显示配置break(显示配置也可以)，默认会break。 45 | */ 46 | } 47 | 48 | private static void labellWhile() { 49 | int i = 0; 50 | outer: 51 | while (true) { 52 | System.out.println("Outer while loop"); 53 | while (true) { 54 | i++; 55 | System.out.println("i=" + i); 56 | if (i == 1) { 57 | System.out.println("continue"); 58 | continue;//跳到内部循环的头部(即从i++开始执行) 59 | } 60 | if (i == 3) { 61 | System.out.println("continue outer"); 62 | continue outer;//跳转到outer的位置。重新进入外部循环 63 | } 64 | if (i == 5) { 65 | System.out.println("break"); 66 | break;//跳出内部循环，从System.out.println("Outer while loop");开始执行， 67 | } 68 | if (i == 7) { 69 | System.out.println("break outer"); 70 | break outer;//调出到outer标签(即外部循环)，不再进入外部循环 71 | } 72 | } 73 | /* 74 | * ·一般的 continue会退回最内层循环的开头(顶部)，并继续执行 75 | * ·带标签的continue会到达标签的位置，并重新进入紧接在那个标签后面的循环 76 | * ·一般的break会中断并跳出当前循环 77 | * ·带标签的break会中断并跳出标签所指的循环，并不会重新进入循环 78 | */ 79 | } 80 | } 81 | 82 | } 83 | -------------------------------------------------------------------------------- /05 第五章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.*; 2 | 3 | public class 第五章 { 4 | 5 | /* 6 | * 第五章：初始化与清理 7 | * ·构造器是一种特殊类型的方法，因为它没有返回值。这与返回值为空明显不同(new表达式确实返回了新建对象的引用，但构造器本身并没有返回值) 8 | * ·方法重载：方法名相同，形参不同的 方法(构造器也是方法)。 9 | * ·如果传入的参数类型 小于 声明的参数类型(精度大的参数类型就大double>float>int)，传人的参数类型就会被提升(对实际的数值是没有影响的) 10 | * char类型略有不同，如果没法找到char类型的参数方法，就会把传人的char直接提升为int(假如你把一个char类型传人，而刚好也有接受int参数的方法) 11 | * ·如果传人的实际参数大于声明的，编译器就会出现一个错误。(例如传人的参数是double类型，但是方法要接受的是int类型的，这个时候就会报错)，必须进行类型显式配置类型转换 12 | * ·不能以返回值区分重载方法 13 | */ 14 | 15 | 16 | public static void main(String[] args) { 17 | acceptFloat(); 18 | 19 | 20 | /* 21 | * this关键字 22 | * ·this只能方法的内部使用，表示对"调用方法的那个对象"的引用。 23 | */ 24 | 25 | 26 | 27 | /* 28 | * 清理:终结处理和垃圾回收 29 | * ·垃圾回收器只知道释放那些经过由new分配的内存。(但是有一些内存是垃圾回收器无法清理的，例如清理一个int)。 30 | * 假设你的对象(并非使用new)获得了一块"特殊"的内存区域。 31 | * 由于你的垃圾回收器只知道回收new分配的内存，所以它不知道该如何释放该对象的这块"特殊"内存。 32 | * 为了应对这种情况，java允许在类中定义一个名为finalize()的方法。它的工作原理是这样的: 33 | * 一旦垃圾回收器准备好释放对象占用的空间，将首先调用finalize()，并在下一次垃圾回收时做一些重要的工作。 34 | * ·垃圾回收只与内存有关 35 | * 使用垃圾回收器的唯一原因是为了回收程序不再使用的内存。所以对于与垃圾回收有关的任何行为来说(尤其是finalize方法)，它们也必须同内存及其回收有关。 36 | * ·finalize()的用途何在? 37 | * 是不是意味这对象中含有其他的对象(当垃圾回收器工作的时候，就没有回收到对象里面的特殊对象)，finalize()就应该明确释放那些特殊的对象? 38 | * 答案是否定的。 39 | * 无论对象是怎么创建的，垃圾回收器都会负责释放对象占据的所有内存。(所以上面的担心是多余的) 40 | * 这就对finalize()的需求限制到一种情况：即是通过某种创建对象方式 以外的方式 为 对象分配内存 的情况 。但是java中一切都是对象，这种情况是怎么回事。 41 | * 这种情况主要发生在使用"本地方法"的情况下，本地方法是一种在java中调用非java代码的方式。本地方法主支持c/c++。在非java代码中，也许会调用c的malloc函数来分配内存空间， 42 | * 而且如果没有调用free()函数，则内存就得不到释放，从而造成内存泄漏。因为free()是c/c++中函数，所以需要在finalize()中用本地方法调用它。 43 | * ·无论是"垃圾回收"还是"终结"，都不能保证一定会发生。如果java虚拟机没有面临内存耗尽的情形，它是不会浪费时间去执行垃圾回收以恢复内存。(一直监控垃圾，和垃圾回收需要大量的成本) 44 | * ·终结条件 45 | * 通常，不能指望finalize()帮你进行"清理"工作，必须创建其他的清理工作。在垃圾回收对象时，会调用一次finalize()方法(也许不会被调用)，所以可以在垃圾回收前判断一下，是否可以安全回收了。 46 | * 当你对某个对象不在感兴趣了--也就是可以被清理了，这个对象应该处于某种状态，使它占用的内存可以被安全的释放。 47 | * 例如，要是对象打开了一个文件，在垃圾回收时，程序员应该关闭这个文件。 对象是否可以安全的被回收(也就是对象存在很难看见的缺陷)。这时就可以使用finalize()来发现这种缺陷--尽管它并不是 48 | * 总被调用(只有内存耗尽才会被调用，或是手动)。 49 | * 一个例子:示范了finalize()可能的使用方式 50 | */ 51 | checkIn(); 52 | 53 | /* 54 | * 垃圾回收器如何工作 55 | * ·在以前的编程语言中，在 堆 上分配对象的代价十分高昂，因此读者自然会觉得java中所有的对象(基本类型除外)都在 堆 上分配的方式也非常高昂。 56 | * 然而，垃圾回收器对于提高对象的创建速度，却有明显的效果。听起来很奇怪--存储空间的释放竟然会影响存储空间的分配，但这确实是某些java虚拟机的工作方式。 57 | * 这就意味着，java从 堆 分配速度，可以和其他语言从 堆栈 上分配空间的速度相媲美。 58 | * 59 | * ·可以把C++里的 堆 想象成一个院子，里面每个对象都负责 管理自己的地盘，一段时间后，对象可能被销毁，但地盘必须加以重用(这里要消耗成本)。 60 | * 在java堆中，堆的实现是截然不同:它更像一个传送带，每分配一个新的对象，它就往前移动一格。这就意味着对象存储空间分配速度非常快 61 | * java的 堆指针 只是简单的移动到没分配的区域，其效率比得上C++在 堆栈 上分配空间的效率。 62 | * 63 | * ·其实，java中的堆并不完全像传送带那样的工作，会导致频繁的内存页面调度，会影响性能，当创建的对象足够多的时候，最终内存耗尽。 64 | * 其中的秘密就是不会像真的传送带那样，指针一直的往后移动，在于垃圾回收器的介入。当它工作时，将一边回收空间，一边将 堆 中的对象紧凑排列，这样指针可以更靠近传送带的开始处(就不会一直往后指) 65 | * 66 | * ·垃圾回收器的依据思想是： 67 | * 对任何"活"的对象，一定能最终追溯到其存活在 堆栈 或 静态存储区 之中的引用。这个引用链可能会穿过数个对象层次。 68 | * 从 堆栈 和 静态存储区 遍历所有的引用，就能找到"活"的对象。对于发现的每个引用，跟踪它引用的对象，然后找到此对象包含的所有引用(如果存在的话)。 69 | * 如此反复进行，直到"存在于 堆 和 静态存储区 中的所有引用"所形成的网络全部被访问到为止(所有引用都能找到对象)。就是根据 堆栈 中的引用将 对应的对象全部查找出来。 70 | * 71 | * 在这种方式下，java采取一种 "自适应"的垃圾回收技术 。至于如何找到存活的对象，取决与java虚拟机的实现(上面也是一种方式)。 72 | * 有一种做法名为 "停止-复制" 。显然这意味着，先把当前运行的程序暂停下来 (所以它不属于后台回收模式)，然后把活的对象(取决于java虚拟机实现，有很多种方式)从当前 堆 复制到另一个 堆 中。 73 | * 没有被复制的全部都是垃圾。当对象被复制到新堆时，它们是一个挨着一个的，所以新堆保持紧密排列。 74 | * 75 | * 当把对象从一处搬到另一处时，所有引用的指向必须修正。对于这种所谓的"复制式回收器"而言，效率会降低。这里有两个原因 76 | * ·第一个:有两个堆，然后在这两个堆之间来回倒腾，需要很多时间。 77 | * ·第二个问题在于复制，程序进入稳定状态之后，可能只会产生少量的垃圾，复制器仍然将所有的内存从一处复制到另一处，这要很大的成本以及浪费。 78 | * 为了避免这种情况，java虚拟机会进行检查：要是没有垃圾产生，就会转换到另一种工作模式("自适应")。这种模式称为"标记-清扫"，速度很慢，但当只产生少量垃圾时甚至没有垃圾产生，它的速度就很快了。 79 | * ·"标记-清扫"所依据的思路同样是从 堆栈 和 静态存储区 出发，遍历所有的引用，找出与之对应的 "活"的对象，就会给这个对象一个标记，这个过程不会回收任何对象。 80 | * 只有全部标记工作完成的时候，清理工作才进行，没有被标记的对象将被释放，不会发生任何的复制操作。所以剩下的 堆 是不连续的。(不像上面的"停止-复制"模式，等到的 堆 是连续的) 81 | * · 82 | * 83 | * ·内存分配以较大的"块"为单位，如果对象较大就会，它就会占用单独的块。严格来收，"停止-复制"要求在释放旧有对象之前，必须先把所有存活对象从 旧堆 复制到 新堆，这就导致大量的复制行为。 84 | * 每个块都用相应的代数来记录它是否还存活。通常，如果块在某处被引用，其代数会增加。垃圾回收装置会定期进行清理动作--大型对象仍然不会被复制(只是其代数增加)，内含小型对象的那些块则被复制并整理。 85 | * java虚拟机进行监视，如果所有对象都很稳定，回收效率低的话，就会切换到"标记-清扫"模式，如果碎片很多就会切换到"停止-复制"模式。这就是"自适应"技术。 86 | * 87 | * ·java虚拟机中有很多附加的技术用以提升速度。尤其是与加速器操作有关，被称为"即时"编译技术。这种技术可以将程序全部或部分翻译为本地机器码(这本是java虚拟机的工作)，程序运行速度因此而提升。 88 | */ 89 | 90 | 91 | /* 92 | * 成员初始化 93 | * ·构造器初始化: 94 | * ·初始化顺序:在构造参数调用之前，所有的变量(实例变量)都被初始化了，变量定义的先后顺序决定了初始化的顺序(不包含局部变量)，即使变量定义散步与方法定义之间， 95 | * 它们仍然会在任何方法(包含构造器)被调用之前得到初始化。 96 | */ 97 | OrderOfIn orderOfIn;//构造器初始化可以点进去看 98 | /* 99 | * ·静态数据的初始化(static关键字)： 无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，只能作用于域。 100 | * 如果一个域是静态的基本类型域，且没有初始化，那就会获得基本类型的初值，如果是对象，初值是null 101 | * 静态初始化只有在必要的时刻才会进行，如果不创建该类型的对象，或者是通过类名访问，那么静态的变量就永远不会被初始化，当被初始化了，静态对象不会再次被初始化 102 | * 初始化的顺序是先"静态"后"非静态" 103 | * 104 | */ 105 | StaticWord staticWord;//点进去 106 | /* 107 | * ·显式的静态初始化：静态块。也是首次创建所在的对象的时候初始化，只初始化一次 108 | * static{ 109 | * int i = 1; 110 | * } 111 | * ·非静态实例化初始化：看起来与 静态初始化字句 差不多，只不过是少了static关键字。这种语法对于支持"匿名内部类"的初始化时必须的。 112 | * { 113 | * int i = 1; 114 | * } 115 | */ 116 | 117 | 118 | /* 119 | * 可变参数列表 120 | * ·在SE5.0之前，要想使用可变参数类型是 要创建以Object数组为参数的方法，并像下面这样调用 121 | * ·注意:可变参数要放在参数列表中的最后一个 122 | * 例如:h(int a,Integer... args) 123 | * 而不能 h(Integer... args,int a) 124 | */ 125 | printArray(new String[]{}); 126 | f(); 127 | 128 | 129 | /* 130 | * ·有了可变参数，就再也不用显示地编写数组语法，当你指定参数时，实际上会为你创建一个数组。你获得的仍然是一个数组 131 | */ 132 | varargType(); 133 | 134 | 135 | /* 136 | * ·可变参数列表使得重载过程变得复杂 137 | * 在每一个中情况，编译器都会使用自动包装机制来匹配重载的方法，然后调用最明确的方法 138 | */ 139 | testH(); 140 | 141 | 142 | /* 143 | * 枚举类型 144 | * ·在SE5.0添加了一个看似很小的特征，即关键字enum关键字(方便，安全) 145 | * ·尽管enum看起来像一种新的数据类型，但是这个关键字只是为enum生成对应的类是让编译器产生了某些编译器行为。事实上，enum确实是一个类，并且具有自己的方法。 146 | */ 147 | enumType(); 148 | 149 | 150 | /* 151 | * enum有一个特别实用的特征，即它可以在switch语句内使用 152 | * ·由于switch是要在有限的可能值集合中进行选择，因此它与enum正是绝佳组合 153 | * ·在SE5.0之前，你需要花费大量的工作才能保证与枚举等价的安全可用性。 154 | */ 155 | enumType2(); 156 | 157 | } 158 | 159 | private static void enumType2() { 160 | switch (Spiciness.MEDIUM) { 161 | case MEDIUM: 162 | System.out.println("MEDIUM"); 163 | break; 164 | default: 165 | System.out.println("default"); 166 | break; 167 | } 168 | } 169 | 170 | private static void enumType() { 171 | Spiciness s = Spiciness.MEDIUM;//如何定义一个枚举类型可以点进去看 172 | System.out.println(s.toString()); 173 | System.out.println(s.ordinal());//编译器还会ordinal()方法，用来表示某个enum常量的声明顺序 174 | /* 175 | * 还可以遍历进行遍历 176 | */ 177 | for (Spiciness sp : Spiciness.values()) { 178 | System.out.println(sp + ",ordinal" + sp.ordinal()); 179 | } 180 | } 181 | 182 | private static void testH() { 183 | h('a','b'); 184 | h(1); 185 | // h(); 186 | /* 187 | * 在每一次。编译器都会使用自动包装机制来匹配重载的方法，然后调用最明确匹配的方法 188 | * 但是在使用0参数调用h()时，编译器就无法知道使用的是哪一个方法了，编译器就会出现一个错误 189 | */ 190 | } 191 | 192 | private static void varargType() { 193 | new VarargType();//点进去可以看可变参数的语法，以及相关的信息 194 | new AutoboxingVarargs(); 195 | } 196 | 197 | private static void f() { 198 | printArray(new Object[]{1,2,3});//这里想要 可变参数 ，就将参数封装为一个数组，再将数组传入 199 | } 200 | 201 | /* 202 | * 可变参数列表 203 | * ·在SE5.0之前，要想使用可变参数类型是 要创建以Object数组为参数的方法，并像下面这样调用 204 | * ·注意:可变参数要放在参数列表中的最后一个 205 | * 例如:h(int a,Integer... args) 206 | * 而不能 h(Integer... args,int a) 207 | */ 208 | private static void printArray(Object[] args) { 209 | for (Object ob : args) { 210 | System.out.println(ob); 211 | } 212 | } 213 | 214 | private static void checkIn() { 215 | //点击去的是一个例子，执行main方法即可 216 | new Book(true); 217 | } 218 | 219 | private static void acceptFloat() { 220 | //如果一个接受一个参数的方法，可以将精度比double低的类型传进去,里面会进行自动进行类型转换(例如将int = 4传进去会转换为4.0) 221 | int a = 4; 222 | acceptDouble(a); 223 | //但是不接受一个比自己精度低的参数，例如将接收int参数的，将一个double类型的传进去是不能的。因为这样是有可能丢失信息的 224 | double b = 4; 225 | // acceptInt(b);//例如这样编译器就会出错 226 | } 227 | 228 | private static void acceptDouble(double a){System.out.println(a);} 229 | 230 | private static void acceptInt(int a){} 231 | 232 | private static void h(Character... args){ 233 | for (Character c : args) { 234 | System.out.print(c); 235 | } 236 | System.out.println(args.getClass()); 237 | } 238 | 239 | private static void h(Long... args){ 240 | for (Long i : args) { 241 | System.out.print(i); 242 | } 243 | System.out.println(args.getClass()); 244 | } 245 | 246 | private static void h(Integer... args){ 247 | for (Integer i : args) { 248 | System.out.print(i); 249 | } 250 | System.out.println(args.getClass()); 251 | } 252 | } 253 | -------------------------------------------------------------------------------- /06 第六章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.ConnectionManager; 2 | 3 | public class 第六章 { 4 | 5 | /* 6 | * 第六章：访问权限控制 7 | * (注意：访问控制权限控制专注于 类库创建者 和 使用该库的外部使用者 之间的关系，这种关系也是一种通信方式) 8 | * ·包:库的单元 9 | * 当你编写一个java文件时候，此文件通常被称为编译单元。每个编译单元后面都要一个.java后缀。而编译单元后面可以有一个public类，该类的名称必须与文件名相同 10 | * 每个编译单元只能有一个public类，否则编译器就不会接受。如果编译单元还有别的类，那么它不能是public类，那么在包之外是无法看见这些类的，而且他们主要是为public类提供服务的。 11 | * 12 | * 如果想要将这些编译单元从属与同一个组群，就可以使用package。 13 | * 如果使用package，它必须是文件(除注释之外)的第一行程序代码，例如:package access;(包的命名规则全部使用小写字母) 14 | * 会 把package名称分解为你机器目录上的一个文件夹 ，当java程序运行并且需要加载.class文件的时候，java程序就根据目录找到.class文件并加载它。 15 | * 16 | * ·java解析器的运行过程如下： 17 | * ·首先，你要设置环境变量CLASSPATH(类文件一定要放在这得子目录下面 )，例如:CLASSPATH=.;D:\JAVA\LIB;C:DOC\JavaT(环境变量可以设置多个) 18 | * ·然后可以把类文件放在 CLASSPATH中 的任何目录之下，(就是你这类文件的绝对路径前面一段一定是 CLASSPATH 中配置有的) 19 | * ·当编译器碰到mo库(假如存在这个库)的import语句时，就会在 CLASSPATH 所指定的目录中寻找，查找指定的目录中是否存在子目录(com/mo)，然后就可以选择的导入要使用的类了。 20 | * 21 | * ·冲突：如果导入了 两个不同的库中 有名字相同 的类，就要使用指定类名:java.util.Vector v = new java.util.Vector(); 22 | * 23 | * ·定制工具类(静态地导入包) 24 | * ·用来创建自己的工具库来减少或消除重复的程序代码。在使用这种类时，可以用一个更具有可读性的静态import语句来导入。 25 | * import static com.mo.Print.*;(表示可以使用Print类中的所有方法) 26 | * 27 | * ·java的访问修饰符 28 | * ·如果不提供修饰符，默认是包访问权限，意味着当前包中的所有其他类对那个成员都有访问权限。但对于这个包之外，所有类对这个成员杀死private。 29 | * ·类控制着自己成员的访问权限。 30 | * ·成员的访问修饰符为public：无论是谁，在哪里，都可以访问该成员 31 | * ·不加修饰符是赋予成员的包访问权限(同一个包内的其他类可见)，其他包的不可见 32 | * ·继承的类，可以访问父类的protected成员(private成员不行) 33 | * ·默认包：没有给自己设定任何包的名称，java会将这样的类自动归为默认包，并给他们都赋予包访问权限(在默认包内)。 34 | * 35 | * ·private：除了本身的类，其他所有都不能访问。(就算是父类的private成员也不能访问) 36 | * ·protected：继承访问权限，子类可以访问父类protected的成员。protected成员还具有包访问权限(相同包内的其他类可以访问protected元素) 37 | * 38 | * ·类的访问权限 39 | * ·每个编译单元，只能有一个public(也可以没有，这样这个类就是包访问权限)，public类的类名要与编译单元名一样 40 | * ·类不能是private或protected。所以对于类访问权限，仅有两个选择：包访问权限和public(什么都不写就是包访问权限)。 41 | * 如果不希望其他人对该类拥有访问权限，可以将所有的构造器都指定为private，从而阻止任何人创建对象。 42 | * 可以在该类的static成员内部创建对象。例如： 43 | */ 44 | code_list_one.Lunch Lunch;//点进去 45 | 46 | 47 | /* 48 | * 练习 49 | */ 50 | ConnectionManager connectionManager;//点进去看看 51 | } 52 | -------------------------------------------------------------------------------- /07 第七章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.*; 2 | 3 | public class 第七章 { 4 | 5 | 6 | /* 7 | * 第七章：复用类 8 | * ·复用代码是java众多引人注目的功能之一 9 | * ·第一种：(组合语法)在新类中引入现有类的代码 10 | * ·第二种：继承语法 11 | * ·第三种：代理 12 | * 13 | * ·组合语法 14 | * ·toString():每一个非基本类型的对象都有一个toString()方法 15 | * · 继承语法 16 | */ 17 | Detergent d;//继承语法看这里 18 | 19 | /* 20 | * ·初始化基类 21 | * ·当你创建一个导出类对象时，该对象还包含一个基类的子对象(之所以称为基类的子对象，是因为与基本的对象还有一点区别，创建导出类时会创建基类的子对象会调用基类的构造器)， 22 | * 这个基类的子对象与你直接创建的对象是一样的，二者的区别是后者是外部的(显示写出来的)，前者是基类的子对象被包装在导出类对象的内部 23 | * ·对基类子对象的正确初始化：在构造器中调用基类的构造器来完成初始化 24 | */ 25 | Cartoon cartoon;//初始化一个导出类点进去看 26 | 27 | /* 28 | * ·初始化带有参数的构造器 29 | */ 30 | Chess chess;//初始化创建带有参数的导出类 31 | 32 | 33 | /* 34 | * ·代理 35 | * · java并没有提供对它的直接支持，这是继承与组合的中庸之道 36 | * ·将一个成员对象置于所要构造的类中(就像组合)，但是同时该类也拥有该成员对象的所有方法(与继承相似，比继承具有更大的灵活性) 37 | */ 38 | SpaceShipDelegation spaceShipDelegation;//代理类看里面 39 | 40 | 41 | /* ·结合使用组合和继承 42 | * ·既有组合又有代理 43 | * 44 | * ·名称屏蔽 45 | * ·如果java的基类拥有某个已被多次重载的方法的名称，那么在导出类 中重载一个方法(方法名一样，参数不一样)，并不会屏蔽其在基类中的任何版本。 46 | * 因此，无论是在该层或者它的基类中对方法进行定义，重载机制都可以正常工作的。 47 | */ 48 | Hide hide;//名称屏蔽:基类与重载剪不断的关系 49 | 50 | /* 51 | * ·在组合与继承之间选择 52 | * ·组合和继承都允许在新的类中放置子对象，组合是显式地这样做，而继承则是隐式地做。 53 | * ·组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形，一般情况下应该使域成为private 54 | */ 55 | 56 | /* 57 | * ·protected关键字 58 | * ·将某些事物尽可能对这个世界隐藏起来，但是允许导出类的成员去访问它们 59 | * ·访问范围： 60 | * ·导出类 61 | * ·同一个包的其他类(即包访问权限) 62 | * ·尽管可以创建protected域，但是最好的方式还是将域保持为private， 63 | */ 64 | 65 | 66 | /* 67 | * ·继承 68 | * ·"为新类提供方法"并不是继承技术中最重要的方面，最重要的方面是用来表现新类和基类之间的关系。这种类型可以用"新类是现有类的一种类型"概括。(更多的是表现出一种层次和包含的关系) 69 | * 一个例子： 70 | * ·假设有一个称为Instrument的代表乐器的基类，和一个称为Wind的导出类。由于继承可以确保基类中所有的方法在导出类中也同样有效，所以能够向基类发送的所有信息同样也可以向导出类发送 71 | * 如果Instrument类具有一个play()方法，那么Wind乐器也将同样具备。这意味着我们可以准确的说Wind对象也是一种类型的Instrument。 72 | * ·向上转型： 73 | * 由导出类转型成基类，在继承图是向上移动的。由于向上转型是从一个 较专用类型 向 较通用类型 转换，所以总是安全的(但是有可能出现导出类方法的丢失)。 74 | * 也就是说导出类是基类的一个超集，它可能比基类含有更多的方法。但它必须至少具备基类中所含有的方法。 75 | */ 76 | Wind wind;//向上转型 77 | 78 | 79 | 80 | 81 | /* 82 | * ·fianl关键字 83 | * ·根据上下文环境，java关键字final的含义存在着细微的区别，但通常它指的是"这是无法改变的" 84 | * ·不想做改变可能出于两种理由:设计或效率 85 | */ 86 | 87 | 88 | /* 89 | * ·可能使用到final的三种情况：数据，方法，类 90 | * 91 | * ·final数据 92 | * ·一个永不改变的编译时常量 93 | * ·编译器对于常量值是告知一块数据是恒定不变的，这减轻了一些运行时的负担。这类常量必须是基本数据类型，在进行定义时必须赋值。 94 | * ·一个既是static又是fianl的域只占据一段不能改变的存储空间 95 | * ·一个在运行时被初始化值，而你不希望它被改变 96 | * ·对象类型使用fianl。fianl使引用恒定不变，一旦一个fianl的 引用 被初始化指向一个对象，就无法改变该引用指向另一个对象。但是被指引的对象本身可以修改 97 | */ 98 | FinalData finalData;//final数据 99 | 100 | /* 101 | * ·空白final 102 | * ·java允许生成"空白final"，所谓空白final是指被声明为final但又未给定初值的域，虽然可以不用立即给定，但是编译器都确保final在使用前必须被初始化(就是在使用前被赋值)。 103 | * (两个地方进行赋值)必须在 域的定义处 或者每个 构造器中 用表达式对final进行赋值，这正是final域在使用前总被初始化的原因所在。 104 | */ 105 | BlankFinal blankFinal;//空白final，其实并不空白 106 | 107 | /* 108 | * ·final参数 109 | * ·java允许在参数中声明参数为final。这意味着你无法在方法中改变参数引用所指向的对象，你可以读参数，但无法修改。 110 | */ 111 | FinalArguments finalArguments; 112 | 113 | /* ·final方法 114 | * ·使用final方法的原因有两个。一个是把方法锁定，以防任何继承类修改它的含义。一个是确保在继承中使方法行为保持不变，并且不会被覆盖(重写) 115 | * ·只有在想要明确禁止覆盖时，才将方法设置为final 116 | * ·final和private关键字 117 | * ·类中的所有private方法都隐式地指定为final的。由于无法取用private方法，所以也就无法覆盖它。可以对private方法添加final修饰词，但是没有任何的意义。 118 | */ 119 | FinalOverridingIllusion finalOverridingIllusion; 120 | 121 | 122 | /* 123 | * ·final类 124 | * ·当将一个类加上final(在class前面加)，就表明你不打算继承该类，而且也不允许别人这样做。 125 | * ·这样做是处于两种考虑，一是出于考虑，你对该类的设计永不需要任何的改动，或者出于安全的考虑，你不希望它有子类。 126 | * ·无论类是不是被定义为final，相同的规则都适用于定义final域(就是不能被更改，参考上面final数据的规则)。 127 | * 然而，由于final类禁止继承，所以final类中的所有方法都隐式指定为final的，因为无法覆盖他们。可以给方法添加final，但是没有任何的意义。 128 | */ 129 | Jursaaic jursaaic;//final类 130 | 131 | 132 | /* 133 | * ·初始化及类的加载 134 | * ·一般来说，"类的代码是在初次使用时才加载"，这通常加载是指发生于创建类的第一个对象时，当访问static域或者是static方法时也会被加载。 135 | * ·构造器也是static方法，只是没有显式的写出来。更准确的说，类是在其任何static成员被访问时才加载。 136 | */ 137 | 138 | /* 139 | * ·继承与初始化 140 | * ·了解包括继承在内的初始化全过程，以对所发生的一切有个全局性的把握。 141 | */ 142 | Beetle beetle;//一个有 继承其他类 的类 是如何初始化的 143 | 144 | /* 145 | * 练习 146 | */ 147 | public void test1() { 148 | new ObjectH(); 149 | } 150 | 151 | public void test2() { 152 | new Amphibian(); 153 | } 154 | 155 | public void test3() { 156 | new FinalAndStatic(); 157 | }//final与final+static 158 | 159 | public void test4() { 160 | new EmptyFinal(new Objc()); 161 | }//空的final 162 | 163 | public void test5() { 164 | new ObjectI(); 165 | } 166 | } 167 | -------------------------------------------------------------------------------- /08 第八章.java: -------------------------------------------------------------------------------- 1 | import code_list_one.*; 2 | 3 | public class 第八章 { 4 | /* 5 | * 第八章:多态 6 | * ·三大基本特征：数据抽象，继承，多态 7 | * ·多态的作用是：消除类型之间的耦合关系。不但能改善代码的结构组织和可读性，还可以创建可扩张的程序。 8 | * ·多态方法调用允许一种类型表现出于其他相似类型之间的区别，只要它们都是从同一个基类中导出的。 9 | */ 10 | 11 | /* 12 | * ·在论向上转型 13 | * ·对象既可以以自己本身的类型使用，也可以作为它的基类使用 14 | * ·把一个对象实例用它的基类指引(基类类型作为引用)被称为向上转型。因为在继承树的画法中，基类是放置在上方的。 15 | */ 16 | Music music; 17 | 18 | /* 19 | * ·忘记对象的类型 20 | * ·接着上面的例子，如果让tune()方法接受一个Wind1引用会更为直观。但是这样做的话，就需要为系统内Instrument1的每一种类型都编写一个新的tune()方法 21 | * ·现在再加入Stringed和Brass这两种乐器 22 | */ 23 | Music2 music2; 24 | 25 | /* 26 | * ·转机 27 | * ·看一个tune方法 28 | * public static void tune(Instrument i) { 29 | * i.play(); 30 | * } 31 | * ---这里接受Instrument引用的对象，但是编译器是怎么知道Instrument引用指向的是Wind1，Stringed类型还是其他类型 32 | * 因为Wind1，Stringed都有一个play方法，编译器是不知道调用的是哪一个对象的play方法。 33 | * 34 | * ·方法调用绑定 35 | * ·将一个方法与一个方法主体(这里应该是指对象)关联起来被称为绑定 36 | * ·在程序执行前进行绑定，叫前期绑定 37 | * ·当编译器只有一个Instrument引用，它无法知道调用的是哪个方法。解决办法就是后期绑定 38 | * ·后期绑定： 39 | * 有一种机制，可以在运行时判断对象的类型，根据对象的类型进行绑定(其实在对象中已经安置了类型的信息，尽管已经向上转型了)，从而调用恰当的方法 40 | * 也就是说，编译器一直不知道对象的类型，但是 方法调用机制 能找到正确的方法体，并加以调用。 41 | * ·java中除了static方法和final方法(private方法也属于final)之外，其他 所有的方法 都是 后期绑定 的。这意味着通常情况下，我们不必判定是否应该进行后期绑定--它会自动发生的 42 | * 所以使用final会生成更有效的代码(其实大多数整体性能不会有什么改观)。所以最好是设计来决定是否使用final，而不是性能 43 | */ 44 | 45 | 46 | /* 47 | * ·产生正确的行为 48 | * ·知道java的所有方法都是后期绑定实现多态，我们就可以编写 只与 基类 打交道的代码(划重点) 49 | */ 50 | Shapes shapes; 51 | 52 | /* 53 | * ·可扩展性 54 | * ·有了多态机制，可根据自己的需求对系统添加任意多的类型，而不用更改基类的代码，只与基类接口通信(服务端原来的代码也不用更改，因为是针对基类进行编程)。 55 | * 这样的程序是可扩展的，因为可以在通用的基类继承出新的类型，增加一些新的功能。那么针对基类编程的不需要有任何的改动 56 | * 57 | */ 58 | 59 | /* 60 | * ·缺陷：不能"覆盖"私有方法 61 | * ·由于private方法被自动认为是final方法，而且对导出类是屏蔽的，private方法是不能被重载的，只有非private方法才能被重载 62 | */ 63 | PrivateOverride privateOverride; 64 | 65 | /* 66 | * ·缺陷：域与静态方法不存在多态 67 | * 如果某个类是静态的，它的行为就不具有多态性，静态方法是类，而并非与单个的对象所关联 68 | */ 69 | FieldAccess fieldAccess;//域不存在多态 70 | StaticPolymorphism staticPolymorphism;//静态方法不存在多态 71 | 72 | /* 73 | * ·构造器和多态 74 | * ·尽管 构造器不具有多态性(它们实际上是static方法，只不过该static声明是隐式的)，但还是非常有必要理解构造器怎样通过多态在复杂的层次结构中运行 75 | * ·对象构造过程 76 | * 1.调用基类的构造器,这个步骤会不断地反复递归下去。首先调用这种层次结构的根，然后是下一层导出类，直到最底层的导出类 77 | * 2.按声明顺序调用成员的初始化方法 78 | * 3.调用导出类的构造器 79 | */ 80 | Sandwich sandwich;//对象构造过程的调用顺序 81 | 82 | /* 83 | * ·继承与清理 84 | * ·通过组合和继承的方式来创建新类时，永远不用担心对象的清理问题，垃圾回收器会处理。 85 | * ·但是有一些情况真的需要清理的话(例如是调用c/c++之类的)，那么就要为新类创建dispose()方法。由于继承的缘故，在做清理工作时，必须在导出类中覆盖dispose()方法， 86 | * 如果导出类也存在需要清理的资源(如果你没有覆盖，基类不可你能帮你清理到的)。同时在导出类的dispose()方法中，必须调用基类的dispose()方法(使用super.dispose()) 87 | * 因为导出类清理完，必须调用基类的清理工作(因为在导出类创建时，基类的对象就已经创建了，如果你不去显式的配置调用基类，那么基类的清理工作就得不到清理) 88 | */ 89 | Frog1 frog1;//继承与清理 90 | 91 | /* 92 | * ·构造器内部的多态方法的行为(基类构造器中有一个方法，导出类覆盖了，把该方法放在基类的构造器中 调用的是导出类的重写的方法，因为多态的存在) 93 | * ·如果调用基类的构造器，它的内部一个动态绑定方法，就要用到那个方法被覆盖之后的定义。 94 | * 然而，调用的效果是令人难以意料的，因为被覆盖的方法是在导出类对象还没有构造之前就被调用(对象都还没有创建，对象的方法就被调用了，你能想象到吗)。 95 | * 96 | * 另：·构造器只是构建对象过程的一个步骤(构建对象还有成员变量初始化..等等)。构造器只是构建对象过程的最后一个步骤，调用构造器之后对象就被创建了。 97 | * 98 | * ·初始化过程 99 | * ·在其他任何事物发生之前，将分配给对象的存储空间初始化为二进制的零 100 | * ·调用基类的构造器。(下面例子中，调用基类构造器中调用了覆盖后的draw方法)。由于第一条，会发现值是1 101 | * ·按照声明的顺序初始化成员变量 102 | * ·调用导出类的构造器 103 | * ·这样做有一个好处就是：那就是所有的东西都是零了。如果是对象引用则是null，这会在排除发现问题方面有很大的帮助 104 | * 105 | * ·针对构造器内部的多态方法的发生，在编写构造器时有一条有效的准则 106 | * ·用尽可能简单的方法使对象进入正常状态，避免调用其它方法 107 | * ·构造器内唯一安全调用的方法是final方法(private也属于final)，这些方法不会被覆盖，那就不会出现多态 108 | */ 109 | PolyConstructors polyConstructors;//构造器内部的多态方法 110 | 111 | /* 112 | * ·协变返回类型 113 | * ·在SE 5.0 中添加了协变返回类型， 一句话：覆盖的方法返回值类型不一定要与基类的一样(是其导出类也可以) 114 | */ 115 | CovariantReturn covariantReturn; 116 | 117 | /* 118 | * ·向下转型与运行时类识别 119 | */ 120 | RTTI rtti; 121 | 122 | 123 | /* 124 | * 练习 125 | */ 126 | Cycle cycle; 127 | Rodent rodent; 128 | ObjectJ objectJ; 129 | } 130 | -------------------------------------------------------------------------------- /09 第九章.java: -------------------------------------------------------------------------------- 1 | import code_list_two.*; 2 | import test.Factories; 3 | 4 | public class 第九章 { 5 | 6 | 7 | /*- 8 | * 第九章：接口 9 | * ·抽象类和抽象方法 10 | * ·抽象类的目的是为它的所有导出类创建一个通用的接口。建立这个通用接口的唯一理由是：不同的子类可以用不同的方式表示此接口。 11 | * 通用接口建立起一种形式，以此表示所有导出类的的共同部分，并称为抽象基类(或者是抽象类)。 12 | * ·那么抽象类的对象就没有任何的意义了(抽象类里面没有具体的实现)，并且编译器阻止你这样做 13 | * ·java提供一个叫做 抽象方法 的机制，这种方法是不完整的，只有声明而没有方法体 14 | * abstract void f(); 15 | * ·包含抽象方法的类叫做抽象类，就算只有一个该类也必须被定义为抽象类 16 | * ·如果从一个抽象类继承，并想为创建该新类的对象，那么就必须为基类中的所有抽象方法提供具体的实现。 17 | * 如果不这样做，那么导出类也必须定义为抽象类，且编译器将会强制我们使用abstract关键字来限定这个类。 18 | * ·一个没有任何抽象方法的类也可以被定义为抽象类(这样可以阻止创建该类的对象) 19 | */ 20 | Music4 music4;//抽象类 21 | 22 | /* 23 | * ·接口(interface) 24 | * ·interface是一个完全抽象的类，根本没有提供任何具体的实现，只是提供形式(允许创建者确定方法名，参数列表和返回值类型) 25 | * ·interface不仅是一个极度抽象的类，它还允许 导出类向上转型 为 多种基类的类型 (如果一个类实现了多个接口的话) 26 | * ·创建一个接口，需要用interface来代替class。可以在interface前面加上public，不加public的话这个接口类就是包访问权限 27 | * ·接口可以创建域，但是这些域都是隐式地是static和final 28 | * ·使用implements实现接口 29 | * ·接口中的所有方法都是public，无论你有没有显式的配置出来 30 | */ 31 | 32 | /* 33 | * ·java中的多重继承 34 | * ·只能继承一个类，但可以实现多个接口。继承写在接口的前面，接口名都置于implements后面，多个接口用逗号隔开。 35 | * class A extends B implements C, D{} 36 | * ·可以继承任意多个接口，并一个类可以向上转型为多个类型，因为每一个接口都是一个独立的类型 37 | * · 38 | */ 39 | Adventure adventure;//一个类实现多个接口 40 | 41 | /* 42 | * ·通过继承来扩充接口 43 | * ·通过继承，可以通过 原有接口 的基础上 扩充一个新的接口(使用extends关键字) 44 | * ·extends多继承只适合接口继承。一般情况，extends只能继承单一类，但是可以实现多个接口。 45 | */ 46 | HorrorShow horrorShow; 47 | 48 | /* 49 | * ·组合接口时的名字冲突 50 | * ·在打算组合的不同接口中使用相同的方法名通常会造成代码可读性的混乱(比如接口A和接口B都有a方法)，请尽量避免这样做。 51 | */ 52 | ObjectF objectF; 53 | 54 | /* 55 | * ·适配接口(这里是一个设计模式，以后要看看) 56 | * · 57 | */ 58 | 59 | /* 60 | * ·接口中的域 61 | * ·放进接口中的任何域都自动是static和final的，所以接口就成为了一种很便捷的用来创建常量组的工具。(在枚举类型出现之前/SE5.0之前) 62 | * 63 | * ·初始化接口中的域 64 | * ·在接口中定义的域不能是"空final"，但是可以使用表达式来初始化 65 | */ 66 | Months months;//接口中创建常量 67 | TestRandVals testRandVals;//接口中的域 68 | 69 | /* 70 | * ·嵌套接口 71 | * ·接口可以嵌套到类或其他接口中 72 | * ·当实现某个接口时，并不需要实现嵌套在其内部的任何接口 73 | */ 74 | NestingInterfaces nestingInterfaces; 75 | 76 | /* 77 | * ·接口与工厂(工厂设计模式) 78 | * ·生成 遵循某个接口的对象 的典型方式就是工厂方法设计模式。这与直接调用构造器不同，而是直接调用方法(方法内部有创建对象的代码)， 79 | */ 80 | Factories factories; 81 | 82 | /* 83 | * 练习 84 | */ 85 | ObjectA objectA; 86 | ObjectB objectB; 87 | ObjectC objectC; 88 | ObjectD objectD; 89 | ObjectG objectG; 90 | ObjectE objectE; 91 | ObjectH objectH; 92 | 93 | } 94 | -------------------------------------------------------------------------------- /10 第十章.java: -------------------------------------------------------------------------------- 1 | import code_list_two.*; 2 | import code_list_three.A3; 3 | import test.Factories; 4 | 5 | public class 第十章 { 6 | /* 7 | * ·第十章：内部类 8 | * ·将一个类的定义放在另一个类的内部，这就是内部类 9 | * ·内部类是以一种非常有用的特征，它允许你将一些逻辑相关的类组织在一起，并控制内部类的可见性 10 | * ·内部类了解外围类，并与之通信 11 | */ 12 | 13 | /* 14 | * ·创建内部类 15 | * ·在拥有外部类对象之前是不能创建该内部类对象的，因为内部类的创建必须要有一个外部类建立连接(就比如寄养生物，如果连寄主都没有，就不存在寄养生物了) 16 | */ 17 | Parcell parcell; 18 | 19 | /* 20 | * ·链接到外部类 21 | * ·当生成一个内部类对象时，此对象与制作它的外围对象之间还有一种联系，所以它能访问其外围对象的所有成员。内部类还拥有其外围类的所有元素的访问权限 22 | * ·内部类是如何获取外围类的成员的? 23 | * ·内部类的创建必须要与某个外围类相关联的情况下才能被创建(可以通过外围类的一个方法返回一个新建的内部类)，内部类不能被单独创建(除了在外围类之内) 24 | * 当某个外围类对象创建了内部类时，此内部类就自动的获取了外围类的引用(编译器的事情)。当你在内部类要访问外围类的成员时，就会使用到这个引用 25 | * 注意：在构建内部类对象时，需要一个指向外围类对象的引用，否则创建不了内部类 26 | */ 27 | Sequence sequence; 28 | 29 | /* 30 | * ·使用.this与.new 31 | * ·如果你需要在内部类生成对外部类对象的引用，可以使用外部类的名字后面紧跟圆点和this 32 | * ·new关键字，通过外围类的对象.new 可以得到一个内部类的对象。 33 | * 例如:Outer ou = new Outer(); Outer.Inner inn = ou.new Inner(); 34 | */ 35 | DotThis dotThis;//生成外围类的引用 36 | DotNew dotNew;//new关键字 37 | Parcel parcel; 38 | 39 | /* 40 | * ·嵌套类(静态内部类)，这样的类是不需要外部类的引用的 41 | */ 42 | 43 | /* 44 | * ·内部类与向上转型 45 | * ·内部类可以实现接口，并可以 向上转型 (转换为接口类型的)。等到的对象(内部类对象)可以指向基类或者接口的引用，所以可以很方便地隐藏实现的细节 46 | */ 47 | TestParcel testParcel; 48 | 49 | /* 50 | * ·在方法和作用域内的内部类：在方法里面或者在任意的作用域内定义内部类 51 | * ·这样做主要有：想创建一个类来辅助你解决方案，但是不希望这个类是公共可用的 52 | * ·局部内部类：在方法的作用域内的创建一个完整的类 53 | */ 54 | Parcel5 parcel5;//局部内部类：在方法里面定义的一个类 55 | Parcel6 parcel6;//这也是一个局部内部类，是定义在方法的if语块里面的 56 | 57 | /* 58 | * ·匿名内部类 59 | * ·return new A() {} : 创建一个继承自A类(A可以是一个抽象类，具体类，或者是接口)的匿名类的对象 60 | * ·如果你定义的内部类，这个内部类需要使用在外部定义的对象(通过参数传入)，那么编译器会要求引用是final 61 | * · 62 | */ 63 | Parcel7 parcel7;//匿名类 64 | Parcel7b parcel7b;//跟上面的匿名类效果是一样的，只不过是展开写了 65 | Parcel9 parcel9;//匿名使用了在外部定义的对象(通过参数传入)，就要将参数定义为final(在方法签名那定义) 66 | AnonymousConstructor anonymousConstructor;//匿名类没有构造器，new A(i)[} 会将参数传递给基类的构造器 67 | 68 | /* 69 | * ·再访工厂方法 70 | */ 71 | Factories fact; 72 | //单一的工厂模式 73 | ObjectO objectO; 74 | 75 | /* 76 | * ·嵌套类 77 | * ·如果不需要内部类对象与外围类对象之间有联系，那么可以将内部类声明为static。这通常称为嵌套类 78 | * ·嵌套意味着：1.创建嵌套类的对象，并不需要其外围类的对象 2.不能从嵌套类对象中访问非静态的外围类对象 79 | * ·普通内部类不能有static字段和方法 也不能包含嵌套类，但是嵌套类可以包含这些东西。嵌套类也没有this引用(内部类使用外围类类名.this可以得到外围类的引用) 80 | * 81 | * ·接口中的嵌套类 82 | * ·如果你想创建某些公共代码，使它们可以被某个接口的所有不同实现所共用，那么使用接口内部的嵌套类会显示得很方便 83 | * ·嵌套类可以成为接口中的一部分(该嵌套类还可以实现外围接口)。放在接口中的任何类都会成为public和static(所以在接口中定义嵌套类不用显式的声明为static) 84 | */ 85 | Parcel11 parcel11;//嵌套类的定义 86 | ClassInInterface classInInterface;//接口中的嵌套类 87 | 88 | /* 89 | * ·一个内部类被嵌套多少层不重要--它都能透明地访问所有它所嵌入的外围类的所有成员 90 | */ 91 | MultiNestingAccess multiNestingAccess; 92 | 93 | /* 94 | * ·为什么使用内部类 95 | * ·一般来说，内部类继承某个类或者实现某个接口，内部类的代码操作的是创建它外围类的对象。所以可以认为内部类提供了某种进入其外围类的窗口 96 | * ·内部类非常灵活 97 | * ·比如，外围类需要一个实例要实现某个接口的，但是外围类又不是总是需要这个接口，选择用外围类去实现这个接口的话并不是一种很好的选择 98 | * 这个时候选择用内部类去实现该接口 返回一个实现了某个接口的对象的话就会变得非常之灵活。 99 | * ·又比如：必须在一个类中已某种方式实现两个接口。由于接口的灵活性，你有两种选择：使用单一的类去实现，或者使用内部类 100 | */ 101 | MultiInterfaces multiInterfaces;//必须在一个类中已某种方式实现两个接口。由于接口的灵活性，你有两种选择：使用单一的类去实现，或者使用内部类 102 | 103 | /* 104 | * ·可以实现多重继承(需要继承的基类都是抽象的或者具体的，而不是接口)，那就只能使用内部类才能实现多重继承 105 | */ 106 | MultiImplementation multiImplementation; 107 | 108 | /* 109 | * ·内部类的继承 110 | */ 111 | InheritInner inheritInner; 112 | 113 | /* 114 | * ·局部内部类 115 | * ·可以在代码块里创建内部类，典型的方式是在一个方法体的里面创建，局部内部类不能有访问修饰符，因为它不是外围类的一部分。但是它可以访问当前代码块的常量，以及外围类的所有 116 | */ 117 | LocalInnerClass localInnerClass; 118 | 119 | /* 120 | * 练习 121 | */ 122 | Outer outer; 123 | ObjectI objectI; 124 | Outer1 outer1; 125 | ObjectJ objectJ; 126 | A3 a3; 127 | ObjectK objectK; 128 | ObjectL objectL; 129 | ObjectM objectM; 130 | ObjectN objectN; 131 | ObjectQ objectQ; 132 | ObjectR objectR; 133 | ObjectS objectS; 134 | 135 | } 136 | -------------------------------------------------------------------------------- /11 第十一章.java: -------------------------------------------------------------------------------- 1 | import code_list_two.*; 2 | 3 | public class 第十一章 { 4 | 5 | /* 6 | * ·第十一章：持有对象 7 | * ·容器：可以根据你添加进来的对象数量，动态的扩充容器的大小。与数组进行比较就是 数组 一旦被初始化长度，就不能改变其大小了。(容器也可以叫集合类) 8 | * ·基本的容器类型有：List,Set,Queue和Map。容器提供了完善的方式来保持对象 9 | * ·Set：保存的对象不能重复 10 | * ·Map：可以将两个对象关联起来(键值对) 11 | */ 12 | 13 | /* 14 | * ·容器的基本概念 15 | * --java容器类类库的用途是"保存对象"，并将其划分为两个不同的概念 16 | * ·Collection：一个独立元素的序列。 17 | * ·List：必须按照插入的顺序保存元素 18 | * ·Set：不能有重复的元素 19 | * ·Queue：按照排队规则来确定对象产生的顺序 20 | * ·Map：一组成对的"键值对"对象，允许你使用 键(键是你自己定义的) 来查找值。 21 | */ 22 | 23 | /* 24 | * ·Collection 25 | * --List 26 | * --Set 27 | */ 28 | SimpleCollection simpleCollection; 29 | 30 | /* 31 | * ·添加一组元素进入容器 32 | * ·在java.util包中的Arrays和Collection类中都有很多实用方法，可以向一个Collection对象添加一组元素 33 | * ·Arrays.asList()方法接受一个数组或者是一个用逗号分隔的元素列表，并将其转化为一个List对象 34 | */ 35 | AddingGroups addingGroups; 36 | 37 | /* 38 | * ·与接口打交道 39 | */ 40 | ObjectP objectP; 41 | 42 | /* 43 | * ·java容器类库中的两种主要类型是，它们的区别在于容器中每个"槽"保存的元素个数 44 | * ·Collection在每个槽中只能保存一个元素 45 | * 这类容器包含：List，Set，Queue---(List容器的元素是有顺序的，Set容器的元素不允许重复，Queue只允许在容器的一端插进，另一个端删除) 46 | * ·Map在每个"槽"内保存了两个对象，键值对 刚好是两个对象。 47 | * 这类容器包含：HashMap，TreeMap和ListMap--(HashMap提供了最快的查找技术，是没有顺序的。TreeMap按照比较结果的升序保存键。LinkedHashMap按照插入顺序保存键) 48 | */ 49 | 50 | /* 51 | * ·List 52 | * ·List承诺可以将元素维护在特定的序列中 53 | * ·List接口在Collection的基础上添加了大量的方法，使得可以在List的中间c插入和移除元素 54 | * 55 | * ·有两种List的类型 56 | * ·基本的ArrayList：擅长随机访问元素，但是在插入元素的比较慢 57 | * ·LinkedList：和ArrayList相反 ，随机访问元素较慢，插进元素比较快 58 | * 59 | * ·List的API: 60 | * ·contains(obj):确定某个对象是否在列表中 61 | * ·remove(obj):移除某个对象 62 | * ·indexOf(obj):某个对象引用的索引 63 | * ·subList():从容器中截取一个片段 64 | * ·containsAll(obj):obj是不是容器的一个子集 65 | * ·removeAll():移除全部元素 66 | * ·addAll(index,obj):在指定的索引值处插入 67 | * ·isEmpty():容器是否为空 68 | * ·clear():清空容器 69 | * ·toArray():将一个Collection转换为一个数组 70 | */ 71 | 72 | /* 73 | * ·迭代器 (迭代器的思想非常之强大的:接受对象容器并传递给它，从而在每个对象上都执行操作。迭代器统一了容器的访问方式)。 74 | * ···是带有List的迭代器 75 | * ·产生的背景：不重写代码就可以应用于不同类型的容器 76 | * ·迭代器就只有三个方法 77 | * ·hasNext():是否还有下一个 78 | * ·next():指针向下移动一格，返回刚刚跨过的元素 79 | * ·remove():删除上一次调用next()返回的元素。这意味着调用remove()之前必须调用一次next()。 80 | */ 81 | SimpleIteration simpleIteration;//迭代器 82 | CrossC c;//迭代器的强大之处，可以将 遍历操作 与 底层结构 分离。就是在你编写 遍历相关的代码 时，你不用关心传过来是什么类型的容器。抽象程度极高，所以说迭代器同一了对容器的访问 83 | 84 | /* 85 | * ·ListIterator:是Iterator的子类型，功能强大很多 86 | * ·只能适合与List 87 | * ·Iterator只能向前移动，ListIterator双向移动 88 | * ·可以使用set()方法替换它访问过的最后一个元素 89 | * ·通过调用listIterator()方法产生一个ListIterator(指针的位置在元素集合的开始处) 90 | * 还有一个重载的方法 listIterator(index)也产生一个ListIterator(指针的位置在index的位置)，这比Iterator灵活多了 91 | * · 92 | * 93 | */ 94 | ListIteration listIteration; 95 | 96 | /* 97 | * ·LinkedList 98 | * ·与ArrayList一样实现了基本的List接口，在插进数据比ArrayList高效(LinkedList是链表结构)，但是在随机访问时就变得比较慢了 99 | * ·具体的API也可以参考ArrayList的 100 | * ·下面还定义了其他的API 101 | * ·getFirst()和element():完全一样。都是返回列表的第一个元素，而不会移除它。如果列表为空抛出NoSuchElementException。 102 | * ·peek():与上面的一样。不同的地方就是 列表类空的时候 不会抛出异常 而是返回一个null 103 | * ·addFirst()：在列表的开始处添加元素 104 | * ·add(),addList()：是一样的，都是从列表的尾端插进元素 105 | * ·removeLast():移除列表的最后一个元素 并被移除的元素 106 | */ 107 | LinkedListFeatures linkedListFeatures; 108 | 109 | /* 110 | * ·栈(Stack) 111 | * ·"栈" 通常是指 后进先出 的容器。你不能对 栈底的元素进行操作，想要对下面的元素进行操作的话，就必须先拿掉上面的元素。有时称栈为 叠压栈。 112 | * ·LinkedList具有实现 栈 所有功能的方法(并不是说LinkedList就是一个栈，只是可以实现一个栈，LinkedList与栈没有任何关系) 113 | * 栈 的 所有 功能就是后进先出。 114 | */ 115 | Stack stack; 116 | 117 | 118 | /* 119 | * ·Set 120 | * -- Collection 121 | * --List 122 | * --ArrayList，LinkedList 123 | * --Set 124 | * --HashSet，TreeSet，LinkedHashList 125 | * --Queue(好像比较少用) 126 | * 127 | * ·不保存重复的元素 128 | * ·如果你试图将统一对象添加到Set容器中，那么它会阻止这种重复的现象 129 | * ·Set最常用的是测试 归属性，判断一个对象是否在Set容器中。正是因为这，查找就成为Set最重要的操作，因此你通常会选择一个HashSet 的实现，HashSet对快速查找进行了优化 130 | * ·Set具有与Collection一样的接口(接口就是方法)，因此没有任何额外的功能，不像前面两个List 131 | * ·实际上Set就是Collection，只是行为不同(这是继承与多态的典型应用：表现不同的行为) 132 | * ·由于出于速度的原因，HashSet使用了散列函数。HashSet维护元素的顺序与TreeSet(使用红黑树)或LinkedHashSet都不同。 133 | */ 134 | SetOfInteger setOfInteger; 135 | /* 136 | * ·Set的API 137 | * ·contains():测试元素的归属性。这个方法查询的速度是很快的 138 | */ 139 | SetOperations setOperations; 140 | 141 | 142 | /* 143 | * ·Map：对象映射，键值对。 144 | * --与Collection不同的，Collection是单个对象的存储的 145 | */ 146 | MapMess mapMess; 147 | 148 | /* 149 | * ---HashMap不维护插入的顺序，LinkedHashMap维护 150 | * ---HashMap不维护插入的顺序，LinkedHashMap维护 151 | * Hash使用散列函数，都是不维护插入顺序的 152 | * Linked是维护插入顺序的，虽然LinkedHashMap看起来像是Hash 153 | */ 154 | 155 | /* 156 | * ·Queue(队列) 157 | * ·Queue是一个典型的先进先出容器。即从容器的一端放进元素，从另一端取出事物。把 事物放进容器的顺序与取出事物的顺序是相同的 158 | * ·常被当作一种可靠的 将对象 从程序的某一区域传输到另一区域的途径。队列在并发编程中特别重要 159 | * ·LinkedList提供了方法支持队列行为，并且实现了Queue接口，因此LinkedList可以用作Queue的一种实现，可以向上转型为Queue 160 | * ·相关的API: 161 | * ·offer():将一个元素插入到队尾 162 | * ·peek()和element():返回队头，但是不移除。当队为空时，peek()返回null，而后者会抛出异常 163 | * ·poll()和remove():返回队头，会移除返回的元素。当队为空时，poll()返回null，而后者会抛出异常 164 | */ 165 | QueueDemo queueDemo; 166 | 167 | /* 168 | * ·PriorityQueue 169 | * ·先进先出是最典型的队列规则 170 | * ·先进先出确定下一个弹出的元素，应该是等待时间最长的 171 | * ·相关的API可以参考上面的Queue 172 | */ 173 | PriorityQueueDemo priorityQueueDemo; 174 | 175 | /* 176 | * ·Collection和Iterator 177 | * ·选择Collection作为容去的基类，从而创建导出类，这样做编写的代码可以接受更通用更多的对象类型(只要基类是Collection都可以)。面向接口编程 178 | * ·C++类库中并没有其容器的任何公共基类，容器之间的所有共性都是通过迭代器达成的，操作容器中的元素全部都是通过迭代器进行操作的 179 | * ·在java中，这两个方法绑定在一起了，实现Collection就意味这提供了iterator()方法，因为Collection继承了该接口就自动拥有了该接口 180 | */ 181 | InterfaceVsIterator interfaceVsIterator; 182 | 183 | /* 184 | * ·Foreach与迭代器 (没有继承Iterable就不能使用Foreach语法) 185 | * ·foreach语法只要应用于数组，也可以应用与Collection对象(事实上foreach在所有Iterator上，Collection只是继承了Iterator) 186 | * ·foreach之所以能与Collection一起工作，是因为SE5.0被引入的Iterable接口。该接口包含一个能够产生Iterator的iterator()方法 187 | * 并且Iterator接口被foreach用来在序列中移动 188 | * ·因此如果你创建了任何实现了Iterable的类，都可以使用foreach这种语句 189 | * ·foreach可以应用在数组，但不代表数组就是Iterator，将数组向上转型为Iterator是不允许的 190 | */ 191 | IterableClass iterableClass;//自己动手实现迭代器功能 192 | 193 | /* 194 | * ·适配器方法惯用法 195 | * ·写一个foreach是反向比遍历的(只要在foreach的参数里面输入一个Iterable类型的实例对象就可以进行迭代了) 196 | */ 197 | ForeachCollections ForeachCollections;//这个一定要看，适配器 198 | ReversibleArrayList reversibleArrayList;//自己定义 可以返回一个反向foreach遍历的 迭代器 199 | MultiIterableClass multiIterableClass;//这里面有三个迭代器 200 | 201 | /* 202 | * ·使用 ArrayList 将 Arrays.asList(x[])方法结果 包装了起来 ，再对ArrayList进行操作，就不会引起x[]的改变 203 | * ·如果不使用ArrayList进行包装，而直接使用 Arrays.asList(x[])方法结果(即返回值) 进行操作，那么x[]也会被改变 204 | */ 205 | ModifyingArraysAsList modifyingArraysAsList; 206 | 207 | 208 | Object2 Object2;//这个是动手写的反向遍历的例子，要好好看一下 209 | 210 | 211 | } 212 | -------------------------------------------------------------------------------- /12 第十二章.java: -------------------------------------------------------------------------------- 1 | import code_list_two.*; 2 | 3 | public class 第十二章 { 4 | /* 5 | * ·第十二章总结 6 | * ·数组可以保持基本类型的数据，数组一旦生成，其容量就不能改变了 7 | * ·Collection保存单一对象，Map保存相关联的键值对信息。有了java泛型，就可以指定容器中存放的对象类型，这样就不会将其他类型的对象放进同一个容器中 8 | * 并且从容器中取出元素的时候，也不需要进行类型转换。Collection和Map都是可以自动拓展的大小的。 9 | * ·容器不能持有基本类型，但是自动包装机制会检查并进行相关类型的转换 10 | * ·和数组一样，List也可以建立数字索引与对象进行关联(可以进行随机访问)。因此，数组和List都是排好序的容器。List能够自动扩充容量 11 | * 12 | * ·如果要进行大量的访问 使用ArrayList；如果要大量的插入和删除数据，使用LinkedList。 13 | * ·各种Queue以及 栈 的行为，LinkedList提供支持 14 | * ·Map是一种 将对象(而非数字) 与对象相关联的设计。HashMap设计用来快速查询。而TreeMap保持键始终处于排序的状态(底部是二叉树，最小的总是第一个) 15 | * 因此TreeMap的快速访问没有HashMap块。LinkedHashMap保持元素插进的顺序，但是也通过散列提供了快速访问的能力 16 | * ·Set不接受重复的元素，HashSet提供最快的查询速度，而TreeSet保持元素处于排序的状态。LinkedHashSet以插进的顺序保存元素 17 | * ·新的程序不应该使用过时的Vector，Hashtable和Stack 18 | */ 19 | 20 | 21 | /* 22 | * 练习 23 | */ 24 | Gerbil gerbil; 25 | ObjectT objectT;//迭代器的强大之处 26 | ObjectU objectU; 27 | ObjectW objectW;//总是向容器中间插进元素 28 | ObjectX objectX;//HashMap不维护插入的顺序，LinkedHashMap维护 29 | ObjectY objectY;//HashSet不维护插入的顺序，LinkedHashSet维护 30 | ObjectZ objectZ; 31 | Object1 object1; 32 | Object2 object2;//未完 33 | } 34 | -------------------------------------------------------------------------------- /13 第十三章.java: -------------------------------------------------------------------------------- 1 | import code_list_three.Concatenation; 2 | import code_list_three.Immutable; 3 | import code_list_three.StringAPI; 4 | import test.ArrayListDisplay; 5 | 6 | public class 第十三章 { 7 | 8 | /* 9 | * 第十三章：字符串(String) 10 | * ·不可变的String 11 | */ 12 | Immutable immutable; 13 | /* 14 | * ·重载 "+" 与StringBuilder 15 | * ·String对象是不可变的，可以给String对象多个别名。String对象具有只读性，所以指向它的任何引用都不能改变它。 16 | * ·不可变性会带来一定的效率问题，为String对象重载的"+"操作符就是一个例子。重载的意思是，一个操作符在应用与特定 的类时，被赋予了不同的意思 17 | */ 18 | Concatenation concatenation; 19 | 20 | /* 21 | * ·无意识的递归 22 | */ 23 | ArrayListDisplay arrayListDisplay; 24 | 25 | /* 26 | * ·String类基本的API 27 | */ 28 | StringAPI stringAPI; 29 | 30 | 31 | } 32 | -------------------------------------------------------------------------------- /14 第十四章.java: -------------------------------------------------------------------------------- 1 | import code_list_three.*; 2 | 3 | public class 第十四章 { 4 | 5 | /* 6 | * 第14章:类型信息 7 | * ·Class对象 8 | * ·类是程序的一部分，每个类都有一个Class对象。所有的类都是在对其第一次使用时，动态加载到JVM中的，当程序创建第一个对类的静态成员的引用时候，就会加载这个类。 9 | * 这个证明构造器也是类的静态方法，即使构造器并没有使用到这个词。因此，使用new操作符创建类的新对象也会被当作对类的静态成员的引用。 10 | */ 11 | SweetShop sweetShop; 12 | /* 13 | * ·Class类包含很多有用的方法，从中可以获取很多有用的信息 14 | */ 15 | ToyTest toyTest; 16 | 17 | /* 18 | * ·类字面常量 19 | * java还提供了另一种方法来生成Class对象的引用，即使用 类字面常量 。 20 | * 像下面这样： 21 | * FancyToy.class; 22 | * 这样做不仅更简单，而且更安全。因为它在编译的时候会受到检查。使用Class.forName("X");可能就会出现没有X这个类，就会在运行时候抛出错误 23 | * ·类字面常量不仅可以引用于普通的类，有可以应用于接口，数组以及基本数据类型 24 | * ·更有趣的是，当使用".class"来创建对class对象的引用时，不会自动地初始化该Class对象。(不会自动加载static变量)，初始化有效的实现了尽可能的"惰性" 25 | */ 26 | ClassInit classInit; 27 | 28 | /* 29 | * ·泛化的Class引用:将它的类型变得更具体一点 30 | */ 31 | GenericClassRe genericClassRe; 32 | FilledList filledList; 33 | GenericToy genericToy; 34 | 35 | /* 36 | * 练习 37 | */ 38 | Shapes shapes; 39 | 40 | 41 | /* 42 | * ·动态代理 43 | */ 44 | SimpleProxyDemo simpleProxyDemo;//静态代理 45 | 46 | } 47 | -------------------------------------------------------------------------------- /15 第十五章.java: -------------------------------------------------------------------------------- 1 | import code_list_three.*; 2 | 3 | public class 第十五章 { 4 | /* 5 | * 第十五章: 6 | * ·泛型："适合于许多许多的类型" 7 | * ·多态算是一种泛化机制。有时候即便是使用了接口，对程序的约束也是太强。因为一旦指明了接口，它就要求你的代码必须使用特定的接口。而我们希望达到的目的是编写更通用的 8 | * 代码，要使代码能够应用于"某种不具体的类型"，而不是一个具体的接口或类。 9 | * ·javaSE 5.0 的重大变化:泛型的概念，泛型实现了参数化类型的概念，使代码可以应用多种类型。 10 | */ 11 | 12 | /* 13 | * ·简单的泛型 14 | * ·有很多原因促成了泛型的出现，而最引人注目的一个就是为了创造 容器类 。容器，就是存放对象的地方 15 | * ·java泛型的核心概念:告诉编译器想使用什么类型，编译器帮你处理一切细节。 16 | */ 17 | Holder1 holder1; 18 | 19 | /* 20 | * ·一个元组类库 21 | * ·有时候你需要仅一次方法调用就能返回多个对象，但是return只能返回一个对象，通常你会创建一个对象，让他来持有多个对象，你可能需要创建专门的类来完成这样的工作 22 | * 有了泛型之后，我们可以一次的解决这个问题。 23 | * ·这个概念叫 元组 ，它是将 一组对象直接打包 存储于其中 的一个 单一对象。这个容器对象允许你读取其中的元素，但是不允许你 向其中 存储新的对象 24 | */ 25 | TwoTuple twoTuple; 26 | 27 | /* 28 | * ·一个堆栈类(Stack) 29 | * ·Stack和LinkedList的组合来创建 30 | */ 31 | LinkedStack linkedStack;//自己自定义一个链表存储机制 32 | RamdomList ramdomList;//RandomList 33 | 34 | /* 35 | * ·泛型接口 36 | */ 37 | Coffee coffee;//泛型接口用作 生成器 38 | Fibonacci fibonacci; 39 | 40 | /* 41 | * ·泛型方法 42 | * ·是否拥有泛型方法，与其所在的类是否是泛型没有关系 43 | * ·泛型方法使得该方法独立与类而产生的变化，一个指导原则：无论何时，尽量使用泛型方法 44 | * ·对于一个static的方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型的能力，就必须使其成为泛型方法 45 | * ·定义一个泛型方法:将泛型参数列表置于返回值之前 46 | * 像这样: 47 | * public void f(T t) {} 48 | * ·注意：使用泛型类必须在创建对象的时候指定参数类型，而在使用泛型方法时，通常不必指明参数类型。因为编译器会帮我们找出具体的类型，这称 类型参数推断 49 | */ 50 | GenericMethod genericMethod; 51 | 52 | /* 53 | * ·杠杆利用类型参数推断 54 | */ 55 | New n; 56 | 57 | /* 58 | * ·可变参数与泛型方法 59 | */ 60 | GenericVarargs genericVarargs; 61 | 62 | /* 63 | * ·用于Generator的泛型方法 64 | * ·利用生成器可以很方便地填充一个Collection(这是上面学的)。而泛型这种操作是具有实际意义的(泛型是现在学的，写出更加通用的代码) 65 | */ 66 | Generators generators; 67 | 68 | /* 69 | * ·一个通用的Generator(对象生成器) 70 | * ·下面的程序可以为任何类构造一个Generator(对象生成器)。为了减少类型声明，提供了一个泛型方法。 71 | */ 72 | BasicGenerator basicGenerator; 73 | 74 | /* 75 | * ·简单元组的使用 76 | */ 77 | Tuple tuple; 78 | 79 | /* 80 | * ·匿名内部类 81 | * ·泛型还可以应用在匿名内部类 82 | */ 83 | BankTeller bkTeller; 84 | 85 | /* 86 | * ·擦除的神秘之处 87 | * ·当你深入研究泛型时，你会发现有大量的东西初看起来是没有意义的。例如，尽管可以声明为ArrayList.class，但是不能声明为ArrayList.class 88 | * 因为声明为ArrayList.class 中的 是没有任何意义的。在编译器后是没有的，是被擦除的。 89 | * ·java泛型是使用擦除来实现的，这意味着当你在使用泛型的时，任何具体的 类型信息 都被擦除了，你唯一知道的就是你在使用一个对象。 90 | * 因此List和List在运行时 事实上是相同的类型的。这两种形式都被擦除成它们的"原生"的类型 91 | * ·C++的方式：看下面。理解C++的泛型也有一定的好处 92 | */ 93 | ErasedTypeEquivalence e;//ArrayList和ArrayList是同一个类型 94 | LostInformation L;//无法获得 类型参数的 具体信息，更无法通过类型参数创建它的Class对象 95 | CPulsPuls cPulsPuls;//C++使用的模板 与 java泛型 的区别，跟java的泛型很一样 96 | 97 | /* 98 | * ·迁移兼容性<下面都是围绕这个话题来说> 99 | * ·为了减少潜在的关于 擦除 的混乱，你必须认识到这不是一个语言的特征，它是java泛型实现中的一种折中。因为泛型不是java语言出现时就有的组成成分，所以这种折中是必须的 100 | * ·如果泛型是java1.0就已经是其一部分了，那么这个特征将不会使用擦除来是实现--它将使用具体化，使类型参数保持为第一类实体，这样的话你就可以在类型参数上执行基于 101 | * 类型语言的操作和反射操作。擦除 减少了泛型的泛化性，泛型咋java中仍然是有用的，只是不如它们本来设想的那么有用，其原因就是擦除 102 | * ·在基于擦除的实现中，泛型类型被当作第二类类型来处理，既不能在重要的上下文环境中使用 类型。泛型类型只有在 静态类型 检查期间才出现，在此之后，程序中所有的泛型类型都被 103 | * 擦除了，替换为它们的非泛型上界。例如：诸如List这样的类型注解将被擦除为List，而普通的类型变量在未指定边界的情况下将被擦除为Object 104 | * ·擦除的核心动机是它使得泛化的客户端可以用非泛化的类库来使用，反之亦然。这经常被称为"迁移兼容性" 105 | * 因为在理想情况下，当所有的事物都可以使用泛化，那我们就可以专注于此。但是在现实中，5.0之前是没有泛型的，必须要处理这些没有被泛化的类库 106 | * ·因此java泛型不仅必须支持向后兼容性，即现有的代码是合法的，并且继续保持之前的含义。而且还要支持迁移兼容性，使得旧的代码不会影响新的代码 107 | * 一句话就是允许非泛型代码与泛型代码共存，擦除 使得这种向着泛型的迁移成为可能 108 | */ 109 | 110 | /* 111 | * ·擦除的问题 112 | * ·擦除的主要的正当理由是从非泛化代码到泛化代码的转变过程，以及在不破环现有类库的情况下，将泛型融入java语言。擦除使得现有的非泛型客户端代码能够在不改变的情况继续使用 113 | * 直到客户端准备好用泛型重写这些代码。这是一个崇高的动机，因为他不会突然间破环所有现有的代码 114 | * ·擦除的代价是显著的，泛型不能用于显式地引用运行时类型的操作之中。因为所有关于参数的类型信息都丢失了。 115 | * ·无论何时，当你在编写泛型代码的时候，必须时刻提醒自己，你只是看起来 好像拥有了 有关类型的信息。其实它只不过是一个Object而已 116 | * ·泛型不是强制的 117 | * ·当你希望将类型参数不要仅仅当作是Obbject处理时，就需要付出额外努力来管理边界(例如通过编写这些来管理) 118 | * ·其他编程语言的参数化类型相比(例如C++)：通常比java得心应手，它们的参数化类型机制比java的更灵活，更强大 119 | */ 120 | ErasureAndInheritance e1; 121 | 122 | /* 123 | * ·边界处的动作 124 | * ·因为擦除，泛型最令人困惑的一方面源自这样的一个事实，，即可以表示没有任何意义的事物。 125 | * ·泛型中的所有动作都发生在边界 126 | */ 127 | ArrayMaker arrayMaker; 128 | 129 | /* 130 | * ·擦除的补偿 131 | * ·擦除丢失了在泛型代码中执行某些操作的能力。在任何时候需要知道确切的类型信息的操作都将无法工作 132 | * ·创建类型实例 133 | */ 134 | InstantiateGenericType instantiateGenericType; 135 | 136 | 137 | public static void main(String[] args) { 138 | 139 | /* 140 | * 练习 141 | */ 142 | test1(); 143 | } 144 | 145 | private static void test1() { 146 | 147 | } 148 | 149 | ObjectA objectA; 150 | ObjectB objectB; 151 | ObjectC objectC;//extend关键字的是使用 152 | } 153 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | README 2 | =========================== 3 | ## 《Java编程思想》笔记 4 | * 书中有穿插着一些设计模式应用到实际的例子中。该书不会一味地讲语法，更多的是会讲一些Java的设计思想，比如他不会一开始就教你怎么用泛型，而是先介绍为什么会出现泛型，没有泛型会有什么后果，Java设计者又为什么会选择泛型的擦除，书中对是否选择泛型的擦除等进行了激烈的讨论，经常会与其他语言做比较，看起来是比较有意思的。 5 | 6 | **** 7 | ## 目录 8 | 9 | ### [第一部分] 10 | * [第一章：对象导论](./01 第一章.java) 11 | * 访问修饰符 12 | * 继承 13 | * 伴随多态的可互换对象 14 | * 单继承结构 15 | * 容器 16 | * 参数化类型 17 | * 对象的创建和生命周期 18 | * 异常处理:处理错误 19 | 20 | * 第二章：一切都是对象 21 | * 用引用操纵对象 22 | * 必须由你创建所有对象 23 | * 存储到什么地方 24 | * 特例：基本类型 25 | * 高精度数字 26 | * java中的数组 27 | * 永远不要销毁对象 28 | * 作用域 29 | * 对象的作用域 30 | * 基本成员默认值 31 | * static关键字: 32 | * 注释文档的语法 33 | * java的基本类型数组 和 包装器类型数组 34 | * 第一个java程序 35 | * 第三章：操作符 36 | * java操作符 37 | * 算术操作符 38 | * 关系操作符 39 | * 逻辑运算符 40 | * float 与 double 的区别 41 | * 前缀式与后缀式的区别 42 | * 测试对象的等价性 43 | * 注意数值过界 44 | * 第四章：控制流程 45 | * 迭代 46 | * return,break和continue 47 | * switch 48 | * 第五章：初始化与清理 49 | * 构造器 50 | * 方法重载 51 | * this关键字 52 | * 清理:终结处理和垃圾回收 53 | * 垃圾回收只与内存有关 54 | * finalize()的用途何在? 55 | * 终结条件 56 | * 垃圾回收器如何工作 57 | * 成员初始化 58 | * 可变参数列表 59 | * 枚举类型 60 | * 第六章：访问权限控制 61 | * 包:库的单元 62 | * java解析器的运行过程 63 | * 定制工具类 64 | * java的访问修饰符 65 | * 类的访问权限 66 | * 第七章：复用类 67 | * 复用代码 68 | * 组合语法 69 | * 继承语法 70 | * 初始化基类 71 | * 代理 72 | * 结合使用组合和继承 73 | * 在组合与继承之间选择 74 | * 继承 75 | * fianl关键字 76 | * 初始化及类的加载 77 | * 继承与初始化 78 | * 第八章：多态 79 | * 三大基本特征 80 | * 多态的作用 81 | * 再论向上转型 82 | * 忘记对象的类型 83 | * 转机 84 | * 可扩展性 85 | * 缺陷 86 | * 构造器和多态 87 | * 继承与清理 88 | * 初始化过程 89 | * 协变返回类型 90 | * 向下转型与运行时类识别 91 | ### [第二部分] 92 | * 第九章：接口 93 | * 抽象类和抽象方法 94 | * 接口 95 | * java中的多重继承 96 | * 通过继承来扩充接口 97 | * 组合接口时的名字冲突 98 | * 适配接口 99 | * 接口中的域 100 | * 嵌套接口 101 | * 接口与工厂 102 | * 第十章：内部类 103 | * 创建内部类 104 | * 链接到外部类 105 | * 使用.this与.new 106 | * 嵌套类(静态内部类) 107 | * 内部类与向上转型 108 | * 在方法和作用域内的内部类 109 | * 匿名内部类 110 | * 嵌套类 111 | * 为什么使用内部类? 112 | * 内部类的继承 113 | * 局部内部类 114 | * 第十一章：持有对象 115 | * 容器 116 | * 基本的容器类型 117 | * 容器的基本概念 118 | * 与接口打交道 119 | * List 120 | * 迭代器 121 | * LinkedList 122 | * 栈(Stack) 123 | * Set 124 | * Map 125 | * Queue 126 | * PriorityQueue 127 | * Collection和Iterator 128 | * Foreach与迭代器 129 | * 适配器方法惯用法 130 | * 总结 131 | ### [第三部分] 132 | * 第十三章：字符串 133 | * 不可变的String 134 | * 重载 "+" 与StringBuilder 135 | * 无意识的递归 136 | * String类基本的API 137 | * 第十四章：类型信息 138 | * Class对象 139 | * 类字面常量 140 | * 代理 141 | * 第十五章：泛型 142 | * 适合于许多许多的类型 143 | * 多态算是一种泛化机制 144 | * 简单的泛型 145 | * 一个元组类库 146 | * 一个堆栈类(Stack) 147 | * 泛型接口 148 | * 泛型方法 149 | * 杠杆利用类型参数推断 150 | * 可变参数与泛型方法 151 | * 用于Generator的泛型方法 152 | * 一个通用的Generator(对象生成器) 153 | * 简单元组的使用 154 | * 匿名内部类 155 | * 擦除的神秘之处 156 | * java泛型是使用擦除来实现的 157 | * C++的方式 158 | * 迁移兼容性 159 | * 擦除的核心动机 160 | * 擦除的问题 161 | * 边界处的动作 162 | * 擦除的补偿 163 | 164 | -------------------------------------------------------------------------------- /src/code_list_one/A2.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | import code_list_two.A1; 4 | 5 | //在第二个包中创建一个protected的内部类，实现刚刚那个接口 6 | public class A2 { 7 | protected class A2Inner implements A1 { 8 | public A2Inner() { 9 | } 10 | 11 | public void method() { 12 | System.out.println("A2Inner.method"); 13 | } 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /src/code_list_one/ATypeName.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class ATypeName { 4 | public static void main(String[] args) { 5 | ATypeName aTypeName = new ATypeName(); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/code_list_one/Amphibian.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Amphibian extends Frog { 4 | 5 | //这里是重新定义基类Frog中的methodA方法 6 | // public void methodA(Frog f) { 7 | // System.out.println("Amphibian.methodA"); 8 | // } 9 | 10 | public static void main(String[] args) { 11 | Amphibian amphibian = new Amphibian(); 12 | amphibian.methodA(amphibian); 13 | /* 14 | * Amphibian是Frog的导出类，Frog的方法接受的是Frog类型的参数 15 | * Amphibian继承Frog，使用Frog的方法，但实际传人的参数是Amphibian类型的,编译器没有报错 16 | * Amphibian也是Frog类型的一种，接受向上转型 17 | */ 18 | } 19 | 20 | } 21 | 22 | class Frog { 23 | public void methodA(Frog f) { 24 | System.out.println("Frog.methodA"); 25 | } 26 | 27 | public void methodB(Frog f) { 28 | System.out.println("Frog.methodB"); 29 | } 30 | } -------------------------------------------------------------------------------- /src/code_list_one/Assignment.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Assignment.java -------------------------------------------------------------------------------- /src/code_list_one/AutoboxingVarargs.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class AutoboxingVarargs { 4 | 5 | public static void f(Integer... args) { 6 | /* 7 | * 这里可以使用迭代证明你得到的是一个数组 8 | */ 9 | for (Integer i : args) { 10 | System.out.println(i.getClass()); 11 | } 12 | } 13 | 14 | public static void main(String[] args) { 15 | f(new Integer(1), new Integer(2)); 16 | f(new Integer[]{1, 5});//如果将一个数组传进去，编译器会发现它已经是一个数组了，所以不会再其上执行任何的转换。 17 | f(4, 5); 18 | f(6, new Integer(7)); 19 | f();//将0个参数传递给可变参数列表是可以得。 20 | /* 21 | * 如果将可变参数的类型设置为Integer时，是可以将基本类型int传进去，但是会将int类型转换Integer 22 | * 如果你有一组事物，可以把它们当作列表传递，而如果你已经有一个数组，该方法可以把它们当作可变参数列表来接受 23 | * 24 | */ 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /src/code_list_one/Beetle.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Beetle extends Insect {//第二步：查看是否有基类(通过extends关键字)，有的话加载基类 4 | private int k = printInit("Beetle的实例变量");//第七步：实例变量初始化 5 | 6 | public Beetle() { 7 | System.out.println("Beetle的构造器被调用");//第八步：构造器这才被调用 8 | } 9 | 10 | private static int x2 = printInit("Beetle的static变量");//第五步：导出类的static变量初始化 11 | 12 | public static void main(String[] args) {//第一步：访问main方法(一个static方法，加载.class文件) 13 | Beetle beetle = new Beetle(); 14 | } 15 | } 16 | 17 | class Insect {//第三步：加载基类 18 | 19 | public Insect() { 20 | System.out.println("Insect的构造器被调用");//第六步：基类的构造器被调用(要想创建导出类，基类的构造器一定会被调用) 21 | } 22 | 23 | private static int x1 = printInit("Insect的static变量");//第四步：基类的static变量初始化 24 | 25 | public static int printInit(String s) { 26 | System.out.println(s); 27 | return 47; 28 | } 29 | } 30 | /* 31 | * 继承与初始化 32 | * 当Beetle运行在java时，发生的第一件事是试图访问Beetle.main()(一个stati方法)，找出Beetle类的编译代码(在名为Beetle.class中) 33 | * 编译器注意到它有一个基类(这是有extends得知)，对基类进行加载(如果基类还有基类，继续加载，以此类推) 34 | * 接下来根基类(最老的那个基类)中的static初始化，然后是下一个导出类，以此类推。这种机制很重要，因为导出类的static初始化可能依赖基类的static。 35 | * 到此为止，所依赖的类已全部加载完毕，对象可以被创建。对象创建的过程:首先，对象中的所有基本类型都会被设为默认值，对象引用被设为null， 36 | * 基类构造器被调用，基类构造器完成之后，导出类的实例变量被初始化 37 | * 38 | */ 39 | -------------------------------------------------------------------------------- /src/code_list_one/BlankFinal.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class BlankFinal { 4 | 5 | private final int i = 0;//这里在域的定义处赋值 6 | private final int j;//可以先不用赋值，但是必须要在 构造中 中进行赋值 7 | 8 | public BlankFinal(int j) { 9 | this.j = j;//这里就对final的域赋值 10 | } 11 | 12 | public static void main(String[] args) { 13 | BlankFinal blankFinal = new BlankFinal(1);//可以在使用前进行赋值，提供了很大的灵活性 14 | // blankFinal.j = 1;//同样也是不可变的 15 | } 16 | 17 | } 18 | -------------------------------------------------------------------------------- /src/code_list_one/Book.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Book { 4 | boolean checkedOut = false; 5 | 6 | public Book(boolean checkedOut) { 7 | this.checkedOut = checkedOut; 8 | } 9 | 10 | //每本书都要签入 11 | public void checkIn() { 12 | checkedOut = false; 13 | System.out.println("书被签入"); 14 | } 15 | 16 | //当进行垃圾回收前调用这个方法 17 | protected void finalize() { 18 | //如果没有被签入，checkedOut就为true，这时候当回收该对象的时候就会执行下面的代码 19 | if (checkedOut) { 20 | System.out.println("书没有被签入"); 21 | } 22 | } 23 | 24 | public boolean getCheckedOut() { 25 | return checkedOut; 26 | } 27 | 28 | public static void main(String[] args) { 29 | Book book = new Book(true); 30 | book.checkIn();//将书签入 31 | new Book(true); 32 | System.gc();//强制进行终结动作(回收)，new出来的书还没有被签入 33 | /* 34 | * 本例的终结条件是:所有的Book对象在被垃圾回收前都应该被签入。但在main()方法中，由于程序员的错误，有一本书未被签入。 35 | * 要是没有finalize()方法来验证终结条件，将很难发现这种缺陷。 36 | * 注意:System.gc()用于强制进行终结动作。即使没有这样做，通过重复的执行程序(假设程序将分配大量的存储空间而导致垃圾回收动作的执行，垃圾回收器是当内存满了才进行清理工作的)， 37 | * 最终也会将Book对象回收(但是Book还有一个对象没有被签入) 38 | */ 39 | } 40 | } -------------------------------------------------------------------------------- /src/code_list_one/Cartoon.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //初始化基类 4 | public class Cartoon extends Drawing { 5 | 6 | public Cartoon() { 7 | System.out.println("Cartoon对象创建"); 8 | } 9 | 10 | public static void main(String[] args) { 11 | Cartoon cartoon = new Cartoon(); 12 | /* 13 | * 当创建一个Cartoon对象时，首先创建一个最顶层的父类，然后一级级往下创建基类的子对象 14 | * 基类在导出类构造器调用之前就已经完成初始化了 15 | */ 16 | } 17 | 18 | } 19 | 20 | class Art { 21 | Art() { 22 | System.out.println("Art对象创建"); 23 | } 24 | } 25 | 26 | class Drawing extends Art { 27 | Drawing() { 28 | System.out.println("Drawing对象创建"); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/code_list_one/Chess.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //初始化带有参数的构造器 4 | public class Chess extends BoardGame { 5 | 6 | public Chess(int i) { 7 | /* 8 | * 要想使用带有参数的构造器必须将参数 通过super传到父类 9 | */ 10 | super(i); 11 | System.out.println("Chess对象创建" + "i=" + i); 12 | } 13 | 14 | public static void main(String[] args) { 15 | Chess chess = new Chess(12);//指定参数创建对象，分别调用了三个带有参数的构造器，创建了两个基类的子对象，一个外部对象。 16 | } 17 | 18 | } 19 | 20 | class Game { 21 | Game(int i) { 22 | System.out.println("Game对象创建" + "i=" + i); 23 | } 24 | } 25 | 26 | class BoardGame extends Game { 27 | 28 | BoardGame(int i) { 29 | super(i);//调用Game带有参数的构造器 30 | System.out.println("BoardGame对象创建" + "i=" + i); 31 | } 32 | 33 | } 34 | 35 | -------------------------------------------------------------------------------- /src/code_list_one/ConnectionManager.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | import java.sql.Connection; 4 | 5 | /* 6 | * 客户端不能直接创建Connection对象，只能通过ConnectionManager类中一个static方法来获取它们， 7 | * 当ConnectionManager类中没有对象的时候，它就会返回一个null 8 | */ 9 | public class ConnectionManager { 10 | 11 | private static Connection[] conn; 12 | 13 | private ConnectionManager() { 14 | conn = new Connection[2]; 15 | } 16 | 17 | public static ConnectionManager createObject() {//调用该方法创建一个对象给方法的调用者 18 | return new ConnectionManager(); 19 | } 20 | 21 | public static Connection[] createConnection() { 22 | return conn;// 23 | } 24 | 25 | public static void main(String[] args) { 26 | Connection[] conn = ConnectionManager.createConnection();//创建一个Connection数组对象 27 | System.out.println(conn);//由于没有调用构造器进行初始化，所以返回的是一个空引用 28 | //调用static调用内部的构造方法进行初始化，数组等到初始化 29 | ConnectionManager.createObject(); 30 | Connection[] conn2 = ConnectionManager.createConnection(); 31 | //数组对象被内部的构造器初始化，数组对象不再是null 32 | System.out.println(conn2); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /src/code_list_one/CovariantReturn.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class CovariantReturn { 4 | public static void main(String[] args) { 5 | 6 | Mill m1 = new Mill(); 7 | Grain p1 = m1.process(); 8 | System.out.println(p1);//这里都是正常的 9 | 10 | Mill m2 = new WheatMill(); 11 | Grain p2 = m2.process(); 12 | System.out.println(p2); 13 | } 14 | } 15 | 16 | class Grain { 17 | public String toString() { 18 | return "Grain"; 19 | } 20 | } 21 | 22 | class Wheat extends Grain { 23 | public String toString() { 24 | return "Wheat"; 25 | } 26 | } 27 | 28 | class Mill { 29 | public Grain process() { 30 | return new Grain(); 31 | } 32 | } 33 | 34 | class WheatMill extends Mill { 35 | /* 36 | * 这里重写了process方法，返回值得类型是Wheat，与基类中该方法的返回值是不一样的(基类的返回值类型是Grain)。尽管Wheat是Grain的导出类也不可以 37 | * 但是在5.0之后，只要覆盖的方法的返回值是其基类的导出类就可以了，就可以使用该类型来接收。 38 | * 一句话：覆盖的方法返回值类型不一定要与基类的一样(是其导出类也可以) 39 | */ 40 | public Wheat process() { 41 | return new Wheat(); 42 | } 43 | } -------------------------------------------------------------------------------- /src/code_list_one/Cycle.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //创建一个Cycle类，它具有三个子类。演示每一个实例都可以由method()方法向上转型 4 | public class Cycle { 5 | public void method(Cycle c) { 6 | System.out.print("Cycle.method"); 7 | System.out.println("传人参数的类型是：" + c.getClass().getName());//运行这一行代码，等到的类名字还是传人的类型，等到的类型并没有向上转型? 8 | } 9 | 10 | public static void main(String[] args) { 11 | Unicycle unicycle = new Unicycle(); 12 | unicycle.method(unicycle);//这个方法传人的参数是Cycle类型的，但是同也可以接受它的导出类 13 | Bicycle bicycle = new Bicycle(); 14 | bicycle.method(bicycle); 15 | Tricycle tricycle = new Tricycle(); 16 | tricycle.method(tricycle); 17 | } 18 | } 19 | 20 | class Unicycle extends Cycle { 21 | public void method(Cycle c) { 22 | System.out.print("Unicycle.method"); 23 | System.out.println("传人参数的类型是：" + c.getClass().getName()); 24 | } 25 | } 26 | 27 | class Bicycle extends Cycle { 28 | public void method(Cycle c) { 29 | System.out.print("Bicycle.method"); 30 | System.out.println("传人参数的类型是：" + c.getClass().getName()); 31 | } 32 | } 33 | 34 | class Tricycle extends Cycle { 35 | public void method(Cycle c) { 36 | System.out.print("Tricycle.method"); 37 | System.out.println("传人参数的类型是：" + c.getClass().getName()); 38 | } 39 | } -------------------------------------------------------------------------------- /src/code_list_one/DataOnly.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //将DataOnly的代码找出，写成一个程序，然后编译，运行 4 | public class DataOnly { 5 | int i; 6 | double d; 7 | boolean b; 8 | 9 | public static void main(String[] args) { 10 | DataOnly data = new DataOnly(); 11 | data.i = 47; 12 | data.d = 1.1; 13 | data.b = false; 14 | //第五个练习，把它打印出来 15 | System.out.println(data.i); 16 | System.out.println(data.d); 17 | System.out.println(data.b); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/code_list_one/Detergent.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //继承 4 | class Cleanser { 5 | 6 | private String s = "Cleanser"; 7 | 8 | public void append(String a) { 9 | s += a; 10 | } 11 | 12 | public void dilute() { 13 | append("dilute()"); 14 | } 15 | 16 | public void apply() { 17 | append("apply()"); 18 | } 19 | 20 | public void scrub() { 21 | append("scrub()"); 22 | } 23 | 24 | public String toString() { 25 | return s; 26 | } 27 | 28 | public static void main(String[] args) { 29 | Cleanser x = new Cleanser(); 30 | x.dilute(); 31 | x.apply(); 32 | x.scrub(); 33 | System.out.println(x);//默认调用toString方法 34 | } 35 | } 36 | 37 | public class Detergent extends Cleanser { 38 | 39 | //重写 40 | public void scrub() { 41 | append("Detergent.scrub()"); 42 | super.scrub();//调用父类的scrub方法 43 | } 44 | 45 | //添加一个新的方法 46 | public void foam() { 47 | append("foam()"); 48 | } 49 | 50 | public static void main(String[] args) { 51 | Detergent x = new Detergent(); 52 | x.dilute(); 53 | x.apply(); 54 | x.scrub(); 55 | x.foam(); 56 | System.out.println(x);//调用一个对象，默认是调用它的toString方法 57 | Cleanser.main(args);//调用另一个类中的main函数 58 | } 59 | 60 | } 61 | 62 | //从Detergent类中继承产生一个新的类。覆盖scrub()并添加一个名为sterilize()的新方法 63 | class DetergentSon extends Detergent { 64 | 65 | //重写Detergent类的scrub()方法 66 | public void scrub() { 67 | System.out.println("DetergentSon.scrub"); 68 | } 69 | 70 | //添加一个新的方法 71 | public void sterilize() { 72 | System.out.println("DetergentSon.sterilize"); 73 | } 74 | 75 | public static void main(String[] args) { 76 | DetergentSon x = new DetergentSon(); 77 | x.scrub();//重写的方法 78 | x.foam();//调用父类的方法 79 | x.apply();//调用父父类的方法 80 | x.sterilize();//调用该类新写的方法 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /src/code_list_one/Dog.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Dog { 4 | 5 | String name; 6 | String says; 7 | 8 | 9 | public static void main(String[] args) { 10 | Dog dog = new Dog(); 11 | dog.name = "spot"; 12 | dog.says = "Ruff!"; 13 | Dog dog2 = new Dog(); 14 | dog2.name = "scruffy"; 15 | dog2.says = "Wurf!"; 16 | System.out.println(dog.name + ":" + dog.says + dog2.name + ":" + dog2.says); 17 | //创建一个新的Dog索引，并对其赋值为sport对象 18 | Dog dog3 = dog; 19 | System.out.println(dog3 == dog); 20 | System.out.println(dog3.equals(dog)); 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /src/code_list_one/Employee.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Employee { 4 | 5 | private int ID; 6 | private String name; 7 | private int managerID; 8 | 9 | public Employee() { 10 | } 11 | 12 | public Employee(int ID, String name, int managerID) { 13 | this.ID = ID; 14 | this.name = name; 15 | this.managerID = managerID; 16 | } 17 | 18 | 19 | public int getID() { 20 | return ID; 21 | } 22 | 23 | public void setID(int iD) { 24 | ID = iD; 25 | } 26 | 27 | public String getName() { 28 | return name; 29 | } 30 | 31 | public void setName(String name) { 32 | this.name = name; 33 | } 34 | 35 | public int getManagerID() { 36 | return managerID; 37 | } 38 | 39 | public void setManagerID(int managerID) { 40 | this.managerID = managerID; 41 | } 42 | 43 | 44 | } 45 | -------------------------------------------------------------------------------- /src/code_list_one/EmptyFinal.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class EmptyFinal { 4 | 5 | private final Objc objc;//这就是空白的final变量，但是在使用前必须完成赋值，只有一种方法(就是在构造器中进行赋值初始化) 6 | 7 | public EmptyFinal(Objc objc) { 8 | this.objc = objc;//在构造器中对final进行赋值 9 | } 10 | 11 | public static void main(String[] args) { 12 | EmptyFinal emptyFinal = new EmptyFinal(new Objc());//在new出来的时候传递一个对象进去，完成对final域的初始化 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /src/code_list_one/FieldAccess.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class FieldAccess { 4 | public static void main(String[] args) { 5 | 6 | //到基类引用指向一个导出类对象 7 | Super su = new Sub(); 8 | System.out.println(su.field);//对于域并没有多态 9 | System.out.println(su.getField());//对于方法就存在多态了 10 | 11 | Sub sup = new Sub(); 12 | /* 13 | * 其实在这里sup对象包含了两个称为field的域：自己一个，基类一个(在创建sup对象时，已经为其创建子对象Super，只是你没有看见) 14 | * 在引用Sub中的field域并不是Super中的(是Sup它自己的)，要想等到Super中的field域，必须显式的指明super.field 15 | */ 16 | System.out.println(sup.field); 17 | System.out.println(sup.getField()); 18 | System.out.println(sup.getSuperField());//这里是调用基类的域 19 | 20 | } 21 | } 22 | 23 | class Super { 24 | public int field = 0; 25 | 26 | public int getField() { 27 | return field; 28 | } 29 | } 30 | 31 | class Sub extends Super { 32 | public int field = 1; 33 | 34 | public int getField() { 35 | return field; 36 | } 37 | 38 | public int getSuperField() { 39 | return super.field;//调用基类的field域 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/code_list_one/FinalAndStatic.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class FinalAndStatic { 4 | 5 | private final Obj a = new Obj();//使用final关键字，在定义变量的时候必须对其进行赋值，赋值后就不能改变(是指变量的引用不能改变，对象内容可以改变)，每个对象拥有独一无二的一份 6 | 7 | private static final Obj b = new Obj();//所有对象共享一份，完成赋值不能改变，只占一份内存 8 | 9 | public static void main(String[] args) { 10 | //创建两个对象 11 | FinalAndStatic fas1 = new FinalAndStatic(); 12 | FinalAndStatic fas2 = new FinalAndStatic(); 13 | //final的hashCode 14 | System.out.println(fas1.a.hashCode()); 15 | System.out.println(fas2.a.hashCode()); 16 | /* 17 | * fianl+static的hashCode 18 | * 就算是final，两个对象的a的值都是不一样的，每个对象都独享一份 19 | */ 20 | System.out.println(fas1.b.hashCode()); 21 | System.out.println(fas2.b.hashCode()); 22 | /* 23 | * final+static：所有对象共享一份，hashCode都是一样的 24 | */ 25 | } 26 | } 27 | 28 | class Obj { 29 | 30 | } -------------------------------------------------------------------------------- /src/code_list_one/FinalArguments.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class FinalArguments { 4 | 5 | public void with(final Gizmo g) { 6 | //无法完成赋值，因为参数定义为final，则允许该方法读取参数的信息，而无法改变参数的引用 7 | //g = new Gizmo(); 8 | } 9 | 10 | public void without(Gizmo g) { 11 | g = new Gizmo();//可以改变参数的信息，随便改变参数的引用对象 12 | } 13 | 14 | public void f(final int i) { 15 | //这里同样是不能更改参数传人的值，只是允许读取参数的信息 16 | //i = 1; 17 | } 18 | 19 | public void g(int i) { 20 | i = 1;//如果不是final，则可以更改参数传入i的值 21 | } 22 | 23 | } 24 | 25 | class Gizmo { 26 | public void spin() { 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/code_list_one/FinalData.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | import java.util.Random; 4 | 5 | class Val { 6 | int i; 7 | 8 | public Val(int i) { 9 | this.i = i; 10 | } 11 | } 12 | 13 | public class FinalData { 14 | private static Random rand = new Random(47); 15 | private String id; 16 | 17 | public FinalData(String id) { 18 | this.id = id; 19 | } 20 | 21 | //基本类型+final 一旦完成初始化就不能改变的，每个对象都有一份，再多+static是所有对象共享一份不可改变的数据 22 | private final int valueOne = 9; 23 | private static final int VALUE_TWO = 99; 24 | public static final int VALUE_THREE = 39; 25 | 26 | //final与final+static的区别，下面有，final+static的基本类型全用大写字母命名 27 | private final int i4 = rand.nextInt(20); 28 | static final int INT_5 = rand.nextInt(20);//这里加了static 29 | 30 | //对象类型+final 31 | private Val v1 = new Val(11); 32 | private final Val v2 = new Val(2); 33 | private static final Val v3 = new Val(13); 34 | 35 | //数组类型+final， 36 | private final int[] a = {1, 2, 3, 4, 5, 6}; 37 | 38 | public String toString() { 39 | return id + ": " + "i4 = " + i4 + ", INT_5= " + INT_5; 40 | } 41 | 42 | public static void main(String[] args) { 43 | FinalData fd1 = new FinalData("fd1"); 44 | 45 | // fd1.valueOne = 1;//final定义的值不能被改变 46 | fd1.v2.i = 1;//不是fianl定义的值可以被改变 47 | 48 | // fd1.v2 = new Val(7);//final+对象类型，一旦初始化引用指向某个对象，那么就不能改变这个引用指引到其他对象 49 | fd1.v1 = new Val(6);//不是final的，随便改变引用指向 50 | 51 | for (int i : fd1.a) { 52 | fd1.a[i] = 1;//数组元素的数据可以改变 53 | // fd1.a[i] = new Val(1);//但是不能改变数组元素的引用指向 54 | } 55 | 56 | System.out.println(fd1); 57 | FinalData fd2 = new FinalData("fd2"); 58 | System.out.println(fd2); 59 | /* 60 | * 从这里可以看出 61 | * final+基本类型: 一旦完成初始化就不可改变，每个对象都有一份 62 | * final+static+基本类型：不可改变，只有一份(所有对象共享一份) 63 | */ 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/code_list_one/FinalOverridingIllusion.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class FinalOverridingIllusion { 4 | public static void main(String[] args) { 5 | OverridingPrivate2 op2 = new OverridingPrivate2(); 6 | op2.f(); 7 | op2.g(); 8 | OverridingPrivate op = op2; 9 | // op.f();//调用不了 10 | } 11 | } 12 | 13 | class WithFinals { 14 | // @Override//如果添加一个Override注解就可以解决这种问题，Override是为了想要覆盖基类的方法，但如果因为某种因素变成了重新定义，那么编译器就会产生一个错误 15 | private final void f() { 16 | System.out.println("WithFinals.f()"); 17 | } 18 | 19 | private void g() { 20 | System.out.println("WithFinals.g()"); 21 | } 22 | } 23 | 24 | class OverridingPrivate extends WithFinals { 25 | //这里是产生一个新的方法，并不是覆盖基类的方法 26 | private final void f() { 27 | System.out.println("OverridingPrivate.f()"); 28 | } 29 | 30 | //这里也是，产生一个新的方法，并不覆盖原来的方法 31 | private void g() { 32 | System.out.println("OverridingPrivate.g()"); 33 | } 34 | } 35 | 36 | class OverridingPrivate2 extends OverridingPrivate { 37 | public final void f() { 38 | System.out.println("OverridingPrivate2.f()"); 39 | } 40 | 41 | public void g() { 42 | System.out.println("OverridingPrivate2.g()"); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/code_list_one/Frog1.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Frog1 extends Amphibian1 {//2.寻找该类是否有基类(通过extends关键字可以知道)，依次类推，最后到根基类 4 | private Charateristic p = new Charateristic("a3"); 5 | private Description d = new Description("b3"); 6 | 7 | public Frog1() { 8 | System.out.println("Frog1"); 9 | } 10 | 11 | protected void dispose() { 12 | System.out.println("Frog1.dispose"); 13 | d.dispose(); 14 | p.dispose(); 15 | super.dispose(); 16 | } 17 | 18 | public static void main(String[] args) {//1.首先加载main方法(一个static方法) 19 | // 6.同样的方法Frog1被实例化 20 | Frog1 frog1 = new Frog1(); 21 | System.out.println("Bye!"); 22 | frog1.dispose(); 23 | /* 24 | * 7. 调用dispose方法 25 | * 这里刚好与前面的相反，先执行导出类的dispose方法，在依次执行到根基类的dispose方法，从输出的结果来看，Frog1对象的所有部分都是按照创建的逆序进行销毁 26 | */ 27 | } 28 | } 29 | 30 | class Charateristic { 31 | private String s; 32 | 33 | public Charateristic(String s) { 34 | this.s = s; 35 | System.out.println("Charateristic构造器"); 36 | } 37 | 38 | protected void dispose() { 39 | System.out.println("Charateristic.dispose"); 40 | } 41 | } 42 | 43 | class Description { 44 | private String s; 45 | 46 | public Description(String s) { 47 | this.s = s; 48 | System.out.println("Description构造器"); 49 | } 50 | 51 | protected void dispose() { 52 | System.out.println("Description.dispose"); 53 | } 54 | } 55 | 56 | class LivingCreature { 57 | /* 58 | * 3.这里是根基类，首先是创建该类的对象。先初始化域(成员变量)，Charateristic和Description对象都被创建(各自的构造器被调用)， 59 | * 成员变量实例化的顺序是按照你编写的顺序。然后再调用LivingCreature的构造器，LivingCreature对象被创建。依次类推，同样的方法创建下一个导出类 60 | * 61 | */ 62 | private Charateristic p = new Charateristic("a"); 63 | private Description d = new Description("b"); 64 | 65 | public LivingCreature() { 66 | System.out.println("LivingCreature构造器"); 67 | } 68 | 69 | protected void dispose() { 70 | System.out.println("LivingCreature.dispose"); 71 | d.dispose(); 72 | p.dispose(); 73 | } 74 | } 75 | 76 | class Animal extends LivingCreature { 77 | /* 78 | * 4.上面已经创建了基类LivingCreature的对象，就有了创建该对象的条件了。先初始化成员变量(构造器被调用)，成员初始化完，创建该对象 79 | */ 80 | private Charateristic p = new Charateristic("a1"); 81 | private Description d = new Description("b1"); 82 | 83 | public Animal() { 84 | System.out.println("Animal"); 85 | } 86 | 87 | protected void dispose() { 88 | System.out.println("Animal.dispose"); 89 | d.dispose(); 90 | p.dispose(); 91 | super.dispose(); 92 | } 93 | } 94 | 95 | class Amphibian1 extends Animal { 96 | /* 97 | * 5.同样的方法创建该对象 98 | */ 99 | private Charateristic p = new Charateristic("a2"); 100 | private Description d = new Description("b2"); 101 | 102 | public Amphibian1() { 103 | System.out.println("Amphibian1"); 104 | } 105 | 106 | protected void dispose() { 107 | System.out.println("Amphibian1.dispose"); 108 | d.dispose(); 109 | p.dispose(); 110 | super.dispose(); 111 | } 112 | } 113 | -------------------------------------------------------------------------------- /src/code_list_one/HelloData.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/HelloData.java -------------------------------------------------------------------------------- /src/code_list_one/Hide.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Hide.java -------------------------------------------------------------------------------- /src/code_list_one/Incrementable.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Incrementable.java -------------------------------------------------------------------------------- /src/code_list_one/Jursaaic.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Jursaaic.java -------------------------------------------------------------------------------- /src/code_list_one/Letter.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Letter { 4 | char c; 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/Lunch.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Lunch.java -------------------------------------------------------------------------------- /src/code_list_one/Music.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Music.java -------------------------------------------------------------------------------- /src/code_list_one/Music2.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Music2.java -------------------------------------------------------------------------------- /src/code_list_one/Note.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Note.java -------------------------------------------------------------------------------- /src/code_list_one/Num.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public enum Num { 4 | ONE, TWO, THREE, FOUR; 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/Objc.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Objc { 4 | 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/ObjectA.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | //static关键字 4 | public class ObjectA { 5 | 6 | public static int i = 47; 7 | 8 | } 9 | -------------------------------------------------------------------------------- /src/code_list_one/ObjectB.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | /* 4 | * 创建一个类，包含一个int域和一个char域，它们都没有初始化，将他们打印出来，以验证java的执行了默认的初始值 5 | */ 6 | public class ObjectB { 7 | int i; 8 | char a; 9 | 10 | public static void main(String[] args) { 11 | ObjectB objectB = new ObjectB(); 12 | System.out.println("基本类型int的默认值是" + objectB.i); 13 | System.out.println("基本类型char的默认值是" + objectB.a); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/code_list_one/ObjectC.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectC.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectD.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectD.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectE.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectE.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectF.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectF.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectG.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectG.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectH.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectH.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectI.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectI.java -------------------------------------------------------------------------------- /src/code_list_one/ObjectJ.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ObjectJ.java -------------------------------------------------------------------------------- /src/code_list_one/Orc.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Orc.java -------------------------------------------------------------------------------- /src/code_list_one/OrderOfIn.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/OrderOfIn.java -------------------------------------------------------------------------------- /src/code_list_one/PassObject.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/PassObject.java -------------------------------------------------------------------------------- /src/code_list_one/PolyConstructors.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/PolyConstructors.java -------------------------------------------------------------------------------- /src/code_list_one/PrivateOverride.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/PrivateOverride.java -------------------------------------------------------------------------------- /src/code_list_one/RTTI.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/RTTI.java -------------------------------------------------------------------------------- /src/code_list_one/ReadTxt.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/ReadTxt.java -------------------------------------------------------------------------------- /src/code_list_one/Rodent.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Rodent.java -------------------------------------------------------------------------------- /src/code_list_one/Sandwich.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Sandwich.java -------------------------------------------------------------------------------- /src/code_list_one/Shapes.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Shapes.java -------------------------------------------------------------------------------- /src/code_list_one/SpaceShipControls.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/SpaceShipControls.java -------------------------------------------------------------------------------- /src/code_list_one/SpaceShipDelegation.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/SpaceShipDelegation.java -------------------------------------------------------------------------------- /src/code_list_one/Spiciness.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Spiciness.java -------------------------------------------------------------------------------- /src/code_list_one/StaticPolymorphism.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/StaticPolymorphism.java -------------------------------------------------------------------------------- /src/code_list_one/StaticTest.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class StaticTest { 4 | public static int i = 47; 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/StaticWord.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/StaticWord.java -------------------------------------------------------------------------------- /src/code_list_one/Tank.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Tank { 4 | int level; 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/Value.java: -------------------------------------------------------------------------------- 1 | package code_list_one; 2 | 3 | public class Value { 4 | public int i; 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_one/VarargType.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/VarargType.java -------------------------------------------------------------------------------- /src/code_list_one/Wind.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_one/Wind.java -------------------------------------------------------------------------------- /src/code_list_three/A3.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/A3.java -------------------------------------------------------------------------------- /src/code_list_three/ArrayListDisplay.java: -------------------------------------------------------------------------------- 1 | package code_list_three; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class ArrayListDisplay { 6 | public static void main(String[] args) { 7 | ArrayList arrayList = new ArrayList(); 8 | arrayList.add("A"); 9 | arrayList.add("B"); 10 | arrayList.add("C"); 11 | System.out.println(arrayList); 12 | // 容器类也有toString方法，并且覆写类该 方法，使得它生成的String结果能够表达它自己的元素 13 | } 14 | } 15 | 16 | class InfiniteRecursion { 17 | public static void main(String[] args) { 18 | ArrayList arrayList = new ArrayList(); 19 | arrayList.add(new InfiniteRecursion()); 20 | System.out.println(arrayList.toString()); 21 | /* 22 | * 这里会报错的原因是： 23 | * 当运行到这行代码的时候 "address" + this ; 24 | * 就会发生类型转换，编译器看到String对象("address就是一个String对象")后面跟着一个"+"。于是编译器就尝试将 this 转换为String对象， 25 | * 可是怎么将this 转换为String?编译器就尝试调用this的toString方法--于是调用this.toString，又回到该toString方法了，就发生了递归 26 | */ 27 | } 28 | public String toString() { 29 | return "address" + this ; 30 | // return "address" + super.toString(); 31 | } 32 | //如果真的想打印内存地址，就应该调用Obejct.toString()方法,它才是负责这个任务的方法(这个任务是指打印内存地址)。所以，你不应该使用this，而是应该调用super.toString()方法 33 | } 34 | -------------------------------------------------------------------------------- /src/code_list_three/ArrayMaker.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ArrayMaker.java -------------------------------------------------------------------------------- /src/code_list_three/BankTeller.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/BankTeller.java -------------------------------------------------------------------------------- /src/code_list_three/BasicGenerator.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/BasicGenerator.java -------------------------------------------------------------------------------- /src/code_list_three/CPulsPuls.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/CPulsPuls.java -------------------------------------------------------------------------------- /src/code_list_three/ClassInit.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ClassInit.java -------------------------------------------------------------------------------- /src/code_list_three/Coffee.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Coffee.java -------------------------------------------------------------------------------- /src/code_list_three/Concatenation.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Concatenation.java -------------------------------------------------------------------------------- /src/code_list_three/Erased.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Erased.java -------------------------------------------------------------------------------- /src/code_list_three/ErasedTypeEquivalence.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ErasedTypeEquivalence.java -------------------------------------------------------------------------------- /src/code_list_three/ErasureAndInheritance.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ErasureAndInheritance.java -------------------------------------------------------------------------------- /src/code_list_three/Factories.java: -------------------------------------------------------------------------------- 1 | package test; 2 | 3 | public class Factories { 4 | public static void main(String[] args) { 5 | //利用工厂模式，调用方法就可以返回一个对象了 6 | ServiceFactory factory = ServiceImpl.factory(); 7 | Service service = factory.getService(); 8 | service.method1(); 9 | service.method2(); 10 | //调用另一个工厂，返回另一种对象实例 11 | ServiceFactory factory2 = ServiceImpl.factory(); 12 | Service service2 = factory2.getService(); 13 | service2.method1(); 14 | service2.method2(); 15 | } 16 | } 17 | //接口 18 | interface Service { 19 | void method1(); 20 | void method2(); 21 | } 22 | //这是一个工厂，调用getService方法可以返回一个实例 23 | interface ServiceFactory { 24 | Service getService(); 25 | } 26 | class ServiceImpl implements Service { 27 | public void method1() {System.out.println("ServiceImpl.method1");} 28 | public void method2() {System.out.println("ServiceImpl.method2");} 29 | //调用这个方法可以获得一个工厂 30 | public static ServiceFactory factory() { 31 | return new ServiceFactory() { 32 | public Service getService() { 33 | return new ServiceImpl(); 34 | } 35 | }; 36 | } 37 | } 38 | class ServiceImpl2 implements Service { 39 | public void method1() {System.out.println("ServiceImpl2.method1");} 40 | public void method2() {System.out.println("ServiceImpl2.method2");} 41 | public static ServiceFactory factory() { 42 | return new ServiceFactory() { 43 | public Service getService() { 44 | return new ServiceImpl2(); 45 | } 46 | }; 47 | } 48 | } 49 | 50 | 51 | -------------------------------------------------------------------------------- /src/code_list_three/Fibonacci.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Fibonacci.java -------------------------------------------------------------------------------- /src/code_list_three/FilledList.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/FilledList.java -------------------------------------------------------------------------------- /src/code_list_three/Generators.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Generators.java -------------------------------------------------------------------------------- /src/code_list_three/GenericClassRe.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/GenericClassRe.java -------------------------------------------------------------------------------- /src/code_list_three/GenericMethod.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/GenericMethod.java -------------------------------------------------------------------------------- /src/code_list_three/GenericToy.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/GenericToy.java -------------------------------------------------------------------------------- /src/code_list_three/GenericVarargs.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/GenericVarargs.java -------------------------------------------------------------------------------- /src/code_list_three/Holder1.java: -------------------------------------------------------------------------------- 1 | package code_list_three; 2 | 3 | public class Holder1 { 4 | private Automobile a; 5 | public Holder1(Automobile a) {this.a = a;} 6 | public Automobile get() {return this.a;} 7 | //这个对象的重用性很差，它无法持有其他类型的任何对象。因此我们要为每一个类型创建一个这样的类 8 | } 9 | class Holder2 { 10 | private Object o; 11 | public Holder2(Object o) {this.o = o;} 12 | public Object get() {return this.o;} 13 | public void set(Object o) {this.o = o;} 14 | public static void main(String[] args) { 15 | Holder2 h2 = new Holder2(new Integer("1")); 16 | h2.get(); 17 | h2.set(new Automobile()); 18 | Automobile a = (Automobile)h2.get(); 19 | } 20 | //现在Holder2可以存储任何类型的对象了 21 | } 22 | class Automobile {} 23 | /* 24 | * 有时候，我们希望容器可以存储多种类型的对象。但是，通常情况下，我们只会存储一种类型 的对象。我们更喜欢暂时不指定类型，而是稍后在决定使用什么类型的参数 25 | * 用尖括号括着，放在类名的后面。然后在使用这个类的时候，再用实际的类型替换此类型参数。 26 | */ 27 | class Holder3 { 28 | private T a; 29 | public Holder3(T a) {this.a = a;} 30 | public T get() {return a;} 31 | public void set(T a) {this.a = a;} 32 | public static void main(String[] args) { 33 | Holder3 h3 = new Holder3(new Automobile()); 34 | Automobile a = h3.get();//自动地转换为正确的类型 35 | // h3.set("a"); 36 | /* 37 | * 当你创建Holder3时，必须指明持有什么类型的对象，将其置于尖括号内。然后，你只能在Holder3中存放该类型(或者是子类，多态与泛型不冲突) 38 | * 并且，在Hodler3中取出它持有的对象时，自动地就是正确的类型了 39 | * ·java泛型的核心概念:告诉编译器想使用什么类型，编译器帮你处理一切细节。 40 | */ 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/code_list_three/Immutable.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Immutable.java -------------------------------------------------------------------------------- /src/code_list_three/InstantiateGenericType.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/InstantiateGenericType.java -------------------------------------------------------------------------------- /src/code_list_three/LinkedStack.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/LinkedStack.java -------------------------------------------------------------------------------- /src/code_list_three/LostInformation.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/LostInformation.java -------------------------------------------------------------------------------- /src/code_list_three/New.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/New.java -------------------------------------------------------------------------------- /src/code_list_three/ObjectA.java: -------------------------------------------------------------------------------- 1 | package code_list_three; 2 | 3 | //如果指定Holder3可以持有某个基类类型，那么它也能持有导出类 4 | public class ObjectA { 5 | public static void main(String[] args) { 6 | Holder3 h3 = new Holder3(new Automobile());//h3持有的是Automobile类型 7 | h3.set(new Automobile2());//也可以持有它的导出类Automobile2 8 | } 9 | } 10 | class Automobile2 extends Automobile {} 11 | -------------------------------------------------------------------------------- /src/code_list_three/ObjectB.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ObjectB.java -------------------------------------------------------------------------------- /src/code_list_three/ObjectC.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ObjectC.java -------------------------------------------------------------------------------- /src/code_list_three/RamdomList.java: -------------------------------------------------------------------------------- 1 | package code_list_three; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Random; 5 | 6 | public class RamdomList { 7 | private ArrayList storage = new ArrayList(); 8 | private Random rand = new Random(47); 9 | public void add(T item) { 10 | storage.add(item); 11 | } 12 | public T select() { 13 | return storage.get(rand.nextInt(storage.size())); 14 | } 15 | public static void main(String[] args) { 16 | RamdomList randomlist = new RamdomList(); 17 | for (String s : "A,B,C,D,E,F,G".split(",")) { 18 | randomlist.add(s); 19 | } 20 | for (int i = 0; i < 6; i++) { 21 | System.out.println(randomlist.select()); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/code_list_three/Shapes.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/Shapes.java -------------------------------------------------------------------------------- /src/code_list_three/SimpleProxyDemo.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/SimpleProxyDemo.java -------------------------------------------------------------------------------- /src/code_list_three/StringAPI.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/StringAPI.java -------------------------------------------------------------------------------- /src/code_list_three/SweetShop.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/SweetShop.java -------------------------------------------------------------------------------- /src/code_list_three/ToyTest.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/ToyTest.java -------------------------------------------------------------------------------- /src/code_list_three/Tuple.java: -------------------------------------------------------------------------------- 1 | package code_list_three; 2 | 3 | public class Tuple { 4 | public static TwoTuple tuple(A a,B b) { 5 | return new TwoTuple(a,b); 6 | } 7 | public static ThreeTuple tuple(A a,B b,C c) { 8 | return new ThreeTuple(a,b,c); 9 | } 10 | public static FourTuple tuple(A a,B b,C c,D d) { 11 | return new FourTuple(a,b,c,d); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/code_list_three/TwoTuple.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_three/TwoTuple.java -------------------------------------------------------------------------------- /src/code_list_two/A1.java: -------------------------------------------------------------------------------- 1 | package code_list_two; 2 | 3 | public interface A1 { 4 | void method(); 5 | } 6 | -------------------------------------------------------------------------------- /src/code_list_two/AddingGroups.java: -------------------------------------------------------------------------------- 1 | package code_list_two; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Collection; 6 | import java.util.Collections; 7 | 8 | //Arrays.asList()方法接受一个数组或者是一个用逗号分隔的元素列表，并将其转化为一个List对象 9 | public class AddingGroups { 10 | public static void main(String[] args) { 11 | Collection c = new ArrayList(Arrays.asList(1, 2, 3)); 12 | //使用Arrays.asList(),可以将一个Collection集合或者是用逗号分隔的对象转换为Collection对象 13 | 14 | Collections.addAll(c, 4, 5, 6); 15 | //Collections.addAll方法也可以将另一个集合或者是逗号分隔的。追加到给定的集合上(要在该方法的参数里面传人一个集合) 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/code_list_two/Adventure.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Adventure.java -------------------------------------------------------------------------------- /src/code_list_two/AnonymousConstructor.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/AnonymousConstructor.java -------------------------------------------------------------------------------- /src/code_list_two/Apply.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Apply.java -------------------------------------------------------------------------------- /src/code_list_two/ClassInInterface.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ClassInInterface.java -------------------------------------------------------------------------------- /src/code_list_two/CrossC.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/CrossC.java -------------------------------------------------------------------------------- /src/code_list_two/DotNew.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/DotNew.java -------------------------------------------------------------------------------- /src/code_list_two/DotThis.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/DotThis.java -------------------------------------------------------------------------------- /src/code_list_two/Factories.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Factories.java -------------------------------------------------------------------------------- /src/code_list_two/ForeachCollections.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ForeachCollections.java -------------------------------------------------------------------------------- /src/code_list_two/Gerbil.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Gerbil.java -------------------------------------------------------------------------------- /src/code_list_two/HorrorShow.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/HorrorShow.java -------------------------------------------------------------------------------- /src/code_list_two/InheritInner.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/InheritInner.java -------------------------------------------------------------------------------- /src/code_list_two/InterfaceVsIterator.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/InterfaceVsIterator.java -------------------------------------------------------------------------------- /src/code_list_two/IterableClass.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/IterableClass.java -------------------------------------------------------------------------------- /src/code_list_two/LinkedListFeatures.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/LinkedListFeatures.java -------------------------------------------------------------------------------- /src/code_list_two/ListIteration.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ListIteration.java -------------------------------------------------------------------------------- /src/code_list_two/LocalInnerClass.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/LocalInnerClass.java -------------------------------------------------------------------------------- /src/code_list_two/MapMess.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/MapMess.java -------------------------------------------------------------------------------- /src/code_list_two/ModifyingArraysAsList.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ModifyingArraysAsList.java -------------------------------------------------------------------------------- /src/code_list_two/Months.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Months.java -------------------------------------------------------------------------------- /src/code_list_two/MultiImplementation.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/MultiImplementation.java -------------------------------------------------------------------------------- /src/code_list_two/MultiInterfaces.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/MultiInterfaces.java -------------------------------------------------------------------------------- /src/code_list_two/MultiIterableClass.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/MultiIterableClass.java -------------------------------------------------------------------------------- /src/code_list_two/MultiNestingAccess.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/MultiNestingAccess.java -------------------------------------------------------------------------------- /src/code_list_two/Music4.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Music4.java -------------------------------------------------------------------------------- /src/code_list_two/Music5.java: -------------------------------------------------------------------------------- 1 | package code_list_two; 2 | 3 | public class Music5 { 4 | static void tune(Instrument1 i) { 5 | i.play(); 6 | } 7 | 8 | static void tune(Instrument1[] arr) { 9 | for (Instrument1 i : arr) { 10 | i.play(); 11 | } 12 | } 13 | 14 | public static void main(String[] args) { 15 | Instrument1[] arr = {new Wind1(), new Percussion1(), new Stringed1(), new Woodwind1(), new Brass1()}; 16 | tune(arr); 17 | } 18 | } 19 | 20 | interface Instrument1 { 21 | int value = 5; 22 | 23 | void play(); 24 | 25 | void adjust(); 26 | } 27 | 28 | class Wind1 implements Instrument1 { 29 | public void play() { 30 | System.out.println("Wind.play"); 31 | } 32 | 33 | public void adjust() { 34 | System.out.println("Wind1.adjust"); 35 | } 36 | } 37 | 38 | class Percussion1 implements Instrument1 { 39 | public void play() { 40 | System.out.println("Percussion1.play"); 41 | } 42 | 43 | public void adjust() { 44 | System.out.println("Percussion1.adjust"); 45 | } 46 | } 47 | 48 | class Stringed1 implements Instrument1 { 49 | public void play() { 50 | System.out.println("Stringed1.play"); 51 | } 52 | 53 | public void adjust() { 54 | System.out.println("Stringed1.adjust"); 55 | } 56 | } 57 | 58 | class Woodwind1 extends Wind1 { 59 | public void play() { 60 | System.out.println("Woodwind.play"); 61 | } 62 | 63 | public String what() { 64 | return "Woodwind1.what"; 65 | } 66 | } 67 | 68 | class Brass1 extends Wind1 { 69 | public void play() { 70 | System.out.println("Brass1.play"); 71 | } 72 | 73 | public void adjust() { 74 | System.out.println("Brass1.adjust"); 75 | } 76 | } -------------------------------------------------------------------------------- /src/code_list_two/NestingInterfaces.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/NestingInterfaces.java -------------------------------------------------------------------------------- /src/code_list_two/Object1.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Object1.java -------------------------------------------------------------------------------- /src/code_list_two/Object2.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Object2.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectA.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectA.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectB.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectB.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectC.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectC.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectD.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectD.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectE.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectE.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectF.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectF.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectG.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectG.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectH.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectH.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectI.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectI.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectJ.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectJ.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectK.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectK.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectL.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectL.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectM.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectM.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectN.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectN.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectO.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectO.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectP.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectP.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectQ.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectQ.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectR.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectR.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectS.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectS.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectT.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectT.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectU.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectU.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectW.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectW.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectX.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectX.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectY.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectY.java -------------------------------------------------------------------------------- /src/code_list_two/ObjectZ.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ObjectZ.java -------------------------------------------------------------------------------- /src/code_list_two/Outer.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Outer.java -------------------------------------------------------------------------------- /src/code_list_two/Outer1.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Outer1.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel.java: -------------------------------------------------------------------------------- 1 | package code_list_two; 2 | 3 | public class Parcel { 4 | class Contents { 5 | private int i = 11; 6 | 7 | public int value() { 8 | return i; 9 | } 10 | } 11 | 12 | class Destination { 13 | private String label; 14 | 15 | public Destination(String label) { 16 | this.label = label; 17 | } 18 | 19 | String readLabel() { 20 | return label; 21 | } 22 | } 23 | 24 | public static void main(String[] args) { 25 | Parcel p = new Parcel(); 26 | Parcel.Contents c = p.new Contents(); 27 | System.out.println(c.value()); 28 | Parcel.Destination d = p.new Destination("H"); 29 | System.out.println(d.readLabel()); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/code_list_two/Parcel11.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel11.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel5.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel5.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel6.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel6.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel7.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel7.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel7b.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel7b.java -------------------------------------------------------------------------------- /src/code_list_two/Parcel9.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcel9.java -------------------------------------------------------------------------------- /src/code_list_two/Parcell.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Parcell.java -------------------------------------------------------------------------------- /src/code_list_two/PriorityQueueDemo.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/PriorityQueueDemo.java -------------------------------------------------------------------------------- /src/code_list_two/QueueDemo.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/QueueDemo.java -------------------------------------------------------------------------------- /src/code_list_two/ReversibleArrayList.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/ReversibleArrayList.java -------------------------------------------------------------------------------- /src/code_list_two/Sequence.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Sequence.java -------------------------------------------------------------------------------- /src/code_list_two/SetOfInteger.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/SetOfInteger.java -------------------------------------------------------------------------------- /src/code_list_two/SetOperations.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/SetOperations.java -------------------------------------------------------------------------------- /src/code_list_two/SimpleCollection.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/SimpleCollection.java -------------------------------------------------------------------------------- /src/code_list_two/SimpleIteration.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/SimpleIteration.java -------------------------------------------------------------------------------- /src/code_list_two/Snippet.java: -------------------------------------------------------------------------------- 1 | package code_list_two; 2 | 3 | public class Snippet { 4 | public static void main(String[] args) { 5 | } 6 | } 7 | 8 | -------------------------------------------------------------------------------- /src/code_list_two/Stack.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/Stack.java -------------------------------------------------------------------------------- /src/code_list_two/TestParcel.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/TestParcel.java -------------------------------------------------------------------------------- /src/code_list_two/TestRandVals.java: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/levonmo/Thinking-in-Java/0f95f66c258c6c8285ded6dfcc7f87dc40b512d6/src/code_list_two/TestRandVals.java --------------------------------------------------------------------------------