From cc6fdd14f24904e4f340c95377b6cac8bf26d7c4 Mon Sep 17 00:00:00 2001 From: David Van Horn Date: Mon, 14 May 2018 23:48:59 -0400 Subject: [PATCH] Start of lec 9. --- 2/www/lectures/8.scrbl | 6 +- 2/www/lectures/9.scrbl | 198 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 199 insertions(+), 5 deletions(-) diff --git a/2/www/lectures/8.scrbl b/2/www/lectures/8.scrbl index 80be46ca..cc44ea87 100644 --- a/2/www/lectures/8.scrbl +++ b/2/www/lectures/8.scrbl @@ -8,6 +8,8 @@ @link["https://umd.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=41c2986c-d55e-4548-b43f-a8820148000b"]{Video}. +@bold{Introducting Java Syntax} + You've now seen several programming languages: BSL, ISL, ISL+, and @tt{class/0}. Now time for one more: Java. Let's start by looking at the @emph{syntax}, the way Java programs are written. @@ -172,6 +174,8 @@ within a programming environment, like DrRacket but for Java, or use a Java @emph{compiler} and run the Java interpreter from the command line. These will be covered in demos in class. +@bold{Grammar: Simplest Java} + Taking a step back, we can characterize the syntax of Java, or at least the small bit of Java we've covered so far, with the following @emph{grammar}: @@ -215,4 +219,4 @@ least the small bit of Java we've covered so far, with the following (list @nonterm{meth-name} @nonterm{id}) (list @nonterm{field-name} @nonterm{id}) (list @nonterm{id} - @elem{any name except for reserved words like @litchar{class}, @litchar{this}, @litchar{return}, etc.})]) \ No newline at end of file + @elem{any name except for reserved words like @litchar{class}, @litchar{this}, @litchar{return}, etc.})]) diff --git a/2/www/lectures/9.scrbl b/2/www/lectures/9.scrbl index df078009..c29d535a 100644 --- a/2/www/lectures/9.scrbl +++ b/2/www/lectures/9.scrbl @@ -1,13 +1,203 @@ #lang scribble/manual -@(require scribble/eval - racket/sandbox - (for-label (only-in lang/htdp-intermediate-lambda define-struct ... check-expect)) +@(require (for-label (only-in lang/htdp-intermediate-lambda define-struct ... check-expect)) (for-label (except-in class/0 define-struct ... check-expect)) (for-label class/universe) + scribble/bnf "../utils.rkt") @lecture-title[9]{Union, Interfaces, and Lists in Java} @link["https://umd.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=15905f29-3a7a-4f9e-92a6-a88601577373"]{Video}. -TBD. \ No newline at end of file +@bold{An IDE for Java} + +We're going to be using the IntelliJ integrated development +environment (IDE) to develop and run Java programs. Like DrRacket, it +will provide useful features to help us in the process of developing +programs. + +We'll do a short demo in class and in lab. + +@bold{Unions in Java: Traffic Lights} + +Let's now turn back to modelling information in Java. So far we've +seen how to represent compound data such as coordinates. Another +common kind of data definition is a @emph{union} data definition. +Let's look at a very simple union data definition (that we first +looked at in @racket[class/0]: traffic lights. + +We define the union of objects in terms of their interface; the method +signatures that each variant of the union has in common. In +@racket[class/0] this takes the form: + +@class-block{ +;; A Light implements +;; +;; Compute the next traffic light after this one +;; next : -> Light +} + +In Java, this interface definition looks like this: +@java-block|{ +interface Light { + // Compute the next traffic light after this one + Light onTick(); +} +}| + +In @racket[class/0], we would define a class and declare it implements +the interface in a comment. In Java, we can declare the intention to +implement the interface as part of the class definition: + +@java-block|{ +class Red implements Light { + Red() {} +} +}| + +@bold{Nullary Constructor by Default.} Note the @java{Red} +constructor takes no arguments and does nothing, which is what we want +since there are no fields in the @java{Red} class. As a side note: we +can omit this @emph{nullary} constructor, since it is the default +constructor Java will use if no constructor is defined. + +@java-block|{ +class Red implements Light {} +}| + +Now, this class @emph{says} that it implements the @java{Light} +interface, but so far it has not actually defined the @java{next} +method as required by the @java{Light} interface. + +The Java type system will catch this error for us. If you tried to +compile this program as-is, there would be a compile-time error: + +@centered{Error: Red is not abstract and does not override abstract +method next() in Light.} + +In the IDE, this static error is often indicated with a red squiggly +underlining of the class definition. + +Let's make a stub for @java{next} method: + +@java-block|{ +class Red implements Light { + // Compute the next traffic light after this red light + Light next() { + return this; + } +} +}| + +@bold{Visibility modifiers.} As a small wrinkle, we need to place a +@emph{visibility modifier} on this method indicating that the method +can be invoked from outside of the methods in this class: +@java-block|{ +class Red implements Light { + // Compute the next traffic light after this red light + public Light next() { + return this; + } +} +}| + +This @java{public} keyword is the visibility modifier. Using it here +indicates that @java{next} can be called from outside of the +@java{Red} class, which is (implicitly) what's required by the +interface. The are also visibility modifiers @java{private} and +@java{protected}. We will mostly ignore visibility issues for now and +assume that methods are public and fields are private. We will add +modifiers when needed to make programs type-check. For more details, +see the +@link["https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html"]{Oracle +tutorial}. + +We can define the other variants of @java{Light}, with method stubs: +@java-block|{ +class Red implements Light { + // Compute the next traffic light after this red light + public Light next() { + return this; + } +} + +class Yellow implements Light { + // Compute the next traffic light after this yellow light + public Light next() { + return this; + } +} + +class Green implements Light { + // Compute the next traffic light after this green light + public Light next() { + return this; + } +} +}| + +Thinking through some examples, it's easy to come up with the correct +code for the method definitions: + +@java-block|{ +class Red implements Light { + // Compute the next traffic light after this red light + public Light next() { + return new Green(); + } +} + +class Yellow implements Light { + // Compute the next traffic light after this yellow light + public Light next() { + return new Red(); + } +} + +class Green implements Light { + // Compute the next traffic light after this green light + public Light next() { + return new Yellow(); + } +} +}| + +So now we've seen our first union data definition in Java. + +@bold{Grammar: Java with Interfaces} + +The grammar of Java programs has grown some now. In particular a +program now consists of some number of class @emph{or interface} +definitions. Since a set of objects may be defined as either a class +or interface, we use @nonterm{type-name} to range over things defined +as classes or interfaces. The grammar is also updated to have +optional visibility modifiers on method definitions. Here are the +revised parts of the grammar (only): + +@(let ([open @litchar|{{}|] + [close @litchar|{}}|]) + @BNF[(list @nonterm{program} + @kleenestar[@nonterm{class-or-intf-defn}]) + (list @nonterm{class-or-intf-defn} + @nonterm{class-defn} + @nonterm{intf-defn}) + (list @nonterm{intf-defn} + @BNF-seq[@litchar{interface} @nonterm{int-name} open @nonterm{method-sigs} close]) + (list @nonterm{field-decl} + @BNF-seq[@nonterm{type-name} @nonterm{field-name} @litchar{;}]) + (list @nonterm{method-sigs} + @BNF-seq[] + @BNF-seq[@nonterm{method-sig} @litchar{;} @nonterm{method-sigs}]) + (list @nonterm{method-sig} + @BNF-seq[@nonterm{type-name} @nonterm{meth-name} @litchar{(} @nonterm{param-list} @litchar{)}]) + (list @nonterm{method-defn} + @BNF-seq[@optional{@nonterm{vis-modifier}} @nonterm{method-sig} open + @litchar{return} @nonterm{expr} @litchar{;} + close]) + (list @nonterm{vis-modifier} @litchar{public} @litchar{private}) + (list @nonterm{type-name} @nonterm{class-name} @nonterm{intf-name}) + (list @nonterm{intf-name} @nonterm{id})]) + +@bold{Recursive Unions in Java: Lists} + +TBD \ No newline at end of file