Java开发者转型指南：Java to Kotlin重构实战

kotlin

java

需积分: 5 198 浏览量更新于2024-06-16 收藏 7.76MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

《Java到Kotlin：重构指南》是一本专为已经掌握Java编程语言但希望转向Kotlin的开发者编写的实用书籍。两位作者Duncan McGregor和Nat Pryce，以其丰富的经验和教训为基础，提供了深入的指导，帮助读者逐步将现有的Java代码重构为Kotlin代码，避免了他们在初次采用Kotlin时可能遇到的问题。本书的特点主要体现在以下几个方面： 1. 针对性：这本书是为Java开发者量身定制的，确保他们在理解和迁移过程中能够保持高效和流畅。 2. 重构技巧：书中详尽介绍了如何运用一系列技巧和方法，如语法转换、代码结构调整，让Java代码逐渐过渡到Kotlin的语法体系。这包括讲解如何处理Java的设计模式、库和框架，以便在新语言中找到合适的替代方案。 3. 实用示例：书中通过大量的实际例子和案例，展示了如何将Java代码中的常见模式和功能无缝迁移到Kotlin，使读者能够直观地理解重构过程，并学会在实践中应用这些策略。 4. 最佳实践与经验分享：作者不仅提供技术性的指导，还分享了他们在重构过程中的宝贵经验和最佳实践，帮助读者避免常见陷阱，提升代码质量和重构效率。 5. 代码质量和性能提升：Kotlin的独特特性如空安全、扩展函数和Lambda表达式等在书中得到了充分探讨，旨在优化代码结构，提升运行时性能，使重构后的代码更具可读性和可维护性。这本书获得了业内专家的好评，如Hadi Hariri（JetBrains）赞扬其作为从Java到Kotlin转变的必备参考书，而Dr. Venkat Subramaniam（Agile Developer, Inc.）则强调了它对于熟悉Java的开发者的价值。此外，Dawn Griffiths和David Griffiths（《Head First Kotlin》作者）也推荐此书为Java开发者快速提升Kotlin技能的高效途径。综上，《Java到Kotlin：重构指南》是一本实战型教程，对于想要拥抱Kotlin语言的Java开发者来说，是一本不可多得的学习和参考工具。通过阅读这本书，开发者们能够更有效地进行代码迁移，同时提升自己的编程技巧和代码质量。

资源详情

资源推荐

a shared belief in the power of functional programming to reduce the complexity of

our systems, especially when combined with object-oriented (OO) message passing.

Java has been moving in this direction over the years. Scala ran toward functional

programming but away from OO. We find that the grain of Kotlin lets us mix func‐

tional and object programming in a way that reduces complexity and brings out the

best in mere mortal developers.

Perfect Code

On the subject of mere mortals, we should address code quality. It is sorely tempting

to aim for perfection when committing code to a book. We know that you will be

judging us by the code here, and like many developers, a great deal of our own self-

worth is tied up in the quality of the work we produce.

At the same time, we are engineers not artists. Our job is to balance scope, schedule,

and cost for our customers. No one but us really cares about the quality of the code

except when it affects one of these three higher values.

So in our examples, we have tried to show realistic production code. The starting

points are sometimes not as good as we might like; we are, after all, trying to show

ways of improving them. Often refactorings will make things worse before they get

better, so definitely don’t judge us by code in the middle of a chapter. By the end of a

chapter, our aim is to have code that is good enough, but not so perfect that we could

be accused of wasting our clients’ money.

That said, we have a policy of applying cost-effective changes to tidy up, even once we

have covered the topic we set out to illustrate, and more than once we have invented a

topic, and written a chapter just to leave the code in a state that we’re happy with. In

the end, we are artists as well as engineers.

Code Formatting

Our code follows (our interpretation of) the standard coding conventions of Java and

Kotlin where possible.

The practical line length for printed code samples is much shorter than the 120 char‐

acters we usually use in an IDE these days, so we have had to split lines more often

than usual to make the code fit in the page width. Our production code might have

four or five parameters or arguments on a line; in this book we will often only have

one. Through formatting the examples for the page, we have come to like the more

vertical style. We find that Kotlin naturally seems to want to take more vertical space

than Java, but even Java readability seems improved by shorter lines, more breaks,

and more visual alignment. Certainly scrolling sideways is almost as inconvenient in

an IDE as in a book, and our pairing sessions are improved by less scrolling and more

xiv | Preface

Using Code Examples

Most of the code examples in the book (the ones from the refactoring sections) can be

accessed online on GitHub. The reference is immediately after the code, like this:

class TableReaderAcceptanceTests {

@Test

fun test() {

}

Example 0.1 [table-reader.1:src/test/java/travelator/tablereader/TableReaderAcceptanceTests.kt]

If you are reading this on a device, the reference should be a hyperlink to that version

of the file on GitHub. On real paper, you can click all you like; nothing will happen,

sorry. But if you take the example number, in this case 0.1, and type it into a form on

the book’s website, it will show you links that take you to the same place.

In Git, the different code examples (these sometimes span multiple chapters) evolve

in separate branches. The steps are tagged—table-reader.1 is the tag in this case. The

GitHub link is to code with that tag, so you can view the file shown (src/test/java/trav‐

elator/tablereader/TableReaderAcceptanceTests.kt here) and the others in the example

at that version. You can also select other tags to see the different versions, and differ‐

ent branches to see different examples. For quicker navigation, you can clone the

repository, open it in IntelliJ, and use the Git tool window to switch branches and

versions.

The code examples are not real! The codebase builds and passes its

tests, but it is fictional. There are places where the examples don’t

join up properly, and others where if you peek behind the curtain

you will see us wiggling the levers. We have tried to be honest, but

prefer to ship!

If you have a technical question or a problem using the code examples, visit the

book’s website or email bookquestions@oreilly.com.

This book is here to help you get your job done. In general, if example code is offered

with this book, you may use it in your programs and documentation. You do not

need to contact us for permission unless you’re reproducing a significant portion of

the code. For example, writing a program that uses several chunks of code from this

book does not require permission. Selling or distributing examples from O’Reilly

books does require permission. Answering a question by citing this book and quoting

example code does not require permission. Incorporating a significant amount of

example code from this book into your product’s documentation does require

permission.

xvi | Preface

Acknowledgments

Thank you to Hadi Hariri for suggesting to O’Reilly that we should write a book, and

to Zan McQuade for believing him. Thank you to our editor Sarah Grey, who had to

live with the consequences, and Kerin Forsyth and Kate Galloway for tidying every‐

thing up and actually getting it published.

Many friends and colleagues, and some lovely strangers, reviewed drafts ranging

from early and uncoordinated to tantalizingly nearly complete. Thank you to Yana

Afanasyeva, Jack Bolles, David Denton, Bruce Eckel, Dmitry Kandalov, Kevin Peel,

James Richardson, Ivan Sanchez, Jordan Stewart, Robert Stoll, Christoph Sturm,

Łukasz Wycisk, and Daniel Zappold and to our technical reviewers, Uberto Barbini,

James Harmon, Mark Maynard, and Augusto Rodriguez. We really appreciate all your

suggestions, encouragement, and candor.

Extreme Programming revolutionized the way that write software—we all owe a debt

of gratitude to Ward Cunningham and Kent Beck. Thank you also to Martin Fowler,

without whom this book might not have been written. In the UK the eXtreme Tues‐

day Club has been innovating on these ideas since 1999, and has attracted a cabal of

developers. We are lucky to have worked with, and learned from, many talented

members of this group. If you have a problem, if no one else can help, and if you can

find them, maybe you can hire them.

Duncan’s Bit

I don’t think my wife will ever understand what I do for a living, and there’s no

chance that she will read the rest of this book, but she will probably get this far. So

thank you, Jo McGregor, for putting up with me writing rather than spending time

with you, and talking about writing when I was spending time with you. I couldn’t

have done it without your support and encouragement. Thank you also to our two

wonderful sons, Callum and Alistair, who make us so proud.

Thank you to Vickie Kennish for taking a keen interest in becoming the mother of an

author, checking on progress during our COVID lockdown walks. My late father,

John, would I’m sure have played it more casual, but be bragging about the book to

his friends. Also gone but not forgotten is our beautiful cat Sweet Pea, who kept me

company through most of the writing but died just before it was finished.

The friendship and support of Robin Helliwell has been a constant throughout my

adult life. Likewise, my sister Lucy Seal, and many other family members too numer‐

ous to list individually. In my professional life, in addition to those who gave

feedback, thank you to Alan Dyke, Richard Care, and Gareth Sylvester-Bradley, all

influential and supportive beyond the call of duty.

xviii | Preface

剩余422页未读，继续阅读

yunquantong

粉丝: 723
资源: 82

会员权益专享

Java开发者转型指南：Java to Kotlin重构实战

一本代码重构的书让代码更简洁

Kotlin相关书籍

kotlin开发电子书

android java语言变kotlin

java转kotlin快捷键

java调用kotlin类,Kotlin和Java互相调用(二)

转换为kotlin代码

java和koTlin区别

android java转kotin代码

java和kotlin混编

kotlin java混合开发

将java代码转成kotlin public class MyService extends Service { @Override public void onCreate() { super.onCreate(); Context context = getBaseContext(); // TODO: 使用context对象进行操作 } }

java 怎么调用kotlin的suspend

java import kotlin

android kotlin转java

kotlin和java混合开发

kotlin转java工具

kotlin代码 "".encodeToByteArray().toList() 使用java代码实现

kotlin如何转换成Java

kotlin转换java

会员权益专享

最新资源