Classes, Objects,
Encapsulation
IT Academy
Agenda
• Class and Object • Constructors
• Access to data • Creating objects
• Fields of class • Static Context
• Methods of class
• Encapsulation
Class and Object
• A class is a prototype (template) from which objects are created.
• An object is a software bundle of related state and behavior.
Student student1
has Last name - Petrenko
Last name First name - Ostap
First name Age - 19
Age List of courses – Java, MySQL
List of courses
student2
can Last name - Romaniv
Pass an exam First name - Maryna
Enroll to course Age - 21
List of courses – .NET, MSSQL
Structure of Java Class
<access specifier> class ClassName {
// fields
<access specifier> data_type variable1;
...
<access specifier> data_type variableN;
// constructors
<access specifier> ClassName(parameter_list1) { method body }
...
<access specifier> ClassName(parameter_listN) { method body }
// methods
<access specifier> return_type method1(parameter_list) { method body }
...
<access specifier> return_type methodN(parameter_list) { method body }
}
Example of Java Class
public class Student {
private String lastName; fields
private String firstName;
private int age;
private Student(){} constructor
public boolean passExam(String subject){
//do something
return true;
}
public void print(){
//do something
} methods
}
Special Requirements to source files
• A source code file (.java) can have only one public class.
• Name of this class should be exactly the same of file name before extension
(including casing).
• Source code file can have any number of non-public classes.
• Most code conventions require use only one top-level class per file.
Default Values for Fields
Type Bits Value Default value
byte 8 -128 < x < 127 0
short 16 -32768 < x < 32767 0
int 32 -2147483648 < x < 2147483647 0
long 64 -922372036854775808 < x < 922372036854775807 0L
char 16 0 < x < 65536 '\u0000'
float 32 3,4e-38 < |x| < 3,4e38; 7-8 digits 0.0f
double 64 1,7e-308 < |x| < 1,7e308; 17 digits 0.0d
boolean 8 false, true false
String variable Symbols sequence of Unicode characters. null
Object variable Any object null
Methods
• Methods are functions that are executed in context of object.
• Always have full access to data of object.
• Method definition consists of a method header and a method body.
Kinds of Methods
• Aside from the constructor, most methods can be grouped into two
types:
• accessor methods
• they return information to the user
• mutator methods
• they change the object's state (its fields)
Accessor Method
Mutator Method
Methods Overloading
• Object can have multiple methods with same name but different signature
(type and order of parameters).
class Person {
String name;
public void print() {
System.out.println(name);
}
public void print(String s) {
System.out.println(s + " " + name + "!");
}
public void print(int a) {
System.out.println(name + " is " + a + " years old" );
}
}
• Signature doesn't include return type, methods can't be
overloaded by return types.
Variable length Arguments
• Methods in Java support arguments of variable length.
• Should be last argument in method definition.
public class Util {
public static void print(String str, String... args) {
System.out.print(str);
for (String arg: args) {
System.out.print(arg);
}
}
}
public class Runner {
public static void main (String[] args) {
Util.print("Any ", arguments ", "are ", "possible", "!");
}
}
Access to Fields
• The following class uses public access control:
public class Student {
public String name;
public int age;
... Do not make so!
}
Student student = new Student();
student.name = "Khrystyna";
student.age = 22;
Getters and Setters
• The following class uses private access control:
public class Student {
private String name;
private Date date = new Date();
public String getName() {
return name;
}
public void setName(String value) {
name = value;
}
public Date getDate() {
return date;
}
}
Encapsulation
• Encapsulation in Java is a mechanism of wrapping the data (variables) and
code acting on the data (methods) together as a single unit.
• Encapsulation is used to hide the values or state of a structured data object
inside a class, preventing unauthorized parties direct access to them.
• Benefits of Encapsulation:
• the fields of a class can be made read-only or write-only;
• a class can have total control over what is stored in its fields;
• Isolation your public interface from change (allowing your public interface to stay
constant while the implementation changes without affecting existing consumers).
Getters and Setters
Student student = new Student();
set
student.setName("Franko");
get
String studentName = student.getName();
Keyword this
• The keyword this always points to current object.
• Often needed to distinguish between parameters and fields:
public class Student {
private int age;
public void setAge(int age) {
this.age = age;
}
}
Constructors
• Constructors – special kind of methods called when instance created.
• Class may have multiple overloaded constructors.
• If not provided any constructor, Java provides default constructor.
public class Student {
private String name;
private int age;
public Student(String name) {
this.name = name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
Constructors and keyword this
• Constructors in the same class can call another constructor with the keyword
this and the parameters list.
• Doing so is called an explicit constructor invocation.
class Student {
private String name;
private int age;
private String[] courses;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student(String name, int age, String[] courses) {
this(name, age);
this.courses = courses;
}
}
Constructors
public class Student {
private String name;
private int age;
public static int count = 0;
public Student(){ count++; }
They have
the same
public Student(String name){
this.name = name;
name
count++;
}
public Student(String name, int age){
this.name = name;
this.age = age;
count++;
}
... getters, setters and methods
}
Creating Objects
stud1
Student stud1 = new Student(); Dmytro
count = 1
stud1.setName("Dmytro"); 25
stud1.setAge(25);
stud2
Student stud2 = new Student("Olga");
stud2.setAge(24); Olga
count = 2
24
Student stud3 = new Student("Ivan", 26);
stud3
int number = Student.count; Ivan
count = 3
26
System.out.println(number);
Static Context
• Keyword static indicates that some class member (method or field) is not
associated with any particular object.
• Static members should be accessible by class name (good practice, not required
by language itself).
public class Helper {
private static String message;
public static void setMessage(String message) {
Helper.message = message;
}
public static void print() {
System.out.println(message);
}
}
Static Context
• You can invoke static method without any instance of the class to which it
belongs.
public class Runner {
public static void main (String[] args) {
Helper.setMessage("hello");
Helper.print();
// Not recommended:
Helper helper = new Helper();
helper.setMessage("new message");
helper.print();
}
}
Static Context
• A class can contain code in a static block that does not exist within a method body.
public class Main {
static String str = "Hello Java!";
static {
System.out.println(str);
}
public static void main(String[] args) {
System.out.println("Hello from the method 'main'");
}
}
$ java Main
Hello Java!
Hello from method 'main'
• It's executed when the class is loaded and a good place to put initialization
of static variables.
Thanks for
attention!
IT Academy
