Object Oriented Programming with Java

Some basic core concepts of object oriented programming.

Transcript

1. Object Oriented Programming with Java Jussi Pohjolainen
2. OO CONCEPTS
3. Intro to OO • Object Orientated programming is a programming paradigm. • One way of describing the structure of the application • Several paradigms available. – Procedural, Functional, ... • OO is nowdays one of the most popular. – C++ – Java – C# – PHP 5 – ...
4. Benefits • Reusability – Once you written code, you can reuse it! • Management – Application is programmed using classes and objects. Pieces that communicate with each other. • Maintanence – When changing the code, it does not influence the whole application.
5. Basic Concept: Object • In real life, the world consists of objects: – cars, buildings, trees, ships, humans, flowers.. • Every object has actions (=methods!) that can incluence other objects – jack drives ferrari. – Object jack has a method drive that influences some way to object ferrari. – jack.drive(ferrari); • In OO, you should implement the app so that it consists of objects that influence each other!
6. Example about an Object • Datsun 100A is an object • Datsun 100A has different actions or methods: drive, brake, park... • Datsun 100A has information or attributes: color, amount of gears, amount of doors...
7. Basic Concept: Class • Class is a blueprint or template of an object • Class describes the state and behaviour to it's objects. • Object is created from the class.
8. Example about an Class • If Datsun 100A is an object, Car is a class. • If one wants to create Datsun 100A, you have to have first the blueprints of the Datsun. • Blueprints of an object: Class • Class Car -> Object Datsun 100A
9. Examples: Class to Object Class Object Car datsun 100a Human Jack Bauer Color red Laptop MacBook Pro String "some string" Array {1,2,3,2,4} ... ...
10. Class and Object • Car - class Datsun 100A Lamborghini Diablo Peugeot 406
11. Car's Blueprint • When building a Car's blueprint (class), you have to think that what is similar in all car's • So what is similar in datsun, lamborghini and peugeot?
12. Objects datsun, lambo, peugeot • datsun: – brand: Datsun 100A , motor: 1.0, fuzzy dices: yes, color: red • lambo – brand: Lamborghini Diablo, motor: 8.0, fuzzy dices: no, color: punainen • peugeot – brand: Peugeot 406, motor: 2.2, fuzzy dices: no, color: blue
13. Car's Blueprint (Class) in UML Car brand motor amountOfDoors color hasFuzzyDices . .
14. From Class to Object datsun Datsun 100A 1.0 3 red true lambo Lamborghini Diablo 8.0 3 red false Car brand motor amountOfDoors color hasFuzzyDices . .
15. Car-class, extension Car brand motor amountOfDoors color hasFuzzyDices drive park brake
16. Class • Class is a template or blueprint to object • Class holds – Attributes (=variables) – Actions (=methods) • Class instances are called objects
17. CLASSES AND OBJECTS IN JAVA
18. Person Class to Objects george George Smith 40 Teacher 09-12345 Jack Jack Puupää Person firstname lastname age profession phonenumber eat sleep drinkBeer eat sleep drinkBeer
19. Person firstname lastname age profession phonenumber eat sleep drinkBeer Person – class to Java class Person { public String firstname; public String lastname; public int age; public String profession; public int phonenumber; public void eat() { System.out.println("Eating!"); } public void sleep() { System.out.println("Sleeping!"); } public void drinkBeer() { System.out.println("Drinking!"); } }
20. From Class to Object • App always starts from the main-method • Let's test the Person – class • This creates a variable a which type is integer – int a; • This creates a object jack which type is Person – Person jack;
21. From Class to Object class Person { .... } class JustTesting { public static void main(String [] args) { // Declare the object Person jack; // Initialize the object jack = new Person(); jack.firstname = "Jack"; jack.lastname = "Smith"; jack.drinkBeer(); } }
22. Example: Car - class class Car { public String brand; public int amountOfGas; public void drive() { amountOfGas--; } }
23. Creating Objects From the Class class Car { .... } class JustTesting { public static void main(String [] args) { Car datsun = new Car(); datsun.amountOfGas = 100; datsun.drive(); System.out.println(datsun.amountOfGas); Car ferrari = new Car(); ferrari.amountOfGas = 300; ferrari.drive(); System.out.println(ferrari.amountOfGas); } }
24. About Attributes • Attributes are usually marked as private • The reason for this is that other objects cannot change the values as they will • You don't for example want that every object in the world can change person's weight to 500kg...
25. Example: Person - class class Person { private String name; private int weight; }
26. class Person { private String name; private int weight; } class JustTesting { public static void main(String [] args) { Person jack = new Person(); jack.name = "Jack Smith"; jack.weight = 500; } } RESULT: TB308POHJUS-L-2:temp pohjus$ javac Person.java Person.java:9: name has private access in Person jack.name = "Jack Smith"; ^ Person.java:10: weight has private access in Person jack.weight = 500; ^ 2 errors
27. class Person { private String name; private int weight; public void setName(String n) { name = n; } public String getName() { return name; } public void setWeight(int w) { if(w > 0 && w <= 150) weight = w; } public int getWeight() { return weight; } } class JustTesting { public static void main(String [] args) { Person jack = new Person(); jack.setName("Jack Smith"); jack.setWeight(200); System.out.println(jack.getName()); } }
28. Accessor and Mutator - methods class Person { private String name; private int weight; // Mutator public void setName(String n) { name = n; } // Accessor public String getName() { return name; } // Mutator public void setWeight(int w) { if(w > 0 && w <= 150) weight = w; } // Accessor public int getWeight() { return weight; } }
29. JAVA TYPES
30. Java Types • Java has two type of types • 1) Primitive types – byte, short, int, long, double, float, char, boolean • 2) Class types – String, Scanner, Array, JButton, JFrame ...
31. Differences • Primitive types are spelled with lowercase: – int, double, float... • Class types are spelled with uppercase – String, Scanner, Person, Cat, Car ... • Primitive type declaring and initialization – int a = 5; • Class type declaring and initialization with new – Dog spot = new Dog();
32. Differences • Primitive type – int a = 5; • Class type – int [] b= new int[5]; • b holds memory address • a holds value 5.
33. Memory Address? int [] b = new int[2]; b[0] = 1; b[1] = 2; // prints 0x01 System.out.println(b); RAM address value 0x01 1 0x02 2 address value 0x09 0x01 variable b
34. Memory Address? int [] b = new int[2]; b[0] = 1; b[1] = 2; int [] a = b; // prints 0x01 System.out.println(b); // prints 0x01 System.out.println(a); RAM address value 0x01 1 0x02 2 address value 0x09 0x01 variable b address value 0x19 0x01 variable a
35. Output? int [] b = new int[2]; b[0] = 1; b[1] = 2; int [] a = b; b[0] = 99; // Output? System.out.println(a[0]);
36. Differences Again • Primitive type – int a = 5; • Class type – int [] b= new int[5]; • b holds memory address • a holds value 5.
37. Differences Again • Primitive type – int a = 5; • Class type – Person jack = new Person() • jack holds memory address • a holds value 5.
38. Output? Person jack = new Person(); jack.setName("Jack Smith"); Person james = jack; james.setName("James Bond"); // output? System.out.println(jack.getName());
39. Methods and Variables public void method(int x) { x++; } public void main(String [] args) { int y = 3; method(y); // Output is 3! System.out.println(y); }
40. Methods and Variables public void method(int [] x) { x[0] = 12; } public void main(String [] args) { int [] y = {1,2,3}; method(y); // Output is 12 since array is class type! System.out.println(y[0]); }
41. String • String is an exception to the rules • String is a class type that acts like primitive type • String is the only class type that can be initialized without the new word. – String a = "hello"; • String is passed by value in methods, so String is copied when moving strings in methods.
42. String and Memory • String variables are objects => holds memory address. • Comparing contents – a.equals(b); • Comparing memory addresses – a == b
43. CONSTRUCTOR
44. Constructors • Constructor is a “init method” that is called when an object is created • Java provides default constructor (= constructor with no parameters) • Constructor has the same name than the class • Constructor does not return anything • Constructor usually initalizes class members
45. Example class Car { public Car() { System.out.println("Constructor!"); } } class Test { public static void main(String [] args) { Car datsun = new Car(); } } > java Test Constructor!
46. class Car { private String brand; public Car(String b) { brand = b; } public String getBrand() { return brand; } } class Test { public static void main(String [] args) { Car datsun = new Car("Datsun 100A"); System.out.println( datsun.getBrand() ); } } > java Test Datsun 100A
47. Multiple Constructors class Car { public Car() { // Do something } public Car(String brand) { // Do something else } } class Test { public static void main(String [] args) { Car datsun = new Car(); Car ferrari = new Car("Ferrari"); } }
48. Problem? class Car { String brand; public Car(String brand) { brand = brand; } } class Test { public static void main(String [] args) { Car datsun = new Car("Datsun 100a"); } } > java Test null
49. Solution class Car { String brand; public Car(String brand) { this.brand = brand; } } class Test { public static void main(String [] args) { Car datsun = new Car("Datsun 100a"); } } > java Test Datsun 100a
50. COMPOSITION
51. Composition • Relatioship between objects, where one object owns, or has the other object • Car has or owns Motor • When Car is build, it's motor is built also • When Car is destroyed it's motor is destroyed
52. UML notation
53. Java: Composition // Composition class Car { private Motor motor; public Car() { motor = new Motor(); } }
54. One to Many?
55. Java: One to Many class Department { private Professor [] members; private int numberOfMembers; public Department(Professor prof) { members = new Professor[20]; members[0] = prof; numberOfMembers = 1; } public void addProfessor(Professor prof) { members[numberOfMembers] = prof; numberOfMembers++; } }
56. INHERITANCE
57. Introduction to Inheritance • Inheritance is a relationship between two or more classes where derived class inherites behaviour and attributes of pre-existing (base) classes • Intended to help reuse of existing code with little or no modification
58. Inheritance • Inheritance can be continous – Derived class can inherit another class, which inherits another class and so on – When changing the base class all the derived classes changes also • Example: – Mammal <– Human <– Worker <- Programmer • Could mammal be a derived class? If so, what would be the base class?
59. Picture about Inheritance a b Class A features: a,b c Class B Features: a,b,c d e Class C Features: a,b,d,e f Class D Features: a,b,d,e,f
60. Multiple Inheritance • In multiple inheritance a derived class has multiple base classes • C++ supports multiple base classes, Java don't Driver - license - Year of approval Conductor - Account number Taxi Driver - area House Boat Houseboat
61. Inheritance and Capsulation • private – Is accessible only via the base class • public – Is accessible everywhere (base class, derived class, othe classes) • protected – Is accessible by the base class and derived classes
62. Basic example • What are Programmer's attributes and methods? Human string name void sleep() void drink() void eat() Programmer int salary void implementApps() void beNerd()
63. Overriding? • What about now? Human string name void sleep() void drink() void eat() Programmer int salary void implementApps() void beNerd() void drink() void eat()
64. Overriding • Since programmer eats and drinks differently than humans (only Coke and Pizza) the eat and drink methods are overriden in Programmer!
65. Abstract Class • Abstract class is a class which you cannot instantiate (create objects) • You can inherit abstract class and create objects from the inherited class, if it is concrete one • Abstract class in C++ has abstract methods, that do not have implementations • These methods forces derived classes to implement those methods
66. Example <<abstract>> Mammal string name void makesound() {abstract} Elephant int trunkLength makesound()
67. Example <<abstract>> Figure int x, y double calculateArea() {abstract} Circle double radius double calculateArea() Rect double length, height double calculateArea()
68. INHERITANCE IN JAVA
69. Example: Basic Inheritance class Human { public void sleep() { System.out.println("Human sleeps"); } } class Programmer extends Human { } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); jussi.sleep(); // "Human sleeps" } }
70. Example: Overriding class Human { public void sleep() { System.out.println("Human sleeps"); } } class Programmer extends Human { public void sleep() { System.out.println("Programmer sleeps"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); jussi.sleep(); // "Programmer sleeps" } }
71. Example: super class Human { public void sleep() { System.out.println("Human sleeps"); } } class Programmer extends Human { public void sleep() { super.sleep(); System.out.println("Programmer sleeps"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); jussi.sleep(); } } > java Test Human sleeps Programmer sleeps
72. Constructors and Inheritance class Human { public Human() { System.out.println("Human"); } } class Programmer extends Human { public Programmer() { System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } } > java Test Human Programmer
73. Constructors and Inheritance • Constructor allways calls the base classes constructor! • When creating a constructor void Human() { } • Java adds super() – call to it: void Human() { super(); // calls base classes constructor }
74. class Human { public Human() { System.out.println("Human"); } } class Programmer extends Human { public Programmer() { System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } } > java Test Human Programmer
75. class Human { public Human() { super(); // Java adds this! Calls base classes contructor System.out.println("Human"); } } class Programmer extends Human { public Programmer() { super(); // Java adds this! Calls base classes contructor System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } } > java Test Human Programmer
76. What the...? What base class? class Human { public Human() { // Java adds this! Calls base classes contructor super(); System.out.println("Human"); } }
77. Object • Every class derives from a class called Object. // Java adds the extends Object too! class Human extends Object { public Human() { super(); System.out.println("Human"); } }
78. Object clone() equals() finalize() toString() ... Human String name ... http://java.sun.com/javase/6/docs/api/java/lang/Object.html
79. class Human { public Human(int a) { System.out.println("Human"); } } class Programmer extends Human { public Programmer() { System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } } > javac Test.java > DOES NOT COMPILE!!! Why?
80. class Human { public Human(int a) { System.out.println("Human"); } } class Programmer extends Human { public Programmer() { super(); // Java adds this and it calls constructor // Human() that does not exist.. System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } }
81. class Human { public Human(int a) { System.out.println("Human"); } } class Programmer extends Human { public Programmer() { super(5); // Now it works: Human(int a) exists. System.out.println("Programmer"); } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer(); } }
82. class Human { private String name public Human(String name) { this.name = name; } } class Programmer extends Human { private int salary; public Programmer(String name, int salary) { super(name); this.salary = salary; } } class Test { public static void main(String [] args) { Programmer jussi = new Programmer("Jussi", 5000); } }
83. Abstract Class • From abstract class you cannot create objects! • Abstract class is usually used with inheritance • Abstract class may contain abstract methods. • Abstract method forces derived classes to implement the abstract method.
84. Abstract Class: example abstract class Mammal { abstract void makeSound(); } class Dog extends Mammal { // You have to implement this! public void makeSound() { System.out.println("Bark!"); } }
85. Abstract Class: example // Does NOT work, since Mammal is // abstract class Mammal object = new Mammal(); // Does work Dog spot = new Dog();
86. Java: Abstract class and Interface • Abstract class can hold "normal" methods and abstract methods. • Interface holds only abstract methods • Abstract class: – class A extends someAbstractClass • Interface – class A implements someInterface
87. Abstract class to Interface abstract class Movable { abstract public void start(); abstract public void stop(); } ó interface Movable { public void start(); public void stop(); }
88. Implementing the Interface interface Movable { public void start(); public void stop(); } class Car implements Movable { // You have to implement these public void start() { // Do something } public void stop() { // Do something } }
89. Abstract class vs Interface • Abstract class can hold normal methods and abstract methods • Interface can hold only abstract methods • Class can inherite only one base class • Class can implement several interfaces!
90. class Car extends Vehicle implements Movable, RunsOnGasoline { // You have to implement these public void start() { // Do something } public void stop() { // Do something } public void reduceGasoline() { // Do something } public void addGasoline() { // Do something } }
91. POLYMORPHISM
92. int as parameter class Exercise13 { public static void main(String [] args) { int x = 4; myMethod(x); } public static void myMethod(int a) { } }
93. Human parameter class Human { } class Exercise13 { public static void main(String [] args) { Human jack = new Human(); myMethod(jack); } public static void myMethod(Human a) { } }
94. Mammal parameter class Mammal { } class Human extends Mammal { } class Dog extends Mammal { } class Exercise13 { public static void main(String [] args) { Human jack = new Human(); Dog spot = new Dog(); Mammal mammal = new Mammal(); // these work! You can pass mammals, dogs and humans to the method! myMethod(jack); myMethod(dog); myMethod(mammal); } public static void myMethod(Mammal a) { } }
95. Object parameter ... class Exercise13 { public static void main(String [] args) { Human jack = new Human(); Dog spot = new Dog(); Mammal mammal = new Mammal(); // these work! You can pass every object to the method myMethod(jack); myMethod(dog); myMethod(mammal); myMethod("hello"); // String } public static void myMethod(Object a) { } }
96. Calling methods from Mammal class Mammal { } class Human extends Mammal { public void bark() { System.out.println("Bark!"); }; } class Dog extends Mammal { } class Exercise13 { public static void main(String [] args) { Human jack = new Human(); Dog spot = new Dog(); Mammal mammal = new Mammal(); myMethod(jack); myMethod(dog); myMethod(mammal); } public static void myMethod(Mammal a) { a.bark(); // Why this does not work? } }
97. Solution class Exercise13 { public static void main(String [] args) { Human jack = new Human(); Dog spot = new Dog(); Mammal mammal = new Mammal(); myMethod(jack); myMethod(dog); myMethod(mammal); } public static void myMethod(Mammal a) { // Now it works if(a instanceof Dog) { Dog spot = (Dog) a; spot.bark(); } } }
98. This works, why? class Mammal { public void giveBirth() { System.out.println("Giving birth"); }; } class Human extends Mammal { } class Dog extends Mammal { } class Exercise13 { public static void main(String [] args) { Human jack = new Human(); Dog spot = new Dog(); Mammal mammal = new Mammal(); myMethod(jack); myMethod(dog); myMethod(mammal); } public static void myMethod(Mammal a) { a.giveBirth(); // Why this works? } }
99. class Movable { public void start(); public void stop(); } class Vehicle { } class Car extends Vehicle implements Movable { public void start() { // Do something } public void stop() { // Do something } } class Exercise13 { public static void main(String [] args) { Car c = new Car(); myMethod(c); } // You can pass every object that implements the Movable! public static void myMethod(Movable a) { a.start(); } }