CS : Data Structures

Transcription

1 CS : Data Structures Michael Schatz Oct 3, 2016 Lecture 14: Machine Code Optimization

2 Assignment 5: Due Sunday Oct 10pm Remember: javac Xlint:all & checkstyle *.java & JUnit Solutions should be independently written!

3 Part 1: Machine Code Optimization

4 Intel Instruction Set Note: modern processors have hundreds of instructions

5 Intro to machine code compiler assembler

6 Java bytecode instructions

7 Java bytecode instructions

8 Reverse Engineering Bytecode $ od -x Mystery.class feca beba c00 000a c f a00 1d00 1e f a c a a a a a a 2b c c e 3e f f00 694c 656e 754e 626d c d 6e c5b a c2f 6e61 2f e b a00 6f c e e 6a2e c c2d 2e00 2f c a f61 616c e 532f e c a 000c c a69 0c b69 3a31 0c c39 3a b e a f61 616c 676e 4f2f 6a e00 616a c2f 6e61 2f67 614d f a f61 616c 676e 532f d f a4c f61 6f69 502f e d b e d 6a4c f61 616c 676e 532f e69 3b c29 616a c2f 6e61 2f e c b c a4c f61 616c 676e 532f e c b 1c c29

9 Reverse Engineering Bytecode $ od -x Mystery.class feca beba c00 000a c f a00 1d00 1e f a c a a a a a a 2b c c e 3e f f00 694c 656e 754e 626d c d 6e c5b a c2f 6e61 2f e b a00 6f c e e 6a2e c c2d 2e00 2f c a f61 616c Just Kidding J e 532f e c a 000c c a69 0c b69 3a31 0c c39 3a b e a f61 616c 676e 4f2f 6a e00 616a c2f 6e61 2f67 614d f a f61 616c 676e 532f d f a4c f61 6f69 502f e d b e d 6a4c f61 616c 676e 532f e69 3b c29 616a c2f 6e61 2f e c b c a4c f61 616c 676e 532f e c b 1c c29

10 Midterm Review

11 Part 1: Inheritance

12 Why Inheritance? Code Reuse Subclass gets to use all methods of the parent class for free Overriding Subclass can have more specific implementation than the parent class Design constraints Subclasses get all of the features of the parent, whether you like them or not! Saying B inherits from A is a very strong relationship: anytime that A could be used, B could be instead

13 Inheritance Types Single Inheritance Multilevel Inheritance Multiple Inheritance B isa A C isa B, B isa A C isa A, C isa B Square isa Rectangle Square isa Rectangle Rectangle isa Shape => Square isa Shape Does Java support multiple inheritance? Sort of, a class can implement multiple interfaces Mike isa CS Prof Mike isa Bio Prof

14 Inheritance versus Encapsulation Pokemon Trainer Position pos String name Should a ListStack inherit from Stack? String team Yep, a ListStack List<Pokemon> ISA Stack! List<Eggs> Backpack pack Position Double lat Double long Double altitude Backpack Int capacity List<Items> items Should a PokemonTrainer inherit from List? B isa A Nah, you wouldn t use a PokemonTrainer in all places that you would use a Square isa List, use encapsulation Trainer instead hasa Position, Rectangle Trainer hasa Backpack, etc Encapsulation is used to hide the values or state of a structured data object inside a class,

15 Part 2: Java Features

16 Primitive Data Types The 8 primitive data types supported by the Java programming language are: 1. byte: 8-bit signed two's complement integer: [-128, 127] 2. short: 16-bit signed two's complement integer: [-32,768, 32,767] 3. int: 32-bit signed two's complement integer: [-2 31, ] 4. long: 64-bit two's complement integer: [-2 63, ] 5. float: Single-precision 32-bit IEEE 754 floating point. Good for saving memory in large arrays of values. 6. double: Double-precision 64-bit IEEE 754 floating point. Default choice for decimal values 7. boolean: Two possible values: true and false. This data type represents one bit of information, but its "size" isn't something that's precisely defined. 8. char: The char data type is a single 16-bit Unicode character. Everything else is an Object Note there is an Object version of each primitive data type and Java will try to convert back and forth when you need it: int ó Integer, float ó Float, etc

17 Classes & Objects All java code must be in some class (and inside some package) (If no package name is listed, code goes into unnamed package) This helps organize code, and avoids naming conflicts: if your code defines a method print, and my code defines a method print specifying the class (and package) will clarify which one you mean However, we don t always want nor need an object to call a method: class MathStuff { public int max3(int a, int b, int c) { MathStuff stuff = new MathStuff(); int biggest = stuff.max3(42,14,99); Use the static keyword to tell the compiler that it is okay to call this method directly (without an object): class MathStuff { public static int max3(int a, int b, int c) { int biggest = MathStuff.max3(42,14,99);

18 Variables Instance Variables (Non-Static Fields) Values are unique to each instance of a class (to each object) Class Variables (Static Fields) Tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. Local Variables Similar to how an object stores its state in fields, a method can store its temporary state in local variables. Local variables are only visible to the methods in which they are declared Parameters Similar to local variables, although are passed in from other calling methods. Final Variables Final means the value can only be set once

19 Variables Instance Variables (Non-Static Fields) Values are unique to each instance of a class (to each object) Class Variables (Static Fields) Tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. Local Variables Similar to how an object stores its state in fields, a method can store its temporary state in local variables. Local variables are only visible to the methods in which they are declared Parameters Similar to local variables, although are passed in from other calling methods. Final Variables Final means How should the value you can store only the be currentspeed set once in a Bicycle class? How should you store Pi in a Math class?

20 Controlling Access Use access level modifiers to restrict access to methods and member variables (enforced by the compiler and JRE!) Access levels affect you in two ways: When you use classes that come from another source, such as the classes in the Java platform, access levels determine which members of those classes your own classes can use. When you write a class, you need to decide what access level every member variable and every method in your class should have.

21 Controlling Access Use access level modifiers to restrict access to methods and member variables (enforced by the compiler and JRE!) Access levels affect you in two ways: When you use classes that come from another source, such as the classes in Should the Java you platform, make all access your methods levels determine and fields which public? members of those classes your own classes can use. When No you way! write Try a class, to make you need access to decide as restricted what access as possible! level every member variable and every method in your class should have.

22 Nested Classes The Java programming language allows you to define a class within another class, a nested class class OuterClass {... class NestedClass {... Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are called inner classes. class OuterClass {... static class StaticNestedClass {... class InnerClass {...

23 Nested Classes The Java programming language allows you to define a class within another class, a nested class A nested class is a member of its enclosing class. As a member class OuterClass of the OuterClass, { a nested class can be declared private, public, protected,... or package private. class NestedClass {... Static nested classes do not have access to other members of the enclosing class. Like static methods, you would have to pass in an object reference Nested classes are divided into two categories: static and non-static. Nested classes that Non-static are declared nested static classes are called (inner static classes) nested classes. have Non-static access to nested other classes are called members inner of classes. the enclosing class, even if they are declared private. An instance of InnerClass can exist only within an instance of OuterClass class OuterClass {... static class StaticNestedClass {... class InnerClass {...

24 Introduction to Java Interfaces Objects define their interaction with the outside world through the methods that they expose. Methods form the object's interface with the outside world; the buttons on the front of your television set, for example, are the interface between you and the electrical wiring on the other side of its plastic casing. You press the "power" button to turn the television on and off. [ ] An interface is a group of related methods with empty bodies. interface Counter { int value(); void up(); void down(); + - specification: Counter has an integer value + button increments by 1 - button decrements by 1 Specification can be a separate documents or in the javadoc comments

25 Abstract Classes Abstract classes are analogous to interfaces, but with a partial implementation. An abstract class is a class that is declared abstract it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be subclassed. An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this: abstract void moveto(double deltax, double deltay); If a class includes abstract methods, then the class itself must be declared abstract, as in: public abstract class GraphicObject { // declare fields int x, y; // declare nonabstract methods abstract void draw();

26 Abstract Classes Consider An abstract using class abstract is a class classes that is if declared any of these abstract it statements may or apply may to not your include abstract methods. Abstract classes cannot be instantiated, but they situation: can be subclassed. You want to share code among several closely related classes. You expect that classes that extend your abstract class have many common An methods abstract or fields, method or is require a method access that modifiers is declared other without than public an implementation (such as (without braces, and followed by a semicolon), like this: protected and private). You want to declare non-static or non-final fields. This enables you to define methods abstract that can void access moveto(double and modify the deltax, state double of the object deltay); to which they belong. If a class includes abstract methods, then the class itself must be declared Consider abstract, using as in: interfaces if any of these statements apply to your situation: You public expect abstract that unrelated class GraphicObject classes would { implement your interface. For example, the // declare interfaces fields Comparable and Cloneable are implemented by many unrelated classes. // declare nonabstract methods You want to abstract specify void the behavior draw(); of a particular data type, but not concerned about who implements its behavior. You want to take advantage of multiple inheritance of type.

27 Java Generics Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types. Code that uses generics has many benefits over non-generic code: Stronger type checks at compile time. A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing compile-time errors is easier than fixing runtime errors, which can be difficult to find. Elimination of casts. The following code snippet without generics requires casting: List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0); When re-written to use generics, the code does not require casting: List<String> list = new ArrayList<String>(); list.add("hello"); String s = list.get(0); // no cast Enabling programmers to implement generic algorithms. By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.

28 Java Generics Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types. Code that uses generics has many benefits over non-generic code: Stronger type checks at compile time. A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing compile-time errors is easier than fixing runtime errors, which can be difficult to find. Elimination of casts. The following code snippet without generics requires casting: List list = new ArrayList(); list.add("hello"); String s = (String) list.get(0); When re-written to use generics, the code does not require casting: List<String> list = new ArrayList<String>(); list.add("hello"); String s = list.get(0); // no cast Enabling programmers to implement generic algorithms. By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.

29 Part 4: Make Lists Useful Again J

30 List Queue insertfront insertback addme.next = first; first = addme; last.next = addme; addme.next = null removefront removeback first = first.next;???

31 List v4 List l = new List<String>(); Position a = l.insertfront( Mike ); Position b = l.insertback( Peter ); Position c = l.insertfront( Kelly ); l.removeat(a); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); Position<T> insertfront(t t); Position<T> insertback(t t); // TODO: void is temporary void removeat(position<t> p); b a c List front Node Kelly next prev Node Mike next prev This interface protects the integrity of the List, but is weird in that we can have references Node to objects but cant get their value or do anything else with them except remove Peter them null next prev back null

32 List v5 public interface Position<T> { T get(); void put(t t); Hooray, now we can get/set the value from a Position public interface List<T> { private static class Node<T> implements Position<T> { Node<T> next; Node<T> prev; T data; List<T> color; public T get() { return this.data; public void put(t t) { this.data = t;... Why wouldn t you want to do it this way? What if you wanted a UniqueList<T> that only stored unique items? This would have to be checked in the UniqueList<T> implementation

33 List v6 public interface List<T> {... Position<T> front() throws EmptyListException; Position<T> back() throws EmptyListException; Position<T> next(position<t> p) throws InvalidPositionException; Position<T> previous(position<t> p) throws InvalidPositionException; boolean hasnext(position<t> p) throws InvalidPositionException; boolean hasprevious(position<t> p) throws InvalidPositionException; Why do we put next() and prev() into the list and not Position? boolean valid(position<t> p); For more complex data structures, like trees or graphs, next() and prev() will be more complicated

34 Iterator Interface public interface Iterator<T> { boolean valid(); void next(); // next element, not necessarily next T get(); // get ok, but put may break invariants public interface List<T> {... Iterator<T> forwarditerator(); Iterator<T> backwarditerator();... Iterator<String> i = list.forwarditerator(); while (i.valid()) { String e = i.get(); // do whatever with the element e i.next();

35 Iterator Interface private static class NodeListIterator<T> implements Iterator<T> { private Node<T> current; private boolean forward; NodeListIterator(Node<T> start, boolean forward) { this.current = start; Ternary operator: this.forward = forward; If (this.forward) { public boolean valid() { this.current = this.current.next; return this.current!= else null; { this.current = this.current.prev; public void next() { this.current = this.forward? this.current.next : this.current.prev; public T get() { return this.current.get();

36 Iterator Interface public Iterator<T> forwarditerator() { return new NodeListIterator<T>(this.front, true); public Iterator<T> backwarditerator() { return new NodeListIterator<T>(this.back, public void testforwarditerator() { list.insertback("peter"); list.insertback("paul"); list.insertback("mary"); String[] expected = {"Peter", "Paul", "Mary"; int current = 0; Iterator<String> i = list.forwarditerator(); while (i.valid()) { String e = i.get(); assertequals(expected[current], e); i.next(); current += 1; assertequals(3, current);

37 Iterator Interface public Iterator<T> forwarditerator() { return new NodeListIterator<T>(this.front, true); public Iterator<T> backwarditerator() { return new NodeListIterator<T>(this.back, public void testbackwarditerator() { list.insertback("peter"); list.insertback("paul"); list.insertback("mary"); String[] expected = {"Mary", "Paul", "Peter"; int current = 0; Iterator<String> i = list.backwarditerator(); while (i.valid()) { String e = i.get(); assertequals(expected[current], e); i.next(); current += 1; assertequals(3, current);

38 List v7 public interface List<T> extends Iterable<T> {... private static class NodeListIterator<T> implements Iterator<T> {... Iterator<String> i = list.iterator(); while (i.hasnext()) { String e = i.next(); // do something with element e for (String e: list) { // do something with element e

39 Living in a null world List List Node front null front Mike next prev null back back null List Node Node front Mike next prev Peter next prev null back null

40 Living in a null world public Position <T> insertback(t t) {... if (this.back List!= null) { List Node this.back.next = n; public Position <T> insertfront(t t ) {... if (this.front == null) { Mike null if (this.front!= null) { this.front front = n; null this.front.prev next =n; prev... if (this.back==null) { this.back null = n; back back... List Node Node public void removeat(position<t> p) { Mike Peter null... if (n.next front!= null) next { n.next.prev next = n.prev; if (n.prev!= null) prev { n.prev.next = n.next;... null back

41 Doubly Linked List with Sentinels List Node Node first f next prev b next prev null last null

42 Doubly Linked List with Sentinels List Node Node Node first f next prev 1 next prev b next prev null last null

43 Doubly Linked List with Sentinels List Node Node Node Node first f next prev 1 next prev 2 next prev b next prev null last null For the cost of a tiny bit of extra memory, the code gets significantly simpler!

44 Part 4: Midterm Review!

45 Next Steps 1. Reflect on the magic and power of Sentinels! 2. Work on Assignment 5: Due Sunday Oct 10:00 pm 3. Start to review for Midterm on Monday Oct Your notes from class 2. Lecture Notes on Piazza 3. Slides on course webpage 4. Online & printed textbooks 5. Sample Midterm!!!

46 Welcome to CS Questions?