Reddit Reddit reviews Core Java Volume I--Fundamentals (10th Edition) (Core Series)

We found 9 Reddit comments about Core Java Volume I--Fundamentals (10th Edition) (Core Series). Here are the top ones, ranked by their Reddit score.

Computers & Technology
Books
Computer Programming
Software Design, Testing & Engineering
Object-Oriented Design
Core Java Volume I--Fundamentals (10th Edition) (Core Series)
Pearson Prentice-Hall Prof
Check price on Amazon

9 Reddit comments about Core Java Volume I--Fundamentals (10th Edition) (Core Series):

u/kradef · 6 pointsr/learnjava

Cay S. Horstmann
Core Java Volume I--Fundamentals

https://www.amazon.com/Core-Java-I-Fundamentals-10th/dp/0134177304

u/GreyDeck · 6 pointsr/java

I liked "Core Java", but it is not as concise as Kernighan/Ritchie.

u/samort7 · 6 pointsr/learnprogramming

I feel like this thread is related to this thread that was posted recently. I'll cross-post my suggestions from that thread:

The book was published in 2005. It's 13 years old. If you're looking to learn Java, there are plenty of excellent resources that also cover the latest features of the language:

u/hem10ck · 5 pointsr/learnprogramming

I was gonna say the same. You'll get much more bang for your buck and a much more wholistic and comprehensive understanding by just grabbing a book like Core Java Fundamentals.

Core Java Volume I--Fundamentals (10th Edition) (Core Series) https://www.amazon.com/dp/0134177304/ref=cm_sw_r_cp_api_BO7oxbBAE9CXE

u/I_make_ur_toe_Curler · 2 pointsr/UCalgary

Computer Science is not about programming so if you worried about programming don't be! When I program I am usually googling most of the times lol. For example when I forget how to initialize an array in Java I will quickly reference the Oracle documentation online here.

This book is REALLY good! I use it all the times as a reference and it explains the concepts really well without all the bullshit that introductory books use such as weird cartoons or sample programs. I remember when I first took the introductory Java course at UofC I did okay but I never got a deep understanding of the language.

So in the Spring/Summer break I read this book and it cleared up a lot of things. Now I use it when ever I need to refresh up on a topic such as Interfaces in Java. Most of the computer science courses you will take in the future will require you to know the basics such as control statements and that's about it actually.

NOTE: I've only probably written at most 1000 lines of Java code during my undergrad in computer science, excluding assembling of course and my side projects.

EDIT:
TIPS:

1). Learn the basics of object orientated programming (use the book mentioned above) and then play around with an API such as the Java Swing API. I learned a lot! I learned how to MVC and structure my code. Its one thing to write code for a school assignment but it's a whole entire other thing if you plan on making a fully functional program. You will also get a good feeling for how GUI code is structured through out most software application.

2). Join the Problem Solving Club. You will get a deeper insight into solving and thinking about certain problems.

3). Have side project! Like make a basic game or a program that can do basic things such as open and edit files BUT with added complexity like implementing an actually user interface using an API such as the swing library in Java.

4). If you learn enough Java consider playing around with Android development. You will learn a lot and in some courses they actually make use of mobile development so you will be one step ahead of everybody else.

Good Luck!

u/ziptofaf · 2 pointsr/learnprogramming

Ah! You have few options available then:

Helsinki's university MOOC:

https://moocfi.github.io/courses/2013/programming-part-1/

And two popular and often recommended books, you should be able to find them at your local university bookstore easily (even if you live outside US, at least Horstmann book is available in multiple languages):

https://www.amazon.com/Introduction-Programming-Structures-Comprehensive-Version/dp/0134670949

https://www.amazon.com/dp/0134177304

u/phao · 2 pointsr/java

I've heard good things about these two:

u/seanprefect · 2 pointsr/learnjava

Interfaces are often hard to understand, that's more a java thing than an OOP thing. As far as books go this one

https://www.amazon.com/Core-Java-I-Fundamentals-10th/dp/0134177304/ref=la_B000AQ1QDY_1_1?s=books&ie=UTF8&qid=1519328730&sr=1-1

is written by the same guy who wrote the java textbook i learned from (but that was like java 5 so my exact book would be out of date, this is up to date) I haven't read this one but going by how much I like my text book i'd imagine it's pretty good.


Going into interfaces and inheritance I'll attempt to provide a more approachable explanation. So classes can be sub classes of another object. This has 2 important affects.

First the subclass can access the properties and methods of its parent, this is useful for many reasons. You don't have to change every class when you want to make a change to some aspect, it also helps keep any given class from getting too large and complicated.

But the second important affect of being a subclass is that it allows other classes to know what a class can or can not do. So for example lets i have a class called animal, and it has the subclass dog, and I have another class called home which has a method that expects an animal. Since dog is a subclass of animal my home class knows it can treat dog like an animal. which involves casting the dog to animal, basically you're telling the JVM "Until i tell you otherwise treat this dog as just an animal" so after that casting you've got a dog but it's only treated as an animal (until you cast it back to dog) this is called polymorphism.

now the thing about subclassing , in java you can only be the child of one class, (this is a java thing not a general OOP thing, different languages have different approaches and there are pros and cons) but what if you want multiple superclasses ?

This is where we have interfaces. Implementing an interface basically promises the JVM that the methods that exist in the interface exist in the class. This means that you can treat classes that implement the interface the same way because you have a list of what you can do with the class , but you don't really make it a proper child of the class.