Declaration and Access Control
practice.

In Java, which access modifier allows a class member to be accessed from any class, even outside the package?

What keyword is used to declare a method that is implemented in a subclass to provide a specific implementation?

In Java, what is the purpose of the final keyword when applied to a method?

Which access modifier allows a class member to be accessed from any class in the same package but not from outside?

What keyword is used to declare a variable that can be accessed without creating an instance of the class?

Which access modifier restricts a class member's visibility to only the same class, its package, and subclasses?

In Java, what is the purpose of the final keyword when applied to a class?

Which keyword is used to declare a method that cannot be overridden in a subclass?

What is the access level of a class member declared as protected in Java?

Which keyword is used to explicitly specify that a method should be overridden in a subclass?

Suppose a class has public visibility. In this class we define a protected method. Which of the following statements is correct?

Choose all the lines which if inserted independently instead of "//insert code here" will allow the following code to compile:

public class Test{   
        public static void main(String args[]){
	        add(); 
		add(1);
		add(1, 2); 
	}

	// insert code here
}

What is the result of compiling and running the following code?

class Base{
        private Base(){
                System.out.print("Base");
        }
}
public class test extends Base{
        public test(){
                System.out.print("Derived");
        }
        public static void main(String[] args){
                new test();
        }
}

What is the result of compiling and running the following code?

public class Tester{
	static int x = 4;
	public Tester(){
		System.out.print(this.x); // line 1
		Tester();
	}
	public static void Tester(){ // line 2
		System.out.print(this.x); // line 3
	}
	public static void main(String... args){ // line 4
		new Tester();
	}
}

What is the result of compiling and running the following code?

public class Tester{
	static int x = 4;
	int y = 9;  	
	public Tester(){
		System.out.print(this.x); // line 1
		printVariables();
	}
	public static void printVariables(){
		System.out.print(x); // line 2
		System.out.print(y); // line 3
	}
	public static void main(String... args) { // line 4
		new Tester();
	}
}

The object is created with new keyword

Consider the following two classes declared and defined in two different packages, what can be added in class B to form what considered a correct access to class A from main() method of class B?

package subPackage;
public class A { }


package anotherPackage;
// line 1
	public class B{
		public static void main(String[] args){
		// line 2
	}
}

1. At line1 add noting; At line2 add: new A();
2. At line 1 add: import package.*; at line 2 add : new subPackage.A();
3. At line 1 add: import subPackage.*; at line 2 add : new A();
4. At line 1 add: import subPackage.A; at line 2 add : new A();

Determine output:

public class InitDemo{
	static int i = demo();
	static{
                System.out.print(i);
        }
	InitDemo(){
		System.out.print("hello1");
	}
	public static void main(String... args){
                System.out.print("Hello2");
	}
 	static int demo(){
        	System.out.print("InsideDemo");
		return 10;
	}
}

Which statements are most accurate regarding the following classes?

class A{
        private int i;
        protected int j;
}

class B extends A{
        private int k;
        protected int m;
}

A package is a collection of