Lesson: Block Statement

Rooms on the shortest path to this room

Programming Land MOO Entry Way
Language Foyer
BASIC Foyer
BASIC Flow of Control
BASIC Looping Lesson
Curt's Loop Construction Tips
Return to Lessons
Java Looping Lesson
Flow of Control
Block Statement

Subordinate rooms and lessons:

Syntax of the Block Statement(#9039)
- More about the Block Statement(#9048)
Using the Block Statement(#9045)
Flow of Control(#12240)
- Java Foyer(#209)
  - Java History and Overview
  - Structured Data(#527)
    - Some Object Types(#386)
      - Java Variables and Expressions
      - Java ArrayLists and Arrays(#528)
        
        Why do we need arrays?(#523)
        
        Array Lists(#13837)
        
        Storing Numbers in Array Lists(#13749)
        
        Finding the Min and Max values(#13852)
        
        Counting Values(#13867)
        
        Searching Array Lists(#13863)
        
        Arrays(#13870)
        
        Copying Arrays(#13890)
        
        Using arrays(#535)
        
        Preparing Arrays for Use(#531)
        
        Array Declaration(#532)
        
        Sizing an Array(#533)
        
        Array Element Instantiation(#534)
        
        Default Values(#540)
        
        Whole Array Usage(#536)
        
        Array Element Usage(#537)
        
        Array Errors(#538)
        
        Removing Array Elements(#13893)
        
        Partially Filled Arrays(#13896)
        
        Array Data Size(#13925)
        
        Allocating more space(#13918)
        
        Migrating to a Larger Array(#13929)
        
        Inserting Array Elements(#13901)
        
        Array Reference vs. Array Copy(#13906)
        
        Array Reference Copy(#13909)
        
        Copying Arrays(#13912)
        
        Array Example(#13946)
        
        Array Bounds(#13843)
        
        Iteration through an Array List(#13846)
        
        Array List Declaration(#13849)
        
        Why use an ArrayList?(#13875)
        
        ArrayList Example(#13943)
        
        Summary(#13830)
    - Designing Classes(#13920)
      - Defining classes and methods(#13921)
        
        Choosing Classes(#13982)
        
        What is a bad candidate for a class?(#13985)
        
        Cohesion(#13988)
        
        Example(#13993)
        
        Minimizing Coupling(#13996)
        
        Low Coupling(#14003)
        
        UML(#13999)
        
        CRC Cards(#14009)
        
        CRC Card Contents(#14012)
        
        Creating CRC Cards(#14015)
        
        CRC Cards Example1(#14021)
        
        High Coupling(#14006)
        
        Accessor and Mutator Methods(#14028)
        
        Accessors and Mutators Example(#14034)
        
        Side Effects(#14031)
        
        Side-effect Example1(#14038)
        
        Side-effect Example2(#14041)
        
        Classification of Methods by Side Effects(#14044)
        
        Modifying Primitive Parameters(#14048)
        
        Call by Value and Call by Reference(#14051)
        
        Modifying Object Parameters(#14054)
        
        Changing Parameter Variables(#14062)
      - Summary and Definitions(#14057)
      - Precondition(#14066)
        
        Precondition ...continued(#14073)
        
        Throwing an Exception(#14076)
        
        Exception Throwing vs. return(#14079)
        
        Postcondition(#14082)
        
        Documenting Pre- and Postcondition(#14088)
        
        Class Invariants(#14091)
        
        More on Class Invariants(#14094)
        
        Documenting the class invariant(#14097)
      - Organizing Classes into Packages(#14085)
        
        Important Packages in the Java Library(#14216)
        
        Importing Packages(#14224)
        
        Package Names(#14235)
        
        How Classes are Located(#14239)
        
        Base Directories and Subdirectories for Packages(#14242)
      - Static Methods and Variables(#14186)
        
        Static Methods(#14070)
        
        Static Method Example(#14101)
        
        Calling a Static Method(#14108)
        
        Static Variable Initialization(#14166)
        
        Static Variable Example(#14169)
        
        Static Field and Instance Fields(#14232)
        
        Static Initialiation Block(#14173)
        
        Static Variables and Side Effects(#14179)
        
        Example of Bad Use of Static Variables(#14182)
        
        Scope(#14203)
        
        Shadowing(#14193)
        
        Scope of Class Members(#14202)
        
        Scope of Local Variables(#14212)
        
        Scope and Block Statements(#14206)
        
        Overlapping Scope(#14214)
        
        Calling one constructor from another(#14221)
  - Introduction to Applets(#3559)
    - String Declaration(#3031)
      - More about strings(#10063)
        
        Strings(#10100)
        
        Objects(#10097)
        
        Variables(#10016)
        
        Writing to the console(#9888)
        
        Method Redefinition(#9913)
        
        Class Declaration(#9997)
        
        Classes and files(#2321)
        
        Compilation Units(#10007)
        
        API Documentation(#9872)
        
        Comments in Programs(#9903)
        
        Block Comments(#9905)
        
        Single Line Comments(#9908)
        
        Documentation Comments(#9984)
        
        Main Function(#10000)
        
        Command line parameters(#12346)
        
        Accessor and Mutator Methods(#12378)
        
        print and println(#10014)
        
        Variable Characteristics(#10031)
        
        Variable declaration(#10034)
        
        Operators(#10037)
        
        Integer operations(#10074)
        
        Real operators(#10077)
        
        Other operators(#10080)
        
        Declaration again(#10086)
        
        Initialization(#10091)
        
        Changing the value of a variable(#10094)
        
        What is a variable?(#10065)
        
        Variable Name(#10068)
        
        Reserved Words(#10056)
        
        Variable Type(#10071)
        
        Primitive Types(#10119)
        
        Constant and Numeric Types(#10122)
        
        Real constants(#10125)
        
        Non-Numeric constants(#10128)
        
        Why do we need variables?(#10113)
        
        UsingObjects125aWebSlideRoom(#11076)
        
        Object References(#12371)
        
        String Operations(#10106)
        
        Other operations(#10109)
    - Applications and Applets
    - Hyper Text Markup Language
    - Important Applet Methods
    - Graphics Methods
    - Applet Parameters(#9329)
    - Applet Examples(#9378)
      - Event Demonstration(#9389)
      - Font Demo Applet Example(#9449)
  - More on Variables and Data Types(#10304)
    - Math Functions(#10381)
      - Math Class(#10393)
        
        Example Program(#10395)
        
        What do you need to know?(#10398)
        
        Math Methods(#10401)
        
        Example Uses(#10407)
        
        Example Program 2(#10410)
        
        One Last Thought(#10412)
      - Introduction to Static Methods(#11859)
        
        More on Strings(#12655)
        
        Scanner Class(#12658)
        
        nextInt/nextDouble methods(#12746)
        
        nextLine/next methods(#12749)
        
        length method(#12729)
        
        Concatenation(#12732)
        
        parseInt/parseDouble methods(#12735)
        
        substring method(#12738)
        
        String position(#12703)
        
        More on static methods(#12719)
        
        Naming convention(#12723)
      - More on Operators(#12646)
        
        Assignment Statement and Operator(#10046)
        
        Assignment Statement(#10041)
        
        Precedence(#10131)
        
        Algebra and the Assignment Statement(#10134)
        
        Assignment Operator(#10137)
        
        Side-Effect Operator(#10155)
        
        Another property of operators(#10157)
        
        Associativity(#10160)
        
        Assignment Operator Properties(#10163)
        
        Precedence Chart Again(#10166)
        
        Equations and Assignments(#10172)
        
        Example(#10178)
        
        How does it work?(#10181)
        
        More about Precedence(#10146)
        
        Precedence Chart(#10152)
        
        What is an expression?(#10140)
        
        General rules(#10185)
        
        Example(#10064)
        
        Side Effect Operators(#10143)
        
        Unary Side-effect Operators(#10189)
        
        Increment Operator(#10193)
        
        Decrement Operator(#10196)
        
        Example(#10199)
        
        Miscellaneous Rules(#10202)
        
        More Side Effect Operators(#10205)
        
        Compound Assignments(#10208)
        
        Example Expression(#10225)
        
        Slightly Different Example(#10227)
        
        Precedence(#10214)
        
        Precedence Chart Revisited(#10211)
        
        Example(#10217)
        
        Avoid Expressions of the type(#10232)
        
        More on Constants(#12627)
        
        More on primitive types(#12626)
        
        Casts(#9994)
        
        Example(#10345)
        
        Conversions(#10347)
        
        When to use conversion?(#10349)
        
        Java Cast(#10351)
        
        2/3 Problem Solved(#10340)
        
        More on Casts(#10359)
        
        Observations(#10368)
        
        What is the fix?(#10370)
        
        Rounding(#10373)
        
        Rounding errors(#12666)
        
        Overflows(#12663)
        
        Keyword final(#12680)
        
        Convention(#12683)
        
        Static constants(#12686)
        
        Math class and its constants(#12689)
  - Basics of Java(#11952)
    - Classes and Their Implementation(#12450)
      - Encapsulation(#12453)
        
        Designing Class(#12484)
        
        Testing a Class(#12487)
        
        Variable Categories(#12490)
        
        Method Parameters(#12493)
        
        First difference-life time(#12601)
        
        Second difference-initialization(#12604)
        
        Life time of instance field(#12609)
        
        Life time of local and parameter varaibles(#12612)
        
        Test class(#12591)
        
        Application program(#12594)
        
        Process of designing a new class(#12511)
        
        Method definition(#12515)
        
        Structure of a method(#8266)
        
        More on Method Definition(#12554)
        
        Constructor definition(#12533)
        
        Class definition(#12536)
        
        Commenting the public interfaces(#12539)
        
        More on documentation(#8274)
        
        Instance fields(#12542)
        
        More on instance fields(#8259)
        
        More on encapsulation(#12529)
        
        Implementing Constructors and Methods(#12545)
        
        Implementing Constructors(#8269)
        
        Implementing methods(#12571)
        
        Implementing accessor method(#12585)
        
        How Constructors work(#12576)
        
        Black Boxes(#12498)
        
        Abstraction(#12501)
        
        Old Times(#12504)
        
        Modern Times(#12507)
  - Flow of Control Statements(#13127)
    - Decision statements(#13058)
      - If-statement(#13137)
        
        Example why we need an If(#13143)
        
        Form of the If-statement(#13146)
        
        If with multiple conditions(#13149)
        
        Body of an If(#13155)
        
        Simple, compound and block statements(#12863)
        
        Structured Programming(#13187)
        
        Object-Oriented Programming(#13178)
        
        About Conditions(#13152)
        
        Comparisons(#13159)
        
        Boolean Operators(#13167)
        
        Boolean Operators Truth Table(#13271)
        
        De Morgan's Law(#13301)
        
        Differences between C++ and Java conditions(#13274)
        
        Precedence of Java Operators(#13298)
        
        Relational Operators(#13312)
        
        Common Comparison Errors(#13266)
        
        Mixed-mode Comparisons(#13169)
        
        Comparing Strings(#13283)
        
        Lexicographic Comparison(#13292)
        
        Testing for null(#13348)
        
        Testing for Null Example(#13712)
        
        Comparing Floating-point Numbers(#13171)
        
        How to compare doubles(#13269)
        
        Evaluation of Boolean Expressions(#13354)
        
        Boolean Variables(#13308)
        
        If Reserved Words(#13315)
        
        Why condition order matters?(#13161)
        
        If Examples and Guidelines(#13257)
        
        Matching if and else(#13347)
        
        Testing(#13349)
        
        Testing Every Path(#13357)
        
        How ifs increase paths(#13360)
        
        Largest of three variables(#13363)
        
        Example If Code(#13261)
        
        Another Example(#13324)
      - Switch Case Statement(#13140)
        
        When do we need a switch statement?(#13350)
        
        example Switch Case(#13368)
        
        Syntax of the Switch Case(#13371)
        
        Break statement(#13374)
        
        Examples of Switch code(#13377)
        
        Final notes on the Switch(#13380)
        
        Day of the Week Example(#13421)
        
        Illegal expression types in a Java Switch(#13424)
        
        Enumeration as a Switch Expression(#13432)
        
        Switch Reserved Words(#13393)
        
        Switch Expression(#13396)
        
        Case Label and Following statements(#13399)
        
        Case Statements(#13367)
        
        Compound Statement(#13402)
    - Looping statements
    - Compound Statement(#13181)
      - Syntax of the Compound Statement(#13226)
        
        Scope of Variables(#13229)
        
        More on Scope of Variables(#13225)
        
        Scope Example(#13241)
        
        Duplicate Variables(#13246)
        
        Overlapping Scope(#13248)
        
        Duplicate Variable Example(#13250)
        
        Using the Compound Statement(#13232)
        
        Example Use of block statements(#13254)
    - Introduction to Flow of Control(#13185)
      - History of Flow of Control(#13174)
      - Structured and Object Oriented Programming(#13176)
        
        Summary of Structured Programming(#13205)
        
        What is Structured Programming?(#13197)
        
        Sequential Statements(#13199)
        
        Decision Statements(#13201)
        
        Iteration or Loop Statements(#13203)
        
        Statement Blocks(#13218)
        
        Flow Chart of a Loop(#13327)
        
        Flow Chart of a Decision Statement(#13330)
        
        Flow Chart of Sequential Statement(#13323)
- Decision Statements
- Introduction to Flow of Control(#9038)
  - History of Flow of Control(#7635)
    - What is Structured Programming?(#2724)
      - Sequential Statements(#9010)
        
        Decision Statements(#9013)
        
        Looping Statements(#9016)
        
        Statement Blocks(#9022)
        
        Summary of Structured Programming(#9028)
    - Structured Programming and Object Oriented Programming(#9033)
  - Structured and Object Oriented Programming(#9072)

Return to the top lesson page.

Index of lessons.

This page created on 8/22/2006