Object Oriented Programming in Java (95-707) Java Language Basics

1
Lecture 3Object Oriented Programming in Java

• Language Basics
• Classes, Interfaces and Packages

2
Assignment B

• Primitive objects and primitive object wrapper
  classes
• throwing exceptions

3
Todays Lecture

• Trail Learning the Java Language
• Lesson Classes, Interfaces, and Packages

4
What makes up a class

• class declaration
• class body
• constructor for the class
• variables
• methods

5
Inheritance Tree

• An object that is instantiated from a class
  contains all the variables and methods defined
  for that that class and all its ancestors.
• However, the methods may have been modified
  (overridden) somewhere along the way. Also,
  access to those variables and methods may have
  been restricted through use of the public,
  private, and protected keywords

6
The parents rule

• Java does not involve a specification of an
  access specifier, public, private, or protected
  at the inheritance interface. In other words,
  inheritance access control cannot be used in Java
  to modify the access control assigned to a member
  of the parent class
• in other words (english) once the parent defines
  the access to its methods and variables, the
  children cannot modify them.

7
Inheritance

• extends keyword
• Default superclass Object
• Inheriting the methods of the Object class
• inheriting the variables of the Object class
• class A inherits from class B
• class A inherits the variables from class B
• class A inherits the methods from class B
• Inheritance is restricted to the non-private
  methods and variables

8
Examples of inheritance
9
Public, Final Abstract classes

• Classes can be declared to be either public,
  abstract, or final, or some combination of the
  three.
• However, before we can make any sense out of the
  public keyword, we need to know a little about
  how classes are grouped into packages.

10
Packages

• We will see packages later on in more details.
• In simple words, packages are a way to group
  classes together.
• A class defines its package by adding the keyword
  package at the beginning of the file.
• Example
• package com.mellon.aPackageName

11
Public classes

• Explicitly define the public keyword otherwise
  your class will be visible only within its own
  package

12
Abstract Classes

• An abstract class is a class that is designed to
  be inherited from (subclassed). It is not
  intended to be a class from which objects are
  instantiated (you cannot do a new on the class)
• Note that the methods themselves can be abstract
• Why create abstract classes?

13
Final Classes

• The opposite of an abstract class is a final
  class. A final class cannot be subclassed.
• Why use final classes?
• Can a class be both abstract and final?
• Examples
• abstract and final
• final class A is extended by class B

14
Examples of abstract and final classes
15
Interfaces

• Interfaces are like the roles that a class can
  play
• A class that implements an interface must define
  the methods that are specified by the interface
• Whenever a class claims to implement an
  interface, you can be assured that it provides a
  definition for all the methods declared within
  that interface. Otherwise, the class cannot be
  compiled.

16
Implementing Interfaces

• A class may implement one or more interfaces
  using the keyword implements and a
  comma-delimited list of interface names as shown
  belowclass MyClassName extends MySuperClass
• implements MyInterface,
  YourInterface
• //body of class

17
Examples with interfaces
18
Constructors

• Constructors are used to instantiate a class
• Even if you dont explicitly define a constructor
  the compiler creates one for you
• It is safer to explicitly define the
  constructor(s)
• Constructor(s) are methods that have the same
  name has the class name and return void

19
Multiple Constructors

• A class can have multiple constructors
• The only difference between them is the list of
  parameters that comes with the constructor
• Why are they parameters to the constructors?

20
A super keyword

• The super keyword allows a constructor to call
  the constructor of a parent class
• If present in the constructor the super keyword
  must appear first in the body of the method
• Why must super appear first?

21
Access control to the constructors

• A constructor can be private, protected, or
  public
• Always explicitly specify the access
• If all the constructors are private how do I
  instantiate the class

22
Examples of constructors
23
Variables

• Types of variables
• Member variables
• class variables
• Instance variables
• Method variables
• local variables

24
The static keyword

• The keyword static determines whether the
  variable is a class variable or an instance
  variable
• To access a static variable you must qualify it
  with the class name (NOT the instance name)
• for exampleClassName.theVariableName aValue
• Why should we use static variable?

25
Final Variables

• Determines whether the variable is a constant or
  not
• Example
• declaring a final object and trying to assign a
  new value to it

26
Controlling access to member variables

• Classes can protect their member variables from
  being access by other objects

27
Subtleties of the private keywords

• It is applied at the class level. In other words,
  objects of the same types have access to each
  others private variables

28
Subtleties of the protected keyword

• The protected member variable of a super class is
  accessible from a subclass only if the subclass
  and the superclass are in the same package

29
Subtleties of the public keyword

• None!
• Everyone can see a public member variable.

30
Subtleties of the package keyword

• You get package level access if you dont specify
  the access level

31
Examples of access levels on member variables
32
Access level to member methods

• Works just like member variables access level

33
Instance Vs. Class Members(methods and variables)

• instance member by default
• use static to override the default and it the
  member becomes a class member

34
Class Members

• All instances of a class share the same copy of
  the class member
• class variables can be accessed via the instance
  (use the instance name) or via the class itself
  (use the class name)

35
Instance Members

• By default all members are instance members
• Every instantiated class carries its own copy of
  the instance variable. In other words, instance
  variables are not shared across instances of the
  class

36
Examples of instance and class members
37
Packages

• Purpose
• grouping relevant classes together
• avoiding name clashes among developers
• Notation
• package mypackage
• public class AnyClass
• .
• Scope of the package statement
• entire source file
• If you dont declare a package
• the compiler puts your class in the default
  package

38
Package name conventions

• Use reversed Internet domain name
• com.company.package
• example
• com.mellon.lineofbusiness.packagename
• com.sun...
• edu.cmu

39
Using a package

• Strategy 1
• use the packagename.classname approach
• example
• com.mellon.aClassName s new com.mellon.aClassNam
  e()
• Strategy 2
• import the package
• put import statement at the beginning of the file
  and after the package statement
• import com.mellon.
• aClasName s new aClassName()
• Use wildcards where necessary
• java.lang. is always imported by default

40
Compiler, Run-time and Packages

• Compiler (javac)
• creates directories that reflect the package
  hierarchy
• compiles the files and places them in their
  respective directory hierarchy
• uses the classpath option on the command line
  to find the source files within the hierarchy of
  directories.
• Example
• javac -classpath .c\myclassesc\jdk\lib\classes
  .zip .java
• Run-time (java)
• uses the classpath option on the command line
  to find classes within the hierarchy of
  directories.
• Example
• java -classpath .c\myclassesc\jdk\lib\classes.
  zip