1 / 106

Access Control

Access Control. Name Space Management. Classes written so far all belong to a single name space: a unique name has to be chosen for each class to avoid name collision. Some way to manage the name space is needed to: 1) ensure that the names are unique

caroun
Download Presentation

Access Control

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Access Control

  2. Name Space Management Classes written so far all belong to a single name space: a unique name has to be chosen for each class to avoid name collision. Some way to manage the name space is needed to: 1) ensure that the names are unique 2) provide a continuous supply of convenient, descriptive names 3) ensure that the names chosen by one programmer will not collide with those chosen by another programmers Java provides a mechanism for partitioning the class name space into more manageable chunks. This mechanism is a package.

  3. Package A package is both a naming and a visibility control mechanism: 1) divides the name space into disjoint subsets It is possible to define classes within a package that are not accessible by code outside the package. 2) controls the visibility of classes and their members It is possible to define class members that are only exposed to other members of the same package. Same-package classes may have an intimate knowledge of each other, but not expose that knowledge to other packages.

  4. Package Definition A package statement inserted as the first line of the source file: package myPackage; class MyClass1 { … } class MyClass2 { … } means that all classes in this file belong to the myPackage package. The package statement creates a name space where such classes are stored. When the package statement is omitted, class names are put into the default package which has no name.

  5. Multiple Source Files Other files may include the same package instruction: package myPackage; class MyClass1 { … } class MyClass2 { … } package myPackage; class MyClass3{ … } A package may be distributed through several source files.

  6. Packages and Directories Java uses file system directories to store packages. Consider the Java source file: package myPackage; class MyClass1 { … } class MyClass2 { … } The bytecode files MyClass1.class and MyClass2.class must be stored in a directory myPackage. Case is significant! Directory names must match package names exactly.

  7. Package Hierarchy To create a package hierarchy, separate each package name with a dot: package myPackage1.myPackage2.myPackage3; A package hierarchy must be stored accordingly in the file system: 1) Unix myPackage1/myPackage2/myPackage3 2) Windows myPackage1\myPackage2\myPackage3 3) Macintosh myPackage1:myPackage2:myPackage3 You cannot rename a package without renaming its directory!

  8. Finding Packages As packages are stored in directories, how does the Java run-time system know where to look for packages? Two ways: 1) The current directory is the default start point - if packages are stored in the current directory or sub-directories, they will be found. 2) Specify a directory path or paths by setting the CLASSPATH environment variable.

  9. CLASSPATH Variable CLASSPATH - environment variable that points to the root directory of the system’s package hierarchy. Several root directories may be specified in CLASSPATH, e.g. the current directory and the C:\myJava directory: .;C:\myJava Java will search for the required packages by looking up subsequent directories described in the CLASSPATH variable.

  10. Finding Packages Consider this package statement: package myPackage; In order for a program to find myPackage, one of the following must be true: 1) program is executed from the directory immediately above myPackage (the parent of myPackage directory) 2) CLASSPATH must be set to include the path to myPackage

  11. Example: Package 1 package MyPack; class Balance { String name; double bal; Balance(String n, double b) { name = n; bal = b; } void show() { if (bal<0) System.out.print("-->> "); System.out.println(name + ": $" + bal); } }

  12. Example: Package 2 class AccountBalance { public static void main(String args[]) { Balance current[] = new Balance[3]; current[0] = new Balance("K. J. Fielding", 123.23); current[1] = new Balance("Will Tell", 157.02); current[2] = new Balance("Tom Jackson", -12.33); for (inti=0; i<3; i++) current[i].show(); } }

  13. Example: Package 3 Save, compile and execute: 1) call the file AccountBalance.java 2) save the file in the directory MyPack 3) compile; AccountBalance.class should be also in MyPack 4) set access to MyPack in CLASSPATH variable, or make the parent of MyPack your current directory 5) run: java MyPack.AccountBalance Make sure to use the package-qualified class name.

  14. Importing of Packages Since classes within packages must be fully-qualified with their package names, it would be tedious to always type long dot-separated names. The import statement allows to use classes or whole packages directly. Importing of a concrete class: import myPackage1.myPackage2.myClass; Importing of all classes within a package: import myPackage1.myPackage2.*;

  15. Access Control • Encapsulation provides an important attribute: Access Control. • Through encapsulation, you can control what parts of a program can access the members of a class. • By controlling access, you can prevent misuse.

  16. Access Control: 2 ways Classes and packages are both means of encapsulating and containing the name space and scope of classes, variables and methods: 1) packages act as a container for classes and other packages 2) classes act as a container for data and code Access control is set separately for classes and class members.

  17. Access Control: Classes What does it mean to access a class ? • Create an instance of class B. • Extend class B. • Access certain methods and variables within class B, depending on the access control of those methods and variables.

  18. Two levels of access: 1)Public Access: A class available in the whole program: public class MyClass { … } 2) Default Access: A class available within the same package only: class MyClass { … }

  19. Default Access package cert; class Beverage{ //code } package exam.stuff; import cert.Beverage; class Tea extends Beverage{ }

  20. Public Access package cert; public class Beverage{ //code } package exam.stuff; import cert.Beverage; class Tea extends Beverage{ }

  21. Non-Access Class Modifiers • We can modify a class declaration using the keywords • final • abstract • Strictfp • We can add these modifiers along with access modifiers

  22. Strictfp • Strictfp is a keyword and can be used to modify a class or a method but never a variable. • Making a class strictfp means that any method code in the class will conform to the IEEE 754 standard rules for floating points. • Without that modifier, floating points used in the method might behave in a patform dependent way.

  23. Final Classes • When used in a class declaration, the final keyword means the class can’t be subclassed. • A final class can’t ever be improved upon or specialized by another programmer.

  24. package cert; public final class Beverage{ public void importantMethod() { } } package exam.stuff; import cert.Beverage; Class Tea extends Beverage{ }

  25. Assignment • Which predefined class is defined as final in java and why?

  26. Abstract Classes abstract class Car{ private double price; private String model; private string year; public abstract void goFast(); } • An abstract class can never be instantiated. • Its sole purpose is to be extended.

  27. class UseCar{ public static void main(String args[]){ Car mycar = new Car(); mycar.goFast(); } }

  28. Import Statement The import statement occurs immediately after the package statement and before the class statement: package myPackage; import otherPackage1;otherPackage2.otherClass; class myClass { … } The Java system accepts this import statement by default: import java.lang.*; This package includes the basic language functions. Without such functions, Java is of no much use.

  29. Name Conflict 1 Suppose a same-named class occurs in two different imported packages: import otherPackage1.*; import otherPackage2.*; class myClass { … otherClass … } package otherPackage1; class otherClass { … } package otherPackage2; class otherClass { … }

  30. Name Conflict 2 Compiler will remain silent, unless we try to use otherClass. Then it will display an error message. In this situation we should use the full name: import otherPackage1.*; import otherPackage2.*; class myClass { … otherPackage1.otherClass … otherPackage2.otherClass … }

  31. Short versus Full References Short reference: import java.util.*; class MyClass extends Date { … } Full reference: class MyClass extends java.util.Date { … } Only the public components in imported package are accessible for nonsub-classes in the importing code!

  32. Example: Packages 2 The importing code has access to the public class Balance of the MyPack package and its two public members: import MyPack.*; class TestBalance { public static void main(String args[]) { Balance test = new Balance("J. J. Jaspers", 99.88); test.show(); } }

  33. Access Issues • Method code in one class can access a member of another class • Whether a subclass can inherit a member of its super class.

  34. Method code in one class can access a member of another class class Zoo { public String CoolMethod(){ return “Wow Baby”; } } Class Moo{ public void useAZoo(){ Zoo z = new Zoo(); System.out.println(“A Zoo says” + z.coolMethods()); } }

  35. Whether a subclass can inherit a member of its super class. class Moo extends Zoo { public void useMyCoolMethod(){ System.out.println(“A Moo says” + this.coolMetho()); Zoo z = new Zoo(); System.out.println(“A Zoo says” + z.coolMethods()); } }

  36. If a subclass inherits a member, it is exactly as if the subclass actually declared the member. • If class A itself can’t be accessed by class B, then no members within class a can be accessed by class B. • Much of the access control centers on whether two classes involved are in the same package or different packages.

  37. Access Control: Members Four levels of access: 1) a member is available in the whole program: public int variable; public int method(…) { … } 2) a member is only available within the same class: private int variable; private int method(…) { … }

  38. Access Control: Members 3) a member is available within the same package (default access): int variable; int method(…) { … } 4) a member is available within the same package as the current class, or within its sub-classes: protected int variable; protected int method(…) { … } The sub-class may be located inside or outside the current package.

  39. Public Access

  40. Public Access -Sludge class package cert; public class Sludge{ public void testIt(){ System.out.println("Sludge"); } }

  41. Public Access – Goo class package book; import cert.Sludge; class Goo{ public static void main(String[] args){ cert.Sludge o = new cert.Sludge(); o.testIt(); } }

  42. Public Access -Observations • Goo and Sludge classes are in different packages. • But Goo can access the method in Sludge because both the Sludge class and testIT() method are marked public. • For a subclass, if a member is declared public, the subclass inherits that member regardless of whether both classes are in the same package.

  43. Public Access - Class Roo package cert; public class Roo{ public String doRooThings(){ return "fun”; } }

  44. Public Access - Class Cloo package notcert; import cert.Roo; class Cloo extends Roo{ public void testCloo(){ System.out.println(doRooThings()); } }

  45. Public Access - Class Toon import notcert.Cloo; class Toon{ public static void main(String args[]){ Cloo c = new Cloo(); System.out.println(c.doRooThings()); c.testCloo(); } }

  46. Private members

  47. Private Access - Class Roo package cert; public class Roo{ private String doRooThings(){ return "fun”; } }

  48. Private Access - Class UseARoo import cert.Roo; class UseARoo{ public void testIt(){ Roo r = new Roo(); System.out.println(r.doRooThings()); } }

  49. Private Access - Class UseARoo -Error • C:\Users\IIIT-Bh\Desktop\java\notcert>javac UseARoo.java • UseARoo.java:9: doRooThings() has private access in cert.Roo • System.out.println(r.doRooThings()); • ^ • 1 error • C:\Users\IIIT-Bh\Desktop\java\notcert>

More Related