access
Download
Skip this Video
Download Presentation
Access

Loading in 2 Seconds...

play fullscreen
1 / 18

Access - PowerPoint PPT Presentation


  • 193 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Access' - Kelvin_Ajay


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
overview
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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!
    • }
ad