Exam Topics

• Java Basics
• Working With Java Data Types
• Using Operators and Decision Constructs
• Creating and Using Arrays
• Using Loop Constructs
• Working with Methods and Encapsulation
• Working with Inheritance
• Handling Exceptions

Define the scope of variables

• Used correctly, variable scope enables a program to reuse and conserve memory.
• Different kinds of variables have different scopes.
• There are a two main scopes of variables in Java - determining of class and method (fields and variables).
• A local variable shadows an instance variable.
• Instance variable shadows the inherited variable from it's parent classes.
• Instance variables are not overridden, they are hidden.

Variables

• A variable is a main element of the data storage in Java program.
• A variable is a memory location that may be assigned a value.
• The value of a variable is changeable.
• A variable is defined by an identifier, a type, and an optional initializer.
• The variables also have a scope (visibility / lifetime).

Variables

The Java programming language defines the following kinds of variables:

• fields:
  • Instance Variables (Non-Static Fields)
  • Class Variables (Static Fields)
• variables:
  • Local Variables
  • Parameters

Instance Variables

• Instance variables are declared in a class, but outside a method, constructor or any block.
• .
• .
• .

Instance Variables

• Instance Variable может быть доступна только в пределах существования экземпляра класса.
• Instance Variable может явно содержать модификатор доступа.
• Instance Variable вызывается через обращение к объекту класса.
• Все Instance Variables которым небыли присвоены явные значения, автоматически инициализуются значениями по умолчанию перед вызовом конструктора.

public class InstanceVariables {	
	private int i;	
	public void print() { System.out.println(i); }
	public static void main(String[] args) {
		new InstanceVariables().print(); // 0
	}
}

Class Variables

• Cтатические переменные инициализируются в момент загрузки класса и уничтожаются, когда программа останавливается.
• Cтатические переменные едины для всех экземляров класса.

Constants

• Константы в Java это переменные класса объявленные как public/private, final и static.
• Константы никогда не изменяют начального состояния.
• Константы принято именовать в верхнем регистре.

class Employee{
   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development";
}

Local Variables

• Локальные переменные не инициализуются значениями по умолчанию автоматически.
• Локальные переменные должны быть явно инициализированы перед использованием, иначе будет ошибка компиляции.
• Access modifiers cannot be used for local variables.
• Local variables are visible only within the declared method, constructor or block.

public int wrongLocalInit(int p) {
    int i; // right way: // int i = 0;
    if (p < 5)
        i += 5; // The local variable i may not have been initialized
    return i;
}

Method Parameters

Define the scope of variables

• Область видимости определяет продолжительность существования переменных.
• Java допускает объявление переменных внутри любого блока (в фигурных скобках).
• Правила обработки области видимости - основы инкапсуляции.
• Области видимости могут быть вложенными.
• Объекты объявленный во внешней области, будут видны коду во внутренней области.

Define the scope of variables

• Входные параметры метода также включаются в его область видимости.
• Переменные объявленные внутри области видимости, не доступны внешнему коду.
• Внутри блока переменные можно объявлять в любом месте, но доступными они становятся только после объявления.
• Продолжительность существования переменной ограничена ее областью видимости.
• Во внутреннем блоке нельзя объявить переменную с тем же именем что и во внешнем.

Define the structure of a Java class

• Класс - центральное понятие в Java.
• Класс используется для создания объектов.
• Класс определяет новый тип данных.
• Класс - это шаблон объекта, а объект - это экземпляр класса.
• Код класса определяет интерфейс к его данным.

Define the structure of a Java class

• Для объявления класса служит ключевое слово class.
• Класс может не содержать метод main().
• Для доступа к переменным применяется оператор точка ..
• Для создания объекта класса служит оператор new.

Define the structure of a Java class

• Для Java все объекты классов должны создаваться динамически, используя оператор new.
• Ссылка на объект класса содержит адрес объекта в памяти и хранится в переменной.

Box obj; //объявление ссылки на объект
// obj = null;
obj = new Box(); // резервирование памяти для объекта
// и присвоение переменной obj ссылки на этот объект
// Box() - конструктор класса Box

Create executable Java applications with a main method

Import other Java packages to make them accessible in your code

• A package is a namespace that organizes a set of related classes and interfaces.
• The names of your types won't conflict with the type names in other packages because the package creates a new namespace.

Working With Java Data Types

Declaring a Variable

• In Java, all variables must be declared before they can be used.
• To declare more than one variable of the specified type, use a comma-separated list.

public static void main(String[] argv) {
    int a, b, c; // declares three ints, a, b, and c.
    int d = 3, e, f = 5; // declares three more ints, initializing d and f.
    byte z = 2; // initializes z.
    double pi = 3.14; // declares an approximation of pi.
    char x = 'x'; // the variable x has the value 'x'.
}

Arrays

Declare, instantiate, initialize and use:

• a one-dimensional arrays
• multi-dimensional arrays
• an ArrayList

One-dimensional arrays

• An array is a container object that holds a fixed number of values of a single type.
• The length of an array is established when the array is created. After creation, its length is fixed.
• Each element in an array is accessed by its numerical index.
• The elements of arrays are always set to default values wherever the array is created. (default values)

Multi-dimensional arrays

ArrayList

• The ArrayList class extends AbstractList and implements the List interface.
• ArrayList supports dynamic arrays that can grow as needed.
• Constructs an empty list with an initial capacity of ten.
• A collection is an object that can hold references to other objects.

ArrayList

• The capacity is the size of the underlying array that is used to store the elements.
• Only function size() returns the number of ArrayList object elements.

List arr = ArrayList();
arr.size();
arr.contains(100);
arr.remove("asd");

Methods and Encapsulation

• Create methods with arguments and return values
• Apply the static keyword to methods and fields
• Create an overloaded method
• Differentiate between default and user defined constructors
• Create and overload constructors
• Apply access modifiers
• Apply encapsulation principles to a class
• Determine the effect upon object references and primitive values when they are passed into methods that change the values

Create methods

static keyword (for methods and fields)

Method overloading

• If a few methods of an one class have the same name but signatures that are not override-equivalent, then the method name is said to be overloaded.
• The method signature is the method's name and the parameter types.
• Method overloading is one of the ways that Java implements polymorphism.
• When an overloaded method is invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call.

Method overloading

• A difference in return type only is not sufficient to constitute an overload and is illegal.
• You can have two methods with the same arguments and different return types only if one of the methods is inherited and the return types are compatible.
• Overloaded methods may call one another simply by providing a normal method call with an appropriately formed argument list.

Constructors

Constructor overloading

Access modifiers

Encapsulation principles

Pass by Value

Use abstract classes and interfaces

• Интерфейсы сообщают классу что он должен делать, но не то как он это будет делать.
• Интерфейсы могут наследовать множество интерфейсов (implements), но не могут наследовать классы.
• Интерфейсы предназначены для поддержки динамического разрешения методов во время выполнения.
• В файле должен быть объявлен только один public интерфейс.

Use abstract classes and interfaces

• Вложенный интерфейс может быть объявлен как public, private или protected..
• Класс может наследовать только один класс (extends), но реализовывать множество интерфейсов (implements).
• Каждый класс, который включает в себя интерфейс, должен реализовать все его методы.
• Классы никак не связанные между собой в иерархии классов, могут реализовывать один интерфейс.

Use abstract classes and interfaces

• Внутри интерфейса, методы не могут содержать реализации и неявно объявляются как public.
• При реализации, метод также должен быть объявлен как public с тойже самой сигнатурой типа.

interface Shape {
	void Draw(); // public by default
}
class Circle implements Shape {
	void Draw() {// Error: by default method not public 
// Cannot reduce the visibility of the inherited method from Shape
		System.out.println("Drawing Circle here");
	}
}

Use abstract classes and interfaces

• Внутри интерфеса могут быть объявлены неизменяемые переменные (final + static).

public interface CarConstants {

      static final String ENGINE = "mechanical"; // public by default
      static public final String WHEEL  = "round";
      
}

Use abstract classes and interfaces

• Переменные можно объявлять с типом интерфейса, для обращения к нескольким реализация интерфеса.

interface IBox {
	public void setSize(int size);
}
public class Rectangle implements IBox {
	private int size;
	public void setSize(int size) { this.size = size; }
	public static void main(String[] args) {
        // myBox contains the methods/fields ONLY from IBox
		IBox myBox = new Rectangle(); myBox.setSize(10);
	}
}

Use abstract classes and interfaces

• Если класс содержит интерфейс, но не полностью реализует определенные им методы, он должен быть объявлен как abstract.
• Абстрактный класс не может содержать объекты.
• Абстрактный класс не может быть создан с помощью оператора new.
• Возможно создание объектной ссылки на абстрактный класс, также как и на интерфес.

Use abstract classes and interfaces

• Если класс имеет абстрактные методы, он также должен быть объявлен как abstract.
• Абстрактный метод обязательно должен быть переопределен в потомке.
• Абстрактный класс может содержать не абстрактные методы, которые можно и не переопределять.
• В абстрактном классе нельзя объявить абстрактные конструкторы или абстрактные статические методы.

Exceptions

• Исключением является событием, которое происходит во время выполнения программы и нарушает нормальный ход программы.
• Исключение - это ошибка времени исполнения.
• Любое исключение не перехваченное программой, будет обработано стандартным обаботчиком, программа будет прервана.

Differentiate among checked exceptions, RuntimeExceptions and Errors

Create a try-catch block and determine how exceptions alter normal program flow

Describe what exceptions are used for in Java

• Исключения могут создаваться системой времени выполнения Java либо могут быть созданы вручную.

Invoke a method that throws an exception

• Конструкция throws перечисляет типы исключений, которые метод может передавать.
• Передать исключение по команде throw можно только если в определении функции будет указано это исключение после ключевого слова throws.
• Исключение может быть объявлено в описании функции, но не вызываться в ее теле.

Конструкция throws перечисляет типы исключений, которые метод может передавать.

import java.io.IOException;
import java.text.ParseException;

public class ThrowsExceptionExample {
	public static void main(String[] args) throws IOException, 
		ParseException {
	}
}

Любое исключение, которое создается и передается внутри метода, должно быть указано в его описании после ключевого слова throws.

public class ThrowExceptionExample {
	public static void main(String[] args) {
		//throw new Exception(); // Error: Unhandled exception type Exception
	}
}

Исключение может быть объявлено в описании функции, но не вызываться в ее теле.

public class AccountExceptionExample {
	public void withdraw() throws Exception {
		// no errors
	}
	public static void main(String[] args) 
		throws Exception {
		new AccountExceptionExample().withdraw();
	}
}

Recognize common exception classes and categories

• Все типы исключений происходщят от встроенного класса Throwable.
• Далее все исключения делятся на две ветви Exceptions, от которой происходят все пользовательские исключения и Error.
• В классе Exception подкласс RuntimeException исключения являются непроверяемыми и автоматически определяются для программ.
• Исключения определенные классом Error обычно возникают в следствие катастрофических сбоев, которые не могут быть обработаны программой.

Declaring a Variables

The Java programming language defines the following kinds of variables:

public class Variables {
	private int instance_var = 1; //instance variable
	public static int CLASS_VAR = 2; //class variable
	public void method(String[] parameters) { //parameter
		int local_var = 3; //local variable
	}
}

Variables

A local variable shadows an instance variable.

class TwoScopes {
	int a = 10;
	public TwoScopes() {
		int a = 5; // hiding (shadowing)
		System.out.println(a); // 5
		System.out.println(this.a); // 10
	}
}
public class TwoScopesExamples {
	public static void main(String[] args) {
		new TwoScopes();
	}
}

Variables

Instance variable shadows the inherited variable from it's parent classes.

class Base {
	public String greeting = "Hello";
}
class Sub extends Base {
	public String greeting = "Good Bye"; // hiding the inherited version
	public String getGreeting() { return greeting; }
}
public class VariableOverridingTest {
	public static void main(String[] args) {
		Base obj = new Sub(); System.out.println(obj.greeting); // "Hello"
		obj.greeting = "How are you";
		System.out.println(obj.greeting); // "How are you"
		System.out.println(obj.getGreeting()); // "Good Bye"
	}
}

Arrays

An array is a container object that holds a fixed number of values of a single type

// declares an array of integers
int[] anArray;
// this form is discouraged
float anArrayOfFloats[];

// will be created an eleven objects
String[] s = new String[10];

Arrays

The length of an array is established when the array is created. After creation, its length is fixed.

// allocates memory for 10 integers
int[] anArray = new int[10];
// Note that arrays have a length 
// field not a length() method.
for(int j = 0; j < anArray.length; j++) {
	anArray[j] = j;
}

Arrays

Each element in an array is accessed by its numerical index.

int i = 0;
long j = 0;
String s[] = { "a", "b", "c", "d" }
String c1[] = s[i]; // ok
String c2[] = s[j]; // compile error!

Data types default values

Hiding & Overriding

class Base {
	public String greeting = "Hello";
	public String getGreeting() { return greeting; }
}

class Sub extends Base {
    // greeting (Base)
	public String greeting = "Good Bye"; // greeting (Sub)
	@Override
	public String getGreeting() { return greeting; 
	// return super.greeting; // hidded
	}
}

public class VariableOverridingTest {
	public static void main(String[] args) {
		Base obj1 = new Base();
		Base obj2 = new Sub();
		System.out.println(obj1.getGreeting()); // "Hello"
		System.out.println(obj2.getGreeting()); // "Good Bye"
	}
}

Method overloading

If a few methods of an one class have the same name but signatures that are not override-equivalent, then the method name is said to be overloaded.

public class Shape {	
	/** display Square area */
	static void displayArea(int a) {
		System.out.println(a*a);
	}
	/** display Triangle area */
	static void displayArea(int b, int h) {
		System.out.println((b*h)/2);
	}	 
	public static void main(String[] args) {
		int a = 3, b = 4, c = 5;
		displayArea(a);
		displayArea(b, c);
	}
}

Method overloading

Method overloading is one of the ways that Java implements polymorphism.

public class OverloadingExample {
	public static void print(Object foo) {
		System.out.println("Object");
	}
	public static void print(Integer foo) {
		System.out.println("Integer");
	}
	public static void main(String[] args) {
		Object foo = new Integer(42);
		print(foo);
		Object bar = new Object();
		print(bar);
	}
}

Method overloading

When an overloaded method is invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call.

public class OverloadingExample {
	public static void main(String[] args) {
		print("asd");
		print(10);
	}
	public static void print(int i) {
		System.out.println("int: " + i);
	}	
	public static void print(String s) {
		System.out.println("String: " + s);
	}
}

Method overloading

You can have two methods with the same arguments and different return types only if one of the methods is inherited and the return types are compatible.

class A { 
    Object foo() { System.out.println("A.foo()");
        return new Object(); 
    } 
}
class B extends A { 
    String foo() { System.out.println("B.foo()");
        return new String(); 
    } 
}
public class OverloadingExample2 {
	public static void main(String[] args) {
		Object foo1 = new A().foo();
		Object foo2 = new B().foo();
	}
}

Method overloading

A difference in return type only is not sufficient to constitute an overload and is illegal.

public class OverloadingExample3 {
	private static int sum = 0;
	public static void main(String[] args) {
		System.out.println(sum(1,2));
	}	
	public static int sum(int i, int j) { 
        return (i + j); 
    }
	public static void sum(int i, int j) { 
        sum = i + j; 
    }	
}

Method overloading

Overloaded methods may call one another simply by providing a normal method call with an appropriately formed argument list.

public class OverloadingExample7 {
	public static void main(String[] args) {
		Object a = "asd"; print(a);
		a = 12; print(a);
	}
	public static void print(Object o) {
		if (o instanceof String) print((String) o);
		if (o instanceof Integer) print((Integer) o);
	}	
	private static void print(String s) {
		System.out.println("String: " + s);
	}	
	private static void print(Integer i) {
		System.out.println("Integer: " + i);
	}
}