Programming

I was thinking the same thing, until I read Minecraft. Java mods...

Thank you! I will write those down for later reference :)

If you teach them factories in tyool 2024, I swear I will find you and I will take away every color compiler and runtime you have outside of Radio Shack Level 1 BASIC (TRS 80).

Sure! The course that finally worked for me is at Codecademy. I'm only doing the free content but it's broken down in ways I can understand, with immediate examples after the explanations. It has you create a small program after each short lesson and keeps slowly building up. There are hints for each task as well, which has helped me tremendously as well.

It reminds me of freeCodeCamp's courses, but for Java. It's also not so wordy (no offense to FCC), which is great for keeping my focus on the content.

I'm currently on the 'Learn Intermediate Java' course but I started with the 'Learn Java' course.

https://www.codecademy.com/learn/learn-java

Classes are Data plus the code required to modify that Data. The idea is to encapsulate data modifications into one thing (a Class) that knows how to modify all the Data as a single unit. This lets us write some code to describe, say, a Scrollbar widget. The Class for the widget combines all the Data for a Scrollbar (position, orientation, bar size, total size, etc) with the methods that read or modify that data (scroll up/down, change size, draw, etc).

That's the first Big Idea of OOP - that data should be grouped with the functions that modify it. If you don't have that - as in C - you have to write functions that only work on a given data type but which are namespaced separately. You get functions like void set_scrollbar_pos(void* scrollbar, word pos) which become verbose in a large project. (I'm not saying this is the worst thing in the world, just a different style.)

The second Big Idea of OOP is message passing. Now that we have code and Data bundled together, it would be nice if Objects that share functions of the same essential type and intention could be swapped out interchangeably. So instead of directly invoking a function on an Object, we send a 'message' that says something like 'if you know how, please draw yourself on screen, relative to X,Y'.

Of course, since plain English is hella verbose, the actual message is going be something like "draw, X,Y" and the Object receiving the message then sorts out if it has a method called "draw" that can use the provided X and Y. If so, it runs the code to do so. If not, you get an error.

Messages like this mean that you can swap out compatible Classes for one another. E.g. you can ask any collection of widgets to .draw themselves with a single method and let the compiler/interpreter generate the machine code as needed. That reduces the amount of boilerplate for engineers by a lot! Otherwise, trying to work with any collection of heterogeneous Objects (like a List of every Widget contained in a Window) would need to have essentially the same code rewritten for every different Type needed - a combinatorial explosion of code!

Tl;Dr -

• Classes help organize code and simplify state management by combining data with the functions that manipulate that data.

• Classes reduce the amount of boilerplate code needed by allowing methods with the same "shape" to be called interchangeably.

Everything else about OOP is essentially built off these two ideas. I hope that helps.

Don't forget kotlin

Probably my favourite of the java/c# family

"Fun" is in the eye of the beholder.

If OP is having fun with Java, that's awesome.

Java's not my favourite language either, but the only "nice" language on his list is C# and particularly if he was using it in a .NET context then it's got a steep learning curve:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Working with closures and run loops is a pretty rough starting point compared to other languages where you start with just print "Hello World". Those concepts are relatively simple for someone experienced but a beginner can easily hit a brick wall they can't climb over.