GEEN165 Vocabulary

Helpfulness: 0
Set Details Share
created 4 years ago by Freedcomic
55 views
Are you taking the infamous GEEN 165 class with the great Dr. Bryant? Are you struggling to remember concepts needed for that class? Fear not! I have assembled every almost every vocabulary term in his class in one package. Dr. Bryant can be tough but here is a tool to help you pass his class. YOU'RE WELCOME!( Anything I miss msg mavdude4@gmail.com
updated 4 years ago by Freedcomic
show moreless
Page to share:
Embed this setcancel
COPY
code changes based on your size selection
Size:
X
Show:
1

Abstraction

separating implementation from use

One of the 4 pillars of Object Oriented Programming

separating the method use from the method implementation

2

Methods

a collection of statements that are grouped together to perform an operation

3

Method Signature

method name + parameter list formal parameter used at the method declaration pass by value

4

Method Overloading

two or more methods with the same name but different signatures

5

Method Abstraction

separating the method use from the method implementation

6

Array

a sequence of variables of the same data type

7

Class

a class is a blueprint for building an object

8

Constructor

special method used to construct an object

- no return type

- default constructor default created by Java Virtual Machine

-no dry contractor w/o parameter

9

2nd Pillar of OOP Encapsulation

making peripheral (private + public) providing mutator + accessor methods

accessor methods - getMethod

mutator - setMethod

10

Instance Variable

is a variable defined in a class for which each instantiated object of the class has a separate copy, or instance.

11

Class Variable (static)

share all instances of a variable

12

Static Method

can be called w/o instantiating a object of the enclosing class type

13

Variable Scope

area where a variable should be accessed

14

Class Contract

public methods + constants defined in the class

15

Local Variable(scope)

from where it is defined to the end of the enclosing block

16

Static Methods

can not access instance variables

17

cohesion

a class should describe a single entity

18

Consistency

follow standard varying conventions & programming style

19

Clarity

achieved through cohesion

constructor & encapsulation

impose no restrictions on what or when a user can do with a class

20

Completeness

provide a variety of way for customization through properties and methods

21

Consistancy

follow standard programming style and naming conventions

22

Polymorphism Requirements

-classes are in the same heirarchy

-all subclasses override the same method

-subclass object reference is assigned to a superclass object reference

-superclass object refeered is used to call the overridden method

23

Benefits of polymorphism

use the same method call for any object in the hierarchy using the superclass reference object

24

4th Pillar of OOP: Polymorphism

-Inheritance object at a sublclass is also an object of any of its superclass

-concept is the basis for an important OOP feature

-simplifies the processing of various objects in the same class hierarchy because we can use the same method call for any object in the hierarchy using the super class reference object

25

Super

- calls the overwritten or superclass

26

Subclass of abstract class

-can implement all, some, or not of the abstract methods

-it doesn't implement all abstract methods, it must be declared as abstract

27

Superclass

pass down information to the subclass

28

Protected

accessed directly to the subclass from the superclass

breaks encapsulation

faster by accessing directly

29

Abstract Method

-pattern by a method the subclass shows implement

-can only be declared w/in a abstract ckass

-must consist at a method header by "j"

-cannot be called

30

Super()

call the immediate superclass constructor

31

toString Method

method is in the object class

32

sublclass

get info from the superclass

33

abstract class

-class not completely implemented

-specifies API but doesn't provide implementation

-cannot initiate objects, but can be declared

Ex: Figure C = new Circle();

34

Rules for Abstract

-Abstract can be extended subclass complete implementation

-to declare a class a abstract include keyword abstract

-to declare method as abstract include abstract in the method header

Ex: accessModifer abstract ReturnType methodName (something) list);

35

OOD

Object Oriented Design

36

OOP

Object Oriented Programming

37

Actual Parameters

call the method

Ex: int x = sumValues (100,200);

AP is................................^

38

ArrayList

ArrayList <variableName> typeofclass

Ex ArrayList<Engine> engine;

39

Class variables

defined in the class of which a single copy exists

40

3rd Pillar of OOP: Inheritance

-organize classes into hierarchies of functionality

-class at the top of hierarchy(super class) defined instances variables + methods common to all classes

-derive subclass, which inherit behavior + from the super class(Passing down)

41

ODD Cohesion

a class should describe a single entity

42

Java Virtual Machine(JVM)

designed to be portable

43

Formal Parameters

-declared at the beginning

Ex: Public static int sumValues(int startVal, int endVal)

44

2nd Pillar of OOP Encapsulation

-making properties private

hides detail

45

UML Diagram

A class diagram

46

Modifiers to code

-method signature

-parameter list

-method name

-return value style

47

Index

-numeric association to an element in a collection of data

48

dot operator(.)

-used to call method of an object of that class

49

Instance Method

defined in a class which is only accessible through the object of the class

50

Immutable class

Make all properties private

Provide no mutators/setter methods

no accessor methods for reference types

51

class abstraction

separating implementation of the class from the uh of the class(Sorry)

52

Arrays

-static

ex autoMobiles = new Auto[100];

value = list[I];

53

Ambiguous invocation

sumValues(int b, int c)