DOCSLIB.ORG

Variables and Data Types

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Variables and Data Types Lecture 2 Variables and Primitive Data Types MIT AITI - 2004 What is a Variable? • Variables are places where information can be stored while a program is running. • Their values can be changed at any point over the course of a program Creating Variables • To create a variable, declare its name and the type of information that it will store. •The type is listed first, followed by the name. • Example: a variable that stores an integer representing the highest score on an exam could be declared as follows: int highScore ; type name Creating Variables (continued) • Now you have the variable (highScore), you will want to assign a value to it. • Example: the highest score in the class exam is 98. highScore = 98; • Examples of other types of variables: String studentName; boolean gameOver; Naming Variables • The name that you choose for a variable is called an identifier. In Java, an identifier can be of any length, but must start with: a letter (a – z), a dollar sign ($), or, an underscore ( _ ). • The rest of the identifier can include any character except those used as operators in Java such as + , - , * . • In addition, there are certain keywords reserved (e.g., "class") in the Java language which can never be used as identifiers. we'll learn what operators are later Naming (Continued) • Java is a case-sensitive language – the capitalization of letters in identifiers matters. A rose is not a Rose is not a ROSE • It is good practice to select variable names that give a good indication of the sort of data they hold – For example, if you want to record the size of a hat, hatSize is a good choice for a name whereas qqq would be a bad choice • When naming a variable, the following convention is commonly used: – The first letter of a variable name is lowercase – Each successive word in the variable name begins with a capital letter – All other letters are lowercase • Here are some examples: pageCount loadFile anyString threeWordVariable POP QUIZ • Which of the following are valid variable names? 1)$amount 2)6tally 3)my*Name 4)salary 5)_score 6)first Name 7)total# Statements •A statement is a command that causes something to happen. • All statements in Java are separated by semicolons ; • Example: System.out.println(“Hello, World”); • You have already used statements to create a variable and assign it a value. Variables and Statements • One way is to declare a variable and then assign a value to it with two statements: int e; // declaring a variable e = 5; // assigning a value to a variable • Another way is to write a single initialization statement: int e = 5; // declaring AND assigning Java is a Strongly-Typed Language • All variables must be declared with a data type before they are used. • Each variable's declared type does not change over the course of the program. • Certain operations are only allowed with certain data types. • If you try to perform an operation on an illegal data type (like multiplying Strings), the compiler will report an error. Primitive Data Types • There are eight built-in (primitive) data types in the Java language – 4 integer types (byte, short, int, long) – 2 floating point types (float, double) – Boolean (boolean) – Character (char) **see Appendix II: Summary of Primitive Data Types for a complete table of sizes and formats** Integer Data Types • There are four data types that can be used to store integers. • The one you choose to use depends on the size of the number that we want to store. Data Type Value Range byte -128 to +127 short -32768 to +32767 int -2147483648 to +2147483647 long -9223372036854775808 to +9223372036854775807 • In this course, we will always use int when dealing with integers. • Here are some examples of when you would want to use integer types: - byte smallValue; smallValue = -55; - int pageCount = 1250; - long bigValue = 1823337144562L; Note: By adding an L to the end of the value in the last example, the program is “forced” to consider the value to be of a type long even if it was small enough to be an int Floating Point Data Types • There are two data types that can be used to store decimal values (real numbers). • The one you choose to use depends on the size of the number that we want to store. Data Type Value Range float 1.4×10-45 to 3.4×1038 double 4.9×10-324 to 1.7×10308 • In this course, we will always use double when dealing with decimal values. • Here are some examples of when you would want to use floating point types: – double g = 7.7e100 ; – double tinyNumber = 5.82e-203; – float costOfBook = 49.99F; • Note: In the last example we added an F to the end of the value. Without the F, it would have automatically been considered a double instead. Boolean Data Type • Boolean is a data type that can be used in situations where there are two options, either true or false. • Example: boolean monsterHungry = true; boolean fileOpen = false; Character Data Types • Character is a data type that can be used to store a single characters such as a letter, number, punctuation mark, or other symbol. • Example: – char firstLetterOfName = 'e' ; – char myQuestion = '?' ; • Note that you need to use singular quotation marks when assigning char data types. Introduction to Strings • Strings consist of a series of characters inside double quotation marks. • Examples statements assign String variables: String coAuthor = "John Smith"; String password = "swordfish786"; • Strings are not one of the primitive data types, although they are very commonly used. • Strings are constant; their values cannot be changed after they are created. POP QUIZ • What data types would you use to store the following types of information?: 1)Population of Ethiopia int 2)Approximation of π double 3)Open/closed status of a file boolean 4)Your name String 5)First letter of your name char 6)$237.66 double Appendix I: Reserved Words The following keywords are reserved in the Java language. They can never be used as identifiers: abstract assert boolean break byte case catch char class const continue default do double else extends final finally float for goto if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void violate while Appendix II: Primitive Data Types The following tables show all of the primitive data types along with their sizes and formats: Integers Data Type Description byte Variables of this kind can have a value from: -128 to +127 and occupy 8 bits in memory short Variables of this kind can have a value from: -32768 to +32767 and occupy 16 bits in memory int Variables of this kind can have a value from: -2147483648 to +2147483647 and occupy 32 bits in memory long Variables of this kind can have a value from: -9223372036854775808 to +9223372036854775807 and occupy 64 bits in memory Appendix II: Primitive Data Types (cont) Real Numbers Data Type Description float Variables of this kind can have a value from: 1.4e(-45) to 3.4e(+38) double Variables of this kind can have a value from: 4.9e(-324) to 1.7e(+308) Other Primitive Data Types char Variables of this kind can have a value from: A single character boolean Variables of this kind can have a value from: True or False.
Load more

Recommended publications
  • Metaobject Protocols: Why We Want Them and What Else They Can Do
    Metaobject protocols: Why we want them and what else they can do Gregor Kiczales, J.Michael Ashley, Luis Rodriguez, Amin Vahdat, and Daniel G. Bobrow Published in A. Paepcke, editor, Object-Oriented Programming: The CLOS Perspective, pages 101 ¾ 118. The MIT Press, Cambridge, MA, 1993. © Massachusetts Institute of Technology All rights reserved. No part of this book may be reproduced in any form by any electronic or mechanical means (including photocopying, recording, or information storage and retrieval) without permission in writing from the publisher. Metaob ject Proto cols WhyWeWant Them and What Else They Can Do App ears in Object OrientedProgramming: The CLOS Perspective c Copyright 1993 MIT Press Gregor Kiczales, J. Michael Ashley, Luis Ro driguez, Amin Vahdat and Daniel G. Bobrow Original ly conceivedasaneat idea that could help solve problems in the design and implementation of CLOS, the metaobject protocol framework now appears to have applicability to a wide range of problems that come up in high-level languages. This chapter sketches this wider potential, by drawing an analogy to ordinary language design, by presenting some early design principles, and by presenting an overview of three new metaobject protcols we have designed that, respectively, control the semantics of Scheme, the compilation of Scheme, and the static paral lelization of Scheme programs. Intro duction The CLOS Metaob ject Proto col MOP was motivated by the tension b etween, what at the time, seemed liketwo con icting desires. The rst was to have a relatively small but p owerful language for doing ob ject-oriented programming in Lisp. The second was to satisfy what seemed to b e a large numb er of user demands, including: compatibility with previous languages, p erformance compara- ble to or b etter than previous implementations and extensibility to allow further exp erimentation with ob ject-oriented concepts see Chapter 2 for examples of directions in which ob ject-oriented techniques might b e pushed.
    [Show full text]
  • Customizing and Extending Powerdesigner SAP Powerdesigner Documentation Collection Content
    User Guide PUBLIC SAP PowerDesigner Document Version: 16.6.2 – 2017-01-05 Customizing and Extending PowerDesigner SAP PowerDesigner Documentation Collection Content 1 PowerDesigner Resource Files.................................................... 9 1.1 Opening Resource Files in the Editor.................................................10 1.2 Navigating and Searching in Resource Files............................................ 11 1.3 Editing Resource Files........................................................... 13 1.4 Saving Changes................................................................13 1.5 Sharing and Embedding Resource Files...............................................13 1.6 Creating and Copying Resource Files.................................................14 1.7 Specifying Directories to Search for Resource Files.......................................15 1.8 Comparing Resource Files........................................................ 15 1.9 Merging Resource Files.......................................................... 16 2 Extension Files................................................................18 2.1 Creating an Extension File.........................................................19 2.2 Attaching Extensions to a Model....................................................20 2.3 Exporting an Embedded Extension File for Sharing.......................................21 2.4 Extension File Properties......................................................... 21 2.5 Example: Adding a New Attribute from a Property
    [Show full text]
  • Chapter 2 Basics of Scanning And
    Chapter 2 Basics of Scanning and Conventional Programming in Java In this chapter, we will introduce you to an initial set of Java features, the equivalent of which you should have seen in your CS-1 class; the separation of problem, representation, algorithm and program – four concepts you have probably seen in your CS-1 class; style rules with which you are probably familiar, and scanning - a general class of problems we see in both computer science and other fields. Each chapter is associated with an animating recorded PowerPoint presentation and a YouTube video created from the presentation. It is meant to be a transcript of the associated presentation that contains little graphics and thus can be read even on a small device. You should refer to the associated material if you feel the need for a different instruction medium. Also associated with each chapter is hyperlinked code examples presented here. References to previously presented code modules are links that can be traversed to remind you of the details. The resources for this chapter are: PowerPoint Presentation YouTube Video Code Examples Algorithms and Representation Four concepts we explicitly or implicitly encounter while programming are problems, representations, algorithms and programs. Programs, of course, are instructions executed by the computer. Problems are what we try to solve when we write programs. Usually we do not go directly from problems to programs. Two intermediate steps are creating algorithms and identifying representations. Algorithms are sequences of steps to solve problems. So are programs. Thus, all programs are algorithms but the reverse is not true.
    [Show full text]
  • PL/SQL Data Types
    PPLL//SSQQLL -- DDAATTAA TTYYPPEESS http://www.tutorialspoint.com/plsql/plsql_data_types.htm Copyright © tutorialspoint.com PL/SQL variables, constants and parameters must have a valid data type, which specifies a storage format, constraints, and valid range of values. This tutorial will take you through SCALAR and LOB data types available in PL/SQL and other two data types will be covered in other chapters. Category Description Scalar Single values with no internal components, such as a NUMBER, DATE, or BOOLEAN. Large Object LOB Pointers to large objects that are stored separately from other data items, such as text, graphic images, video clips, and sound waveforms. Composite Data items that have internal components that can be accessed individually. For example, collections and records. Reference Pointers to other data items. PL/SQL Scalar Data Types and Subtypes PL/SQL Scalar Data Types and Subtypes come under the following categories: Date Type Description Numeric Numeric values on which arithmetic operations are performed. Character Alphanumeric values that represent single characters or strings of characters. Boolean Logical values on which logical operations are performed. Datetime Dates and times. PL/SQL provides subtypes of data types. For example, the data type NUMBER has a subtype called INTEGER. You can use subtypes in your PL/SQL program to make the data types compatible with data types in other programs while embedding PL/SQL code in another program, such as a Java program. PL/SQL Numeric Data Types and Subtypes Following
    [Show full text]
  • Lecture 2: Variables and Primitive Data Types
    Lecture 2: Variables and Primitive Data Types MIT-AITI Kenya 2005 1 In this lecture, you will learn… • What a variable is – Types of variables – Naming of variables – Variable assignment • What a primitive data type is • Other data types (ex. String) MIT-Africa Internet Technology Initiative 2 ©2005 What is a Variable? • In basic algebra, variables are symbols that can represent values in formulas. • For example the variable x in the formula f(x)=x2+2 can represent any number value. • Similarly, variables in computer program are symbols for arbitrary data. MIT-Africa Internet Technology Initiative 3 ©2005 A Variable Analogy • Think of variables as an empty box that you can put values in. • We can label the box with a name like “Box X” and re-use it many times. • Can perform tasks on the box without caring about what’s inside: – “Move Box X to Shelf A” – “Put item Z in box” – “Open Box X” – “Remove contents from Box X” MIT-Africa Internet Technology Initiative 4 ©2005 Variables Types in Java • Variables in Java have a type. • The type defines what kinds of values a variable is allowed to store. • Think of a variable’s type as the size or shape of the empty box. • The variable x in f(x)=x2+2 is implicitly a number. • If x is a symbol representing the word “Fish”, the formula doesn’t make sense. MIT-Africa Internet Technology Initiative 5 ©2005 Java Types • Integer Types: – int: Most numbers you’ll deal with. – long: Big integers; science, finance, computing. – short: Small integers.
    [Show full text]
  • Kind of Quantity’
    NIST Technical Note 2034 Defning ‘kind of quantity’ David Flater This publication is available free of charge from: https://doi.org/10.6028/NIST.TN.2034 NIST Technical Note 2034 Defning ‘kind of quantity’ David Flater Software and Systems Division Information Technology Laboratory This publication is available free of charge from: https://doi.org/10.6028/NIST.TN.2034 February 2019 U.S. Department of Commerce Wilbur L. Ross, Jr., Secretary National Institute of Standards and Technology Walter Copan, NIST Director and Undersecretary of Commerce for Standards and Technology Certain commercial entities, equipment, or materials may be identifed in this document in order to describe an experimental procedure or concept adequately. Such identifcation is not intended to imply recommendation or endorsement by the National Institute of Standards and Technology, nor is it intended to imply that the entities, materials, or equipment are necessarily the best available for the purpose. National Institute of Standards and Technology Technical Note 2034 Natl. Inst. Stand. Technol. Tech. Note 2034, 7 pages (February 2019) CODEN: NTNOEF This publication is available free of charge from: https://doi.org/10.6028/NIST.TN.2034 NIST Technical Note 2034 1 Defning ‘kind of quantity’ David Flater 2019-02-06 This publication is available free of charge from: https://doi.org/10.6028/NIST.TN.2034 Abstract The defnition of ‘kind of quantity’ given in the International Vocabulary of Metrology (VIM), 3rd edition, does not cover the historical meaning of the term as it is most commonly used in metrology. Most of its historical meaning has been merged into ‘quantity,’ which is polysemic across two layers of abstraction.
    [Show full text]
  • Subtyping, Declaratively an Exercise in Mixed Induction and Coinduction
    Subtyping, Declaratively An Exercise in Mixed Induction and Coinduction Nils Anders Danielsson and Thorsten Altenkirch University of Nottingham Abstract. It is natural to present subtyping for recursive types coin- ductively. However, Gapeyev, Levin and Pierce have noted that there is a problem with coinductive definitions of non-trivial transitive inference systems: they cannot be \declarative"|as opposed to \algorithmic" or syntax-directed|because coinductive inference systems with an explicit rule of transitivity are trivial. We propose a solution to this problem. By using mixed induction and coinduction we define an inference system for subtyping which combines the advantages of coinduction with the convenience of an explicit rule of transitivity. The definition uses coinduction for the structural rules, and induction for the rule of transitivity. We also discuss under what condi- tions this technique can be used when defining other inference systems. The developments presented in the paper have been mechanised using Agda, a dependently typed programming language and proof assistant. 1 Introduction Coinduction and corecursion are useful techniques for defining and reasoning about things which are potentially infinite, including streams and other (poten- tially) infinite data types (Coquand 1994; Gim´enez1996; Turner 2004), process congruences (Milner 1990), congruences for functional programs (Gordon 1999), closures (Milner and Tofte 1991), semantics for divergence of programs (Cousot and Cousot 1992; Hughes and Moran 1995; Leroy and Grall 2009; Nakata and Uustalu 2009), and subtyping relations for recursive types (Brandt and Henglein 1998; Gapeyev et al. 2002). However, the use of coinduction can lead to values which are \too infinite”. For instance, a non-trivial binary relation defined as a coinductive inference sys- tem cannot include the rule of transitivity, because a coinductive reading of transitivity would imply that every element is related to every other (to see this, build an infinite derivation consisting solely of uses of transitivity).
    [Show full text]
  • Guide for the Use of the International System of Units (SI)
    Guide for the Use of the International System of Units (SI) m kg s cd SI mol K A NIST Special Publication 811 2008 Edition Ambler Thompson and Barry N. Taylor NIST Special Publication 811 2008 Edition Guide for the Use of the International System of Units (SI) Ambler Thompson Technology Services and Barry N. Taylor Physics Laboratory National Institute of Standards and Technology Gaithersburg, MD 20899 (Supersedes NIST Special Publication 811, 1995 Edition, April 1995) March 2008 U.S. Department of Commerce Carlos M. Gutierrez, Secretary National Institute of Standards and Technology James M. Turner, Acting Director National Institute of Standards and Technology Special Publication 811, 2008 Edition (Supersedes NIST Special Publication 811, April 1995 Edition) Natl. Inst. Stand. Technol. Spec. Publ. 811, 2008 Ed., 85 pages (March 2008; 2nd printing November 2008) CODEN: NSPUE3 Note on 2nd printing: This 2nd printing dated November 2008 of NIST SP811 corrects a number of minor typographical errors present in the 1st printing dated March 2008. Guide for the Use of the International System of Units (SI) Preface The International System of Units, universally abbreviated SI (from the French Le Système International d’Unités), is the modern metric system of measurement. Long the dominant measurement system used in science, the SI is becoming the dominant measurement system used in international commerce. The Omnibus Trade and Competitiveness Act of August 1988 [Public Law (PL) 100-418] changed the name of the National Bureau of Standards (NBS) to the National Institute of Standards and Technology (NIST) and gave to NIST the added task of helping U.S.
    [Show full text]
  • Boolean Data Type & Expressions Outline Basic Data Types
    Boolean Data Type & Expressions Outline Basic Data Types 1. Boolean Data Type & Expressions Outline Numeric 2. Basic Data Types – int 3. C Boolean Data Types: char or int/ – float Boolean Declaration Non-numeric 4. Boolean or Character? – char 5. Boolean Literal Constants #include <stdio.h> 6. Boolean Expressions/ int main () Boolean Operations ¡ /* main */ 7. Example: Boolean Literal Constants & Expressions float standard_deviation, relative_humidity; int count, number_of_silly_people; 8. Example: Boolean Variables char middle_initial, hometown[30]; ¢ 9. Relational Operations /* main */ 10. Example: Relational Expressions 11. Structure of Boolean Expressions 12. Precedence Order of Boolean Operations 13. Another Boolean Precedence Example 14. Example: Boolean Precedence Order 15. Example: More Relational Expressions 16. Example: More Relational Expressions (continued) 17. Short Circuiting 18. Exercise: Writing a Program 1 2 C Boolean Data Type: char or int Boolean or Character? The C data type typically used for storing Boolean values is char, Question: How does the C compiler know that a particular char although int will also work. declaration is a Boolean rather than a character? Like numeric data types, Booleans have particular ways of being Answer: It doesn’t. stored in memory and of being operated on. % cat shortcircuit.c #include <stdio.h> Conceptually, a Boolean value represents a single bit in memory, char int int main () although the and data types aren’t implemented this ¡ /* main */ way — if for no other reason than that computers can’t address a const int maximum_short_height_in_cm = 170; single bit, since the smallest collection of bits that they can address int my_height_in_cm = 160; char I_am_Henry = 1; is a byte (or, in a few cases, a word).
    [Show full text]
  • PDF (Dissertation.Pdf)
    Kind Theory Thesis by Joseph R. Kiniry In Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy California Institute of Technology Pasadena, California 2002 (Defended 10 May 2002) ii © 2002 Joseph R. Kiniry All Rights Reserved iii Preface This thesis describes a theory for representing, manipulating, and reasoning about structured pieces of knowledge in open collaborative systems. The theory's design is motivated by both its general model as well as its target user commu- nity. Its model is structured information, with emphasis on classification, relative structure, equivalence, and interpretation. Its user community is meant to be non-mathematicians and non-computer scientists that might use the theory via computational tool support once inte- grated with modern design and development tools. This thesis discusses a new logic called kind theory that meets these challenges. The core of the work is based in logic, type theory, and universal algebras. The theory is shown to be efficiently implementable, and several parts of a full realization have already been constructed and are reviewed. Additionally, several software engineering concepts, tools, and technologies have been con- structed that take advantage of this theoretical framework. These constructs are discussed as well, from the perspectives of general software engineering and applied formal methods. iv Acknowledgements I am grateful to my initial primary adviser, Prof. K. Mani Chandy, for bringing me to Caltech and his willingness to let me explore many unfamiliar research fields of my own choosing. I am also appreciative of my second adviser, Prof. Jason Hickey, for his support, encouragement, feedback, and patience through the later years of my work.
    [Show full text]
  • OMG Meta Object Facility (MOF) Core Specification
    Date : October 2019 OMG Meta Object Facility (MOF) Core Specification Version 2.5.1 OMG Document Number: formal/2019-10-01 Standard document URL: https://www.omg.org/spec/MOF/2.5.1 Normative Machine-Readable Files: https://www.omg.org/spec/MOF/20131001/MOF.xmi Informative Machine-Readable Files: https://www.omg.org/spec/MOF/20131001/CMOFConstraints.ocl https://www.omg.org/spec/MOF/20131001/EMOFConstraints.ocl Copyright © 2003, Adaptive Copyright © 2003, Ceira Technologies, Inc. Copyright © 2003, Compuware Corporation Copyright © 2003, Data Access Technologies, Inc. Copyright © 2003, DSTC Copyright © 2003, Gentleware Copyright © 2003, Hewlett-Packard Copyright © 2003, International Business Machines Copyright © 2003, IONA Copyright © 2003, MetaMatrix Copyright © 2015, Object Management Group Copyright © 2003, Softeam Copyright © 2003, SUN Copyright © 2003, Telelogic AB Copyright © 2003, Unisys USE OF SPECIFICATION - TERMS, CONDITIONS & NOTICES The material in this document details an Object Management Group specification in accordance with the terms, conditions and notices set forth below. This document does not represent a commitment to implement any portion of this specification in any company's products. The information contained in this document is subject to change without notice. LICENSES The companies listed above have granted to the Object Management Group, Inc. (OMG) a nonexclusive, royalty-free, paid up, worldwide license to copy and distribute this document and to modify this document and distribute copies of the modified version. Each of the copyright holders listed above has agreed that no person shall be deemed to have infringed the copyright in the included material of any such copyright holder by reason of having used the specification set forth herein or having conformed any computer software to the specification.
    [Show full text]
  • Software II: Principles of Programming Languages
    Software II: Principles of Programming Languages Lecture 6 – Data Types Some Basic Definitions • A data type defines a collection of data objects and a set of predefined operations on those objects • A descriptor is the collection of the attributes of a variable • An object represents an instance of a user- defined (abstract data) type • One design issue for all data types: What operations are defined and how are they specified? Primitive Data Types • Almost all programming languages provide a set of primitive data types • Primitive data types: Those not defined in terms of other data types • Some primitive data types are merely reflections of the hardware • Others require only a little non-hardware support for their implementation The Integer Data Type • Almost always an exact reflection of the hardware so the mapping is trivial • There may be as many as eight different integer types in a language • Java’s signed integer sizes: byte , short , int , long The Floating Point Data Type • Model real numbers, but only as approximations • Languages for scientific use support at least two floating-point types (e.g., float and double ; sometimes more • Usually exactly like the hardware, but not always • IEEE Floating-Point Standard 754 Complex Data Type • Some languages support a complex type, e.g., C99, Fortran, and Python • Each value consists of two floats, the real part and the imaginary part • Literal form real component – (in Fortran: (7, 3) imaginary – (in Python): (7 + 3j) component The Decimal Data Type • For business applications (money)
    [Show full text]