Get Started. It's Free
or sign up with your email address
Rocket clouds
Java by Mind Map: Java

1. BlueJ

1.1. Chapter 3

1.1.1. To open a project, select Open from the Project menu.

1.1.2. To create an object, select a constructor from the class popup menu.

1.1.3. To execute a method, select it from the object popup menu.

1.1.4. To edit the source of a class, double-click its class icon.

1.1.5. To compile a class, click the Compile button in the editor. To compile a project, click the Compile button in the project window.

1.1.6. To get help for a compiler error message, click the question mark next to the error message.

1.2. Chapter 4

1.2.1. Object inspection allows some simple debugging by showing an object’s internal state.

1.2.2. An object can be passed as a parameter to a method call by clicking on the object icon.

1.3. Chapter 5

1.3.1. To create a project, select New... from the Project menu

1.3.2. To create a class, click the New Class button and specify the class name.

1.3.3. To create an arrow, click the arrow button and drag the arrow in the diagram, or just write the source code in the editor

1.3.4. To remove a class or an arrow, select the remove function from its popup menu.

1.4. Chapter 6: Code Pad

1.4.1. To start using the code pad, select Show Code Pad from the View menu. (CTRL-E)

1.4.2. To evaluate Java expressions, just type them into the code pad.

1.4.3. To transfer objects from the code pad to the object bench, drag the small object icon.

1.4.4. To inspect result objects in the code pad, double-click the small object icon.

1.4.5. Statements that are typed into the code pad are executed

1.4.6. Use shift-Enter at the end of a line to enter multi-line statements.

1.4.7. Local variables can be used in single, multi-line statements. The names of objects on the object bench serve as instance fields.

1.4.8. Use up-arrow and down-arrow keys to make use of the input history.

1.5. Chapter 7: Debugging

1.5.1. To set a breakpoint, click in the breakpoint area to the left of the text in the editor.

1.5.2. To single-step through your code, use the Step and Step Into buttons in the debugger.

1.5.3. Inspecting variables is easy – they are automatically displayed in the debugger.

1.5.4. Halt and Terminate can be used to halt an execution temporarily or permanently.

1.6. Chapter 8: Stand-alone applications

1.6.1. To create a stand-alone application, use Project - Create Jar File...

1.7. Chapter 9: Creating applets

1.7.1. To run an applet, select Run Applet from the applet’s popup menu.

1.7.2. To create an applet, click the New Class button and select Applet as the class type.

1.8. Chapter 10: Other operations

1.8.1. Non-BlueJ packages can be opened with the Project: Open Non BlueJ... command.

1.8.2. Classes can be copied into a project from outside by using the Add Class from File... command.

1.8.3. Static methods can be called from the class's popup menu.

1.8.4. To generate documentation for a project, select Project Documentation from the Tools menu.

1.8.5. The Java standard class API can be viewed by selecting Help - Java Class Libraries.

1.8.6. To create objects from library classes, use Tools – Use Library Class.

2. Java itself

2.1. The Java Environment

2.1.1. Java Runtime Engine

2.1.2. Java Software Development Kit

2.1.3. Command line use

2.1.3.1. Path

2.1.3.2. CLASSPATH

2.1.3.3. javac

2.1.3.4. java

2.2. Java notes

2.2.1. Other features

2.2.1.1. import

2.2.1.2. packages

2.2.1.3. Java API

2.2.1.4. Jar files

2.2.1.4.1. Creating Jar Files

2.2.1.5. Javadoc

2.2.1.6. Exception handling

2.2.1.7. Applications vs. Applets vs. Servlets

2.2.2. Additional topics

2.2.2.1. Programming style

2.2.2.2. Debugging

2.2.2.3. Unit testing

2.2.2.3.1. Stepwise Development

2.2.2.4. Swing (GUI package)

2.2.2.5. Packages

2.2.2.5.1. Classpath

2.2.2.6. Compiler

2.2.2.6.1. Path

2.2.3. Solid-line points to superclass

2.2.3.1. Superclass is more general

2.2.3.2. Parent

2.2.3.3. "is-a"

2.2.3.4. "inherits from"

2.2.4. Dashed line points to the class of a data member

2.2.4.1. "has-a"

2.2.4.2. "uses"

2.2.4.3. always come from top or bottom and point to a side

2.2.5. Only subclasses of an abstract class can have instances

2.2.5.1. example: pets

2.2.6. BlueJ lets you test classes before the application is complete

2.2.7. document icon is README.TXT for project

2.2.8. structure above, instances below

2.2.8.1. "object bench"

2.2.9. Everything is an Object

2.2.10. Editor window has code and documentation views

2.2.10.1. Properly formatted comments generate documentation

2.2.11. Striped classes are not yet compiled

2.2.12. Inspector can view but not change

2.2.13. When we add lines between classes, how is each affected?

2.2.14. code pad

2.2.14.1. literals

2.2.14.2. object bench items

2.2.14.3. drag results to object bench

2.2.15. camelCase

2.3. Classes

2.3.1. Abstract Classes

2.3.2. Interfaces

2.3.3. Static variables and methods

2.3.4. Superclasses and Subclasses

2.3.5. Nested Classes

2.3.5.1. Anonymous Classes

2.3.6. Access

2.3.6.1. public

2.3.6.2. private

2.3.6.3. protected

2.3.7. Methods

3. Basic programming structures

3.1. Variables

3.1.1. Declarations

3.1.2. Primitive types

3.1.2.1. int

3.1.2.2. double

3.1.2.3. boolean

3.1.2.4. char

3.1.2.5. less common

3.1.2.5.1. float

3.1.2.5.2. long

3.1.2.5.3. short

3.1.2.5.4. byte

3.1.3. Objects

3.1.3.1. String

3.1.3.2. Array

3.1.4. Assignments

3.1.5. "new" operator

3.2. Blocks

3.3. Looping

3.3.1. for

3.3.2. while

3.3.3. do ... while

3.4. Conditional execution

3.4.1. if / then / else

3.4.2. switch / case

4. OO: Head First p. 32

4.1. Basics

4.1.1. Abstraction

4.1.2. Encapsulation

4.1.2.1. setters and getters

4.1.3. Polymorphism

4.1.4. Inheritance

4.1.4.1. Superclasses and Subclasses

4.2. Principles

4.2.1. Encapsulate what varies

4.2.2. Favor composition over inheritance

4.2.3. Program to interfaces, not implementations

4.2.4. Strive for loosely-couples designs between objects that interact

4.2.5. Classes: extendable but not modifiable

4.3. Patterns

4.3.1. Strategy

4.3.2. Decorator

4.3.3. Observer

4.3.4. Factory

4.3.5. Singleton

4.3.6. Model / View / Controller

5. Computational Thinking and Creating

5.1. Concepts

5.1.1. Sequences: series of steps

5.1.2. Loops: make the same thing happen multiple times

5.1.3. Parallelism: make multiple things happen at once

5.1.4. Events: one thing causes another to happen

5.1.5. Conditionals: make decisions based on conditions

5.1.6. Operators: math and logical expressions

5.1.7. Variables: storing and updating information

5.1.8. Lists: organize a collection of items

5.1.9. How can these concepts be taught without tying new students to a particular implementation?

5.2. Practices

5.2.1. incremental / iterative: do a little; try it out; do some more

5.2.2. testing / debugging: make sure things work; fix mistakes

5.2.3. re-using / re-mixing: build on what you or other have done

5.2.4. abstracting / modularizing: build a larger thing with smaller parts

5.3. Perspectives

5.3.1. expressing: I can create

5.3.2. connecting: I can do more when I

5.3.2.1. create with others

5.3.2.2. create for others

5.3.3. questioning: I can ask questions to make sense of the world (and how it works)

6. Expectations

6.1. There is no homework as such, but I strongly encourage you to get Greenfoot running and start using at home so that I can help you with any problems that may come up. I want you to be completely comfortable with it at home by the time this class is over.

6.2. I expect each of you to have a notebook or section of a notebook dedicated to this class. What notes you take about what I have to say is completely up to you, but I expect you to write something each week about what you are doing in class.