DOCSLIB.ORG

Introduction to Object-Oriented Programming

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Introduction to Object-Oriented Programming QUIZ How could we disable the automatic creation of copy- constructors pre-C++11? What syntax feature did C++11 introduce to make the disabling clearer and more permanent? • Give a code example. QUIZ How is the overloaded assignment operator different from all other overloaded operators in C++? QUIZ Show in a code example how to disable the automatic creation of the overloaded assignment operator post- C++11. The class is named Foo. Ch. 14: Inheritance & Composition Remember composition Composition If embedded object is private, it will be accessed through member (or friend) functions Composition – multi-level example Draw the UML diagram, as learned in ch.1! Inheritance Base class, from which Y inherits UML diagram Inheritance The default is private inheritance During inheritance, everything defaults to private. If the base class were not preceded by public, it would mean that all of the members of the base class, private and public would be private in the derived class. Examples on next slide Explaining public and private in inheritance (see protected later!) Inheritance – adding new functions change( ) ↔ we can add completely new functions. Inheritance – redefining functions set( ) ↔ we can redefine functions from the base class. If function is redefined, we can still call the base-class version using the scope resolution operator! Inheritance – redefining functions A note on language: redefining functions in a derived class is mostly referred to today as overriding; this includes the C++ standards. (Redefining is used when we talk about typedef or namespaces.) Unfortunately, the matter is further muddled by the existence of the override identifier (since C++11 – it applies only to virtual functions). Does this colon remind us of something? Answer: The constructor initializer list Indeed, the constructor initializer list is used to initialize the members of the parent class! Example on next slide Using the constructor initializer list to initialize members of the parent class Using the constructor initializer list to initialize members of the parent class There’s no way to get to the opening brace of the constructor without some constructor being called for all the member objects and base-class objects, even if the compiler must make a hidden call to a default constructor. text This is a further enforcement of the C++ guarantee that no object (or part of an object) can get out of the starting gate without its constructor being called. Automatic destructor calls Although you are often required to make explicit constructor calls in the initializer list, you never need to make explicit destructor calls because there’s only one destructor for any class, and it doesn’t take any arguments. However, the compiler still ensures that all destructors text are called, and that means all of the destructors in the entire hierarchy, starting with the most-derived (bottom) destructor and working up to the root. Automatic destructor calls Note well: Constructors and destructors are quite unusual in that every one in the hierarchy is called, text whereas with a normal member function only that function is called, but not any of the base- class versions. QUIZ Write a constructor for class Bar that initializes the data member and announces itself. Solution Declare a class MyType2 derived from Bar that has a new private data QUIZ member of type integer, m. Solution QUIZ Write a constructor for MyType2 that initializes i with a value, and m with the same value incremented by one. Solutions QUIZ Can Bar’s constructor also be moved from the initializer list inside the body? Solution In other words: “It’s too late!” QUIZ Write a print() member function for MyType2 that prints both i and m. Solution User code on next slide EOL 1 Order of constructor & destructor calls If an object has several sub-objects, each of them possibly with sub-objects of their own: • construction starts at the very root of the class hierarchy • at each level, the base class constructor is called first, followed by the member object constructors. The destructors are called in exactly the reverse order of the constructors. example First, let’s grok the macro used to define classes in the program C14:Order.cpp It has to be only one logical line for the preprocessor! "Stringification Operator" converts a token into a string, escaping any quotes or backslashes. Write the expanded form when ID is replaced with Base1 by the preprocessor! First, let’s grok the macro used to define classes in the program C14:Order.cpp Placeholder argument avoids default constructor! Remember character array concatenation from ch.2! First, let’s grok the macro used to define classes in the program C14:Order.cpp Some programmers like to put it here, so the code looks like a valid class declaration, but it adds to … Innocuous here, but can cause problems before else statement, since it counts as a null statement. It is considered best practice to “swallow the semicolon”. This is one of the many reasons why macros are tricky! This is an economical way to create many similar classes with diferent names (for testing purposes). Now let’s see the derived classes in the program C14:Order.cpp Draw the UML diagram! Now let’s see the derived classes in the program C14:Order.cpp Now let’s see the derived classes in the program C14:Order.cpp Name hiding If you inherit a class and provide a new definition for one of its member functions, the function from the base class is hidden. If the function was overloaded in the base class, all the text overloaded versions are hidden. (This happens whether we provide the exact signature and return type or not.) examples Redefinition, so g() from the base class is hidden Hides both overloaded f() functions from the base! However, it’s still possible to access the overloaded f() from the base using the scope-resolution operator! Return value does not make a difference; just like derived2, it hides both overloaded f() functions from the base! Argument type does not make a difference; just like derived2, it hides both overloaded f() functions from the base! Functions that don’t automatically inherit Language twist: What is meant is that the functions are not automatically inherited. 1. Constructors and destructors deal with the creation and destruction of an object, and they can know what to do with the aspects of the object only for their particular class, so all the constructors and destructors in the hierarchy below them must be called. Thus, they are not inherited, and must be created specially for each derived class. Functions that don’t automatically inherit 2. The operator= doesn’t inherit either, because it performs a constructor-like activity. In lieu of inheritance, these functions are synthesized by the compiler if you don’t create them yourself, using memberwise initialization and memberwise assignment, respectively (as described in Chapters 11 and 12). Inheritance and static member functions As far as inheritance is concerned, static member functions act the same as non-static ones: • They are inherited automatically into the derived class. • If you redefine a static member, all the other overloaded functions in the base class are hidden. protected In an ideal world, private members would always be hard-and-fast private, but in real projects there are times when you want to make something hidden from the world at large and yet allow access for members of text derived classes. The protected keyword is a nod to pragmatism; it says, “This is private as far as the class user is concerned, but available to anyone who inherits from this class.” Example on next slide No need for public inheritance anymore, we can be more selective and allow the derived class access to only those members of the base class that are really needed. This makes the code safer! Individual work for next time: • Read and understand the section Combining composition & inheritance • End-of-chapter exercises 1, 2 EOL 2 QUIZ: Explain how methods are hidden during inheritance QUIZ: Explain how methods are hidden during inheritance Solution If we redefine a member function foo, all the overloaded member functions foo in the base class are hidden. Important application of inheritance: subtyping Example: We want to create a type of ifstream object that not only opens a file but also keeps track of the name of the file. We try to use composition and embed both an ifstream and a string into the new class: …. Unfortunately, we run into this problem: The member functions of the embedded objects are not immediately available, e.g. we need to say Solution: Derive a class from ifstream Added benefit: non-member functions like getline( ) that expect an ifstream can also work with an FName2. That’s because an FName2 is a type of ifstream; it doesn’t just contain one! This is called … Upcasting The relationship between the child class and parent class Parent (base) can be summarized by class saying, “The child class is a type of the parent class.” Child (derived) class Upcasting and the copy-constructor Draw the UML class diagram! No explicit copy-constructor! QUIZ In what order are the initializations performed when a Child object is created? How does the compiler synthesize the copy-constructor? As expected, top-down: Conclusion: If you allow the compiler to synthesize a copy-constructor for a derived class, it will automatically call the base-class copy- constructor, and then the copy-constructors for all the member objects (or perform a bitcopy on built-in types) Extra-credit EOL 3 SKIP Operator overloading & inheritance Deleted functions & inheritance Not in text. Only applies to C++11 and later.
Load more

Recommended publications
  • Regular Expressions
    Regular Expressions A regular expression describes a language using three operations. Regular Expressions A regular expression (RE) describes a language. It uses the three regular operations. These are called union/or, concatenation and star. Brackets ( and ) are used for grouping, just as in normal math. Goddard 2: 2 Union The symbol + means union or or. Example: 0 + 1 means either a zero or a one. Goddard 2: 3 Concatenation The concatenation of two REs is obtained by writing the one after the other. Example: (0 + 1) 0 corresponds to f00; 10g. (0 + 1)(0 + ") corresponds to f00; 0; 10; 1g. Goddard 2: 4 Star The symbol ∗ is pronounced star and means zero or more copies. Example: a∗ corresponds to any string of a’s: f"; a; aa; aaa;:::g. ∗ (0 + 1) corresponds to all binary strings. Goddard 2: 5 Example An RE for the language of all binary strings of length at least 2 that begin and end in the same symbol. Goddard 2: 6 Example An RE for the language of all binary strings of length at least 2 that begin and end in the same symbol. ∗ ∗ 0(0 + 1) 0 + 1(0 + 1) 1 Note precedence of regular operators: star al- ways refers to smallest piece it can, or to largest piece it can. Goddard 2: 7 Example Consider the regular expression ∗ ∗ ((0 + 1) 1 + ")(00) 00 Goddard 2: 8 Example Consider the regular expression ∗ ∗ ((0 + 1) 1 + ")(00) 00 This RE is for the set of all binary strings that end with an even nonzero number of 0’s.
    [Show full text]
  • Technical Standard COBOL Language
    Technical Standard COBOL Language NICAL H S C T A E N T D A R D [This page intentionally left blank] X/Open CAE Specification COBOL Language X/Open Company, Ltd. December 1991, X/Open Company Limited All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording or otherwise, without the prior permission of the copyright owners. X/Open CAE Specification COBOL Language ISBN: 1 872630 09 X X/Open Document Number: XO/CAE/91/200 Set in Palatino by X/Open Company Ltd., U.K. Printed by Maple Press, U.K. Published by X/Open Company Ltd., U.K. Any comments relating to the material contained in this document may be submitted to X/Open at: X/Open Company Limited Apex Plaza Forbury Road Reading Berkshire, RG1 1AX United Kingdom or by Electronic Mail to: [email protected] X/Open CAE Specification (1991) Page : ii COBOL Language Contents COBOL LANGUAGE Chapter 1 INTRODUCTION 1.1 THE X/OPEN COBOL DEFINITION 1.2 HISTORY OF THIS DOCUMENT 1.3 FORMAT OF ENTRIES 1.3.1 Typographical Conventions 1.3.2 Terminology Chapter 2 COBOL DEFINITION 2.1 GENERAL FORMAT FOR A SEQUENCE OF SOURCE PROGRAMS 2.2 GENERAL FORMAT FOR NESTED SOURCE PROGRAMS 2.2.1 Nested-Source-Program 2.3 GENERAL FORMAT FOR IDENTIFICATION DIVISION 2.4 GENERAL FORMAT FOR ENVIRONMENT DIVISION 2.5 GENERAL FORMAT FOR SOURCE-COMPUTER-ENTRY 2.6 GENERAL FORMAT FOR OBJECT-COMPUTER-ENTRY 2.7 GENERAL FORMAT FOR SPECIAL-NAMES-CONTENT 2.8 GENERAL FORMAT FOR FILE-CONTROL-ENTRY 2.8.1
    [Show full text]
  • CMPSCI 250 Lecture
    CMPSCI 250: Introduction to Computation Lecture #29: Proving Regular Language Identities David Mix Barrington 6 April 2012 Proving Regular Language Identities • Regular Language Identities • The Semiring Axioms Again • Identities Involving Union and Concatenation • Proving the Distributive Law • The Inductive Definition of Kleene Star • Identities Involving Kleene Star • (ST)*, S*T*, and (S + T)* Regular Language Identities • In this lecture and the next we’ll use our new formal definition of the regular languages to prove things about them. In particular, in this lecture we’ll prove a number of regular language identities, which are statements about languages where the types of the free variables are “regular expression” and which are true for all possible values of those free variables. • For example, if we view the union operator + as “addition” and the concatenation operator ⋅ as “multiplication”, then the rule S(T + U) = ST + SU is a statement about languages and (as we’ll prove today) is a regular language identity. In fact it’s a language identity as regularity doesn’t matter. • We can use the inductive definition of regular expressions to prove statements about the whole family of them -- this will be the subject of the next lecture. The Semiring Axioms Again • The set of natural numbers, with the ordinary operations + and ×, forms an algebraic structure called a semiring. Earlier we proved the semiring axioms for the naturals from the Peano axioms and our inductive definitions of + and ×. It turns out that the languages form a semiring under union and concatenation, and the regular languages are a subsemiring because they are closed under + and ⋅: if R and S are regular, so are R + S and R⋅S.
    [Show full text]
  • Some Aspects of Semirings
    Appendix A Some Aspects of Semirings Semirings considered as a common generalization of associative rings and dis- tributive lattices provide important tools in different branches of computer science. Hence structural results on semirings are interesting and are a basic concept. Semi- rings appear in different mathematical areas, such as ideals of a ring, as positive cones of partially ordered rings and fields, vector bundles, in the context of topolog- ical considerations and in the foundation of arithmetic etc. In this appendix some algebraic concepts are introduced in order to generalize the corresponding concepts of semirings N of non-negative integers and their algebraic theory is discussed. A.1 Introductory Concepts H.S. Vandiver gave the first formal definition of a semiring and developed the the- ory of a special class of semirings in 1934. A semiring S is defined as an algebra (S, +, ·) such that (S, +) and (S, ·) are semigroups connected by a(b+c) = ab+ac and (b+c)a = ba+ca for all a,b,c ∈ S.ThesetN of all non-negative integers with usual addition and multiplication of integers is an example of a semiring, called the semiring of non-negative integers. A semiring S may have an additive zero ◦ defined by ◦+a = a +◦=a for all a ∈ S or a multiplicative zero 0 defined by 0a = a0 = 0 for all a ∈ S. S may contain both ◦ and 0 but they may not coincide. Consider the semiring (N, +, ·), where N is the set of all non-negative integers; a + b ={lcm of a and b, when a = 0,b= 0}; = 0, otherwise; and a · b = usual product of a and b.
    [Show full text]
  • Theme and Variations on the Concatenation Product
    Theme and variations on the concatenation product Jean-Eric´ Pin1⋆ LIAFA, University Paris-Diderot and CNRS, France. Abstract. The concatenation product is one of the most important op- erations on regular languages. Its study requires sophisticated tools from algebra, finite model theory and profinite topology. This paper surveys research advances on this topic over the last fifty years. The concatenation product plays a key role in two of the most important results of automata theory: Kleene’s theorem on regular languages [23] and Sch¨utzen- berger’s theorem on star-free languages [60]. This survey article surveys the most important results and tools related to the concatenation product, including connections with algebra, profinite topology and finite model theory. The paper is organised as follows: Section 1 presents some useful algebraic tools for the study of the concatenation product. Section 2 introduces the main definitions on the product and its variants. The classical results are summarized in Section 3. Sections 4 and 5 are devoted to the study of two algebraic tools: Sch¨utzenberger products and relational morphisms. Closure properties form the topic of Section 6. Hierarchies and their connection with finite model theory are presented in Sections 7 and 8. Finally, new directions are suggested in Section 9. 1 The instruments This section is a brief reminder on the algebraic notions needed to study the con- catenation product: semigroups and semirings, syntactic ordered monoids, free profinite monoids, equations and identities, varieties and relational morphisms. More information can be found in [1–3,18,35,42,45]. 1.1 Semigroups and semirings If S is a semigroup, the set P(S) of subsets of S is also a semiring, with union as addition and multiplication defined, for every X, Y ∈P(S), by XY = {xy | x ∈ X,y ∈ Y } In this semiring, the empty set is the zero and for this reason, is denoted by 0.
    [Show full text]
  • Mal E Init N Synt X Cobol
    BeMA EUROPEAN CO~IPUTER ~lANUFACTURERS ASSOCIATION MAL E INIT N of the SYNT X COBOL eptelnber ] 970 Free copies of this document are available from ECMA, European Computer Manufacturers Association, 114 Rue du Rhone - 1204 Geneva (Switzerland) EeMA EUROPEAN COMPUTER MANUFACTURERS ASSOCIATION FORMAL DEFINITION of the SYNTAX OF COBOL Septenlber 1970 FORMAL DEFINITION of the SYNTAX OF COBOL - i - CONTENTS Page PREFACE ix INTRODUCTION TO THE NOTATION xiii FORMAL DEFINITION OF COBOL SYNTAX G. Syntactic Definitions of General Nature EMPTY 1 COBOL GRAPHICS 2 COBOL CONTROLS 4 SOME FREQUENTLY USED SEPARATORS 5 WORD 6 PROPER NONNUMERIC LITERAL 7 PROPER NUMERIC LITERAL 8 FIGURATIVE CONSTANT 9 LITERAL 10 ARITHMETIC OPERATOR 11 PROPER RELATIONAL OPERATOR 12 PICTURE CHARACTER STRING 13 COMMENT STRING 14 OTHER LANGUAGE STRING 15 T. COBOL Text SEPARATORS 16 GENERALIZED CHARACTER STRING 17 STRUCTURE OF COBOL TEXT 18 - ii - Page N. Names defined by the Imp1ementors HARDWARE NAMES 19 OTHER NAMES 20 C. COBOL Program COBOL PROGRAM STRUCTURE 21 I. Identification Division IDENTIFICATION DIVISION STRUCTURE 22 PROGRAM-ID PARAGRAPH 23 DATE COMPILED PARAGRAPH 24 OTHER PARAGRAPHS 2S COt~ENT PAP~GRAPH BODY 26 E. Environment Division ENVIRONMENT DIVISION STRUCTURE 27 CONFIGURATION SECTION STRUCTURE 28 INPUT-OUTPUT SECTION STRUCTURE 29 SOURCE COMPUTER PARAGRAPH 30 OBJECT COMPUTER PARAGRAPH 31 SEGMENT LIMIT CLAUSE 32 SPECIAL-NAMES PARAGRAPH 33 SPECIAL-NAMES CLAUSE 34 CURRENCY-SIGN CLAUSE 37 DECIMAL-POINT CLAUSE 38 FILE-CONTROL PARAGRAPH 39 SELECT CLAUSE 41 ASSIGN CLAUSE 42 MULTIPLE REEL/UNIT CLAUSE 43 ALTERNATE AREA CLAUSE 44 FILE-LIMIT CLAUSE 4S - iii - Page ACCESS MODE CLAUSE 46 PROCESSING MODE CLAUSE 47 KEY CLAUSE 48 I-O-CONTROL PARAGRAPH 49 RERUN CLAUSE 50 SAME CLAUSE 51 MULTIPLE FILE CLAUSE 52 D.
    [Show full text]
  • Finite Automata Part Three
    Finite Automata Part Three Recap from Last Time A language L is called a regular language if there exists a DFA D such that ℒ(D) = L. NFAs ● An NFA is a ● Nondeterministic ● Finite ● Automaton ● Can have missing transitions or multiple transitions defined on the same input symbol. ● Accepts if any possible series of choices leads to an accepting state. ε-Transitions ● NFAs have a special type of transition called the ε-transition. ● An NFA may follow any number of ε-transitions at any time without consuming any input. a start a a q0 q1 q2 ε ε b, ε b q03 q4 q5 b a a b b b New Stuff! DFAs and NFAs NFAs and DFAs ● Any language that can be accepted by a DFA can be accepted by an NFA. ● Why? ● Just use the same set of transitions as before. ● Question: Can any language accepted by an NFA also be accepted by a DFA? ● Surprisingly, the answer is yes! Finite Automata ● NFAs and DFAs are finite automata; there can only be finitely many states in an NFA or DFA. ● An NFA can be in any combination of its states, but there are only finitely many possible combations. ● Idea: Build a DFA where each state of the DFA corresponds to a set of states in the NFA. Simulating an NFA with a DFA 0 0 start q14 q03 start 0 1 0 1 q0 q1 q2 1 0, 1 ε 1 0 0 0 q2 q q5 q3 q4 q5 1 0 1 0 1 1 0 1 q q q 1 4 0 3 The Subset Construction ● This construction for transforming an NFA into a DFA is called the subset construction (or sometimes the powerset construction).
    [Show full text]
  • Regular Expressions
    Automata Theory CS411 2015F-02 Formal Languages David Galles Department of Computer Science University of San Francisco 02-0: Alphabets & Strings An alphabet Σ is a finite set of symbols Σ1 = {a, b, . ., z} Σ2 = {0, 1} A string is a finite sequence of symbols from an alphabet fire, truck are both strings over {a, . ., z} length of a string is the number of symbols in the string |fire| = 4, |truck| = 5 02-1: Alphabets & Strings The empty string ǫ is a string of 0 characters |ǫ| = 0 ◦ is the concatenation operator w1 = fire, w2 = truck w1 ◦ w2 = firetruck w2 ◦ w1 = truckfire w2 ◦ w2 = trucktruck Often drop the ◦: w1w2 = firetruck For any string w, wǫ = w 02-2: Concatenation & Reversal We can concatenate a string with itself: w1 = w w2 = ww w3 = www By definition, w0 = ǫ Can reverse a string: wR truckR = kcurt 02-3: Formal Language A formal language (or just language) is a set of strings L1 ={a, aa, abba, bbba} L2 ={car, truck, goose} L3 ={1, 11, 111, 1111, 11111, . .} A language can be either finite or infinite 02-4: Language Concatenation We can concatenate languages as well as strings L1L2 = {wv : w ∈ L1 ∧ v ∈ L2} {a, ab}{bb, b} = 02-5: Language Concatenation We can concatenate languages as well as strings L1L2 = {wv : w ∈ L1 ∧ v ∈ L2} {a, ab}{bb, b} = {abb, ab, abbb} {a, ab}{a, ab} = 02-6: Language Concatenation We can concatenate languages as well as strings L1L2 = {wv : w ∈ L1 ∧ v ∈ L2} {a, ab}{bb, b} = {abb, ab, abbb} {a, ab}{a, ab} = {aa, aab, aba, abab} {a, aa}{a, aa} = 02-7: Language Concatenation We can concatenate languages as well as strings L1L2 = {wv : w ∈ L1 ∧ v ∈ L2} {a, ab}{bb, b} = {abb, ab, abbb} {a, ab}{a, ab} = {aa, aab, aba, abab} {a, aa}{a, aa} = {aa, aaa, aaaa} What can we say about |L1L2|, if we know |L1| = m and |L2| = n? 02-8: Language Concatenation We can concatenate a language with itself, just like strings L1 = L, L2 = LL, L3 = LLL, etc.
    [Show full text]
  • (Python) Chapter 1: Introduction to Programming in Python 1.1
    (Python) Chapter 1: Introduction to Programming in Python 1.1 Compiled vs. Interpreted Languages Computers only understand 0s and 1s, their native machine language. All of the executable programs on your computer are a collection of these 0s and 1s that tell your computer exactly what to execute. However, humans do a rather poor job of communicating and 0s and 1s. If we had to always write our instructions to computers in this manner, things would go very, very slowly and we'd have quite a few unhappy computer programmers, to say the least. Luckily, there are two common solutions employed so that programmers don't have to write their instructions to a computer in 0s and 1s: 1) Compiled languages 2) Interpreted languages In a compiled language, the programmer writes a program in a programming language that is human readable. Then, a program called a compiler translates this program into a set of 0s and 1s known as an executable file that the computer will understand. It's this executable file that the computer runs. If one wants to make changes to how their program runs, they must first make a change to their program, then recompile it (retranslate it) to create an updated executable file that the computer understands. In an interpreted language, rather than doing all the translation at once, the compiler translates some of the code written (maybe a line or two) in a human readable language to an intermediate form, and then this form gets "interpreted" to 0s and 1s that the machine understands and immediately executes.
    [Show full text]
  • Concatenation
    Back to concatenation • Theorem The class of regular languages is closed under concatenation. If L1 and L2 are regular languages then so is L1 L2. 1/1 Back to concatenation • Theorem The class of regular languages is closed under concatenation. If L1 and L2 are regular languages then so is L1 L2. • Question: Can we apply the same trick as with the Unioner M which simultaneously runs M1 and M2 & accepts if either M1 accepts or M2? M would have to accept if the input can be split into two pieces: one which is accepted by M1 and the following one by M2 1/2 Let’s play a bit • First, find the DFA for – L1 = { x {0,1}* | x is any string} – L2 = { x {0,1}* | x is composed of one or more 0s} • Then, find the DFA for – L1 L2 = { x {0,1}* | x is any string that ends with at least one 0} Introduction to Nondeterministic Finite Automata • We have mostly played with Deterministic Finite Automata (DFA) – Every step of a computation follows from the preceding one in a unique way • Nondeterministic Finite Automata (NFA) generalizes DFA – Several choices may exist for the next state at any point – We have already seen one example of a NFA: One in which not all transitions were defined • Now, let’s dive deeper 1/4 Introduction to Nondeterministic Finite Automata • The static picture of an NFA is as a graph whose edges are labeled by S and by e (called Se) and with start vertex q0 and accept states F.
    [Show full text]
  • Object-Oriented Programming in Java Buzzwords
    Object-Oriented Programming in Java Buzzwords responsibility-driven design inheritance encapsulation iterators overriding coupling cohesion javadoc interface collection classes mutator methods polymorphic method calls CS2336: Object-Oriented Programming in Java 2 What to Expect • Expect: fundamental concepts, principles, and techniques of object- oriented programming • Not to expect: language details, all Java APIs, JSP/JavaServlet, use of specific tools CS2336: Object-Oriented Programming in Java 3 Fundamental concepts • object • class • method • parameter • data type CS2336: Object-Oriented Programming in Java 4 What is OOP? • OOP: – identifying objects and having them collaborate with each other • procedural programming: – identifying steps that need to be taken to perform a task CS2336: Object-Oriented Programming in Java 5 Objects and classes • objects – represent ‘things’ from the real world, or from some problem domain (example: “the red car down there in the car park”) – An object has a unique identity, state, and behaviors • classes – represent all objects of a kind (example: “car”) CS2336: Object-Oriented Programming in Java 6 Methods and parameters • Objects have operations which can be invoked (Java calls them methods). • The behavior of an object is defined by a set of methods. • Methods may have parameters to pass additional information needed to execute. • Methods may return a result via a return value. • Method signature specifies the types of the parameters and return values CS2336: Object-Oriented Programming in Java 7 Data Types • Parameters have data types, which specify what kind of data should be passed to a parameter. • There are two general kinds of types: primitive types, where values are stored in variables directly, and object types, where references to objects are stored in variables.
    [Show full text]
  • CS110: Introduction to Computer Science the String Data Type The
    The String Data Type CS110: Introduction to Text is represented in programs by the Computer Science string data type. A string is a sequence of characters enclosed within quotation marks (") or Dianna Xu apostrophes ('). 1 2 The String Data Type The String Data Type When you enter a name, it ’s doing the One way to fix this is to enter your same thing as: string input with quotes around it. firstName = Dianna The way Python evaluates expressions Even though this works, this is is to look up the value of the variable cumbersome! Dianna and store it in firstName. 3 4 The String Data Type The String Data Type There is a better way to handle We can access the individual characters text – the raw_input function. in a string through indexing . The positions in a string are numbered raw_input is like input , but it from the left, starting with 0. doesn ’t evaluate the expression The general form is that the user enters. <string>[<expr>] , where the value of expr determines which character is selected from the string. 5 6 Python Programming, 1/e 1 The String Data Type The String Data Type H e l l o B o b H e l l o B o b 0 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 8 In a string of n characters, the last character is at position n-1 since we start counting with 0. We can index from the right side using negative indexes. 7 8 The String Data Type The String Data Type Indexing returns a string containing a Slicing: single character from a larger string.
    [Show full text]