Access l.jpg
This presentation is the property of its rightful owner.
Sponsored Links
1 / 18

Access PowerPoint PPT Presentation


void birthday( ) { this.age = this.age + 1; } void growOlder( ) { this.birthday( ); } 9 ... if (this.age < 75) this.birthday(); //

Download Presentation

Access

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Access l.jpg

Access


Overview l.jpg

Overview

  • Questions covered in this talk:

    • How do we access fields and methods?

    • Why have access restrictions?

    • What can have access restrictions?

    • How do we provide or restrict access?


Instance and class variables l.jpg

Instance and class variables

  • You can declare variables within a class

    • These variables are called instance variables, or fields

    • Every object of that class has its own copy of those fields

    • The fields describe something about the object

  • You can also declare static variables within a class

    • There is only one of each static variable

    • A static variable is also called a class variable

    • The static variable describes something about the class as a whole


Method variables l.jpg

Method variables

  • You can declare variables within a method or within a constructor

    • These are called method variables, not fields

    • Method variables are basically used for computation

    • Method variables are strictly temporary, and are used only within that method

    • When a method returns (completes), all its variables are discarded


Example a rabbit class l.jpg

Example: a “Rabbit” class

  • class Rabbit { static int population; // class variable (counts Rabbits) double hunger; //instance variable double fear; // instance variable double courage = 0.75; // instance variable

  • void eat() { double temp; // method variable temp = courage * hunger; if (temp > fear) { System.out.println(“Eating!”); hunger = hunger - 1; } }}


Statements l.jpg

Statements

  • You can declare variables inside a class or inside a method or a constructor

  • You can put statements (executable code) only within methods and constructors, not inside a class

  • Declarations with initializations are still declarations, not statements


Statements must be in methods or in constructors l.jpg

Statements must be in methods(or in constructors)

  • class Rabbit {

    • double hunger; // OK--declaration

    • double fear = 5.0; // OK--still a declaration

    • hunger = 5.0; // illegal--assignment statement

    • Rabbit ( ) { hunger = 5.0; // OK—statement in a constructor}

    • void eat ( ) { hunger = hunger - 1; // OK—statement in a method}

  • }


Access from inside a class l.jpg

Access from inside a class

  • Inside a class, you can access other fields and methods inside the class just by naming them

  • Example:

    • class Person {

    • int age;

    • void birthday( ) { age = age + 1; }

    • void growOlder( ) { birthday( ); }}

  • Equivalently, you can use the keyword this:

    • void birthday( ) { this.age = this.age + 1; }

    • void growOlder( ) { this.birthday( ); }


Accessing from outside a class 1 l.jpg

Accessing from outside a class, 1

  • Outside a class (from some other class) you access instance variables and methods by

    • Naming the object you want to talk to

    • Putting a dot

    • Naming the variable or method

  • Example:

    • // if NOT in class Person, say:if (john.age < 75) john.birthday();

  • Inside the class, the keyword this means “this object”:

    • if (this.age < 75) this.birthday(); // "this" may mean john


Accessing from outside a class 2 l.jpg

Accessing from outside a class, 2

  • Outside a class (from some other class) you access class variables and methods by

    • Naming the class you want to talk to

    • Putting a dot

    • Naming the variable or method

  • Examples:

    • Person.population = Person.population + 1;

    • x = Math.abs(y);


Responsibility l.jpg

Responsibility

  • In Java, objects are considered to be active

    • They have behaviors

    • They are responsible for their own data

    • Data (variables) must be kept consistent

      • Example: population should never be negative

  • In order for a class or object to be responsible for its own data, it must keep control of that data


Loss of control l.jpg

Loss of control

  • Suppose a Rabbit object, bugsBunny, has a variable named hunger

  • Inside the class, this method is fine:

    • void eat ( ) { hunger = hunger - 1; }

  • From outside the class, the following is legal:

    • bugsBunny.hunger = bugsBunny.hunger - 1;

    • But should we be allowed to “reach inside” a rabbit?

    • The class needs to protect itself from errors in other classes (and from malicious behavior)


Private variables and methods l.jpg

private variables and methods

  • If you declare a variable or method to be private, that variable or method can only be accessed from within the class

    • private methods also make sense, e.g.digest()

  • If you declare a variable or method to be public, then any code anywhere can access it

  • Typically, a class or object has both

    • Methods for use by the rest of the program

    • Methods and variables that it alone should control


Levels of access l.jpg

Levels of access

  • private -- access only from within the class

  • “package” -- access from within the class, or from any class in the same directory (“folder”)

    • This is the default; there is nopackage keyword

  • protected -- access from within the class, or from within any subclass, or from any other class in the same directory

  • public -- access from anywhere at all


Levels of access ii l.jpg

Levels of access, II

  • To make a variable or method visible

    • Only within this class: private

    • From this class and its subclasses: not possible

    • From this class and its subclasses, and any other class in this directory: “package” (default)

    • From this subclass and its subclasses, and any other classes in this directory: protected

    • From anywhere: public


Getters and setters l.jpg

Getters and setters

  • One way to control access is via getters and setters:

    • class Rabbit {

      • private double hunger;

      • // getterpublic double getHunger() { return hunger;}

      • // setterpublic void setHunger(double hunger) { this.hunger = hunger;}

  • This seems silly, but it’s much safer and more flexible


Immutable objects l.jpg

Immutable objects

  • Suppose a Planet has a mass, and you want to be able to see its mass but not change it:

    • class Planet {

      • private long mass;

      • // ConstructorPlanet(long mass) { this.mass = mass;}

      • //getterlong getMass() { return mass;}

      • // Notice there is no setter!

    • }


The end l.jpg

The End


  • Login