How Much Are The Quo Makeup Brushes

Preparing for SCJP certification (2) Declaration and Class modifiers

After a long break for personal reasons I return to ; publication of the study notes for SCJP certification you want to see the next or previous chapters remember you can go to the index which lists all the Series Here

This time we will review the declaration of classes and the switches that we can use them

write code that is structured always in classes or interfaces (we will speak of packages) and within put variables and methods, the way we declare each of these elements will affect the behavior of our code.

For example to change a public method private to do this out of sight of all the other methods that reference it except in the case of methods belonging to the same class it was declared.



File Declaration Rules Code:

can be only one class with the modifier public per file
Comments may be at the start or end of any line of code
If in a public class file is a file name must be the same as that of the class, for example if we have a class file:

the file must be named Cat.java

order statements is as follows:

• package declaration import statements
class declaration

example

both sentences package or import could not be present, but should be kept the same order, for example based on the previous example the following combinations are valid:



statements import package and apply to all classes within the code file and are declared only once at the beginning of the file, eg

imagine the following code within the file Cat.java

A file can have more than one class that has the public modifier but if that does not contain a public class does not need the same name as any of the classes inside

Class Declaration and Modifiers

enough to declare a class with a ruling class the following code is the minimum necessary to have a valid class:

However, we can add modifiers before the ruling class to modify the behavior of the same, these switches are 2 types:
modifiers access ( public, protected, private )
other switches ( strictfp, final, abstract )

Access Modifiers:

there anything interesting about access levels (also called access control or access control) is that there are 4, but we have only mentioned 3 access modifiers the fourth level of access control is the default access or package, then declare the class before:

has the level of packet access control, in other words, is that we place an access modifier or not, every class method or attribute already has an access level assigned
another point to consider is that although there are 4 levels of access control in a class you can enter only 2 these are:

• A ccess default or package (no modifier) \u200b\u200b
• A ccess public (public switch )

say that a class A has access to a class B means that:

• A can create an instance of B.
• A can extend B (that is, may become a subclass of B).
• A can access to certain methods and variables in B, depending on the control of access to such methods and variables.

When we talk about access classes we also talk about visibility, the level of access that exist between them takes precedence over the level of access that have their methods or attributes, that means that if class A has no access to the class B, no matter what level of access methods or attributes, the class can not access any method or attribute of B.

o Default Access Package
As mentioned this is the level of access that we get if we do not add any switches to a class at this level is also known as Access Level package because a class with default access level can only be seen by other classes that are within the same package as the same level (explain this in the example).

Examples:

file1:

file2:

here Carreta class with package access level is in a different package that the class Auto, and while class file compiles perfectly Carreta class file Auto tells us that "Auto not can be resolved to type "

get the same in the following case:

file1:

file2:

This time Auto class is in the vehicle package is a subpackage of antiques, and yet get the same error so we can concluded that the access level of the package is tight, no matter if the class inherits this in a subpackage.

To make the code work we have 2 options: Declare the class as public Carreta adding the modifier public or placing both classes in the same package as in the following example: file1

:

file2:

This third case is allowed access to the class from the class Car Carreta since both vehicles belong to the package


Public Access A class is publicly accessible if added before of the ruling class public Case with this we are doing this kind visible to all other classes in all packages, but remember that it is necessary even add the statement import to access the class from other packages such



based on the example of previous section for the statement to be validated using public access should change the class declaration by Carreta

file1:

file2:

Other Class Modifiers You
of the access switches are the switches we have seen: s trictfp, abstract and final , and can be used in conjunction with the access modifiers except the combination abstract and final. Switch

final
A class is final if we add to his statement switch final, a final class can not be subclassed, ie any class can inherit from final class, if you try to inherit from this class will get an error message at compile time, the reasons for this are varied but the principal is usually ensure that the implementation of a class remains unchanged, usually for security reasons.
Most classes that make up the core of the sdk are declared as final, for example the class String

should be noted however that much for example the following situation:
Imagine
not have the source code of a class that has not been declared final and need to make changes, you only need to inherit it, implement the necessary changes and calls to replace the old class for the new class you just modify If you need to change the class had been declared final it would not be possible and the change would be impossible to make

Example:
Continuing the example above now declare the class as final Carreta and see the message returned

file1:

file2:

if we tried to run the code would get the message: The type
Auto
Can not subclass final class the Carreta


abstract modifier
A class is abstract if we add to his statement abstract modifier , A abstract class can not be implemented, so that its sole purpose is to be subclassed or inherited by other classes this may be because this class will serve as the father of many classes or because it is too vague a concept to be structured , take for example a class called Animal is too vague as it represents all possible animals, how many legs does it have? how many eyes?, what color is it? ... more. and behave? it move?, walks, flies, no?, suddenly more than one at a time, as is born? of an egg, mother, etc. However

declaring once more specific classes of these questions can be answered as a Dog, Rabbit, etc.

Another fact to be noted is that the methods of an abstract class can also be abstract and therefore not be implemented, only declared. For this we include in the method declaration abstract switch and instead of the braces ({}) end in a semicolon (;) an abstract method has no implementation in this case the implement delegate who inherits the abstract class. An abstract class can have both abstract methods and non-abstract, but a non-abstract class can have abstract methods, in short: if a class contains at least one abstract method, the class must be declared as abstract. An example of non-abstract methods can have an abstract class are getters and setters for its attributes. Example



code above is correct and compiles without problems, however if we try to instantiate the class will get: Animal

class is an abstract class. It Can not Be instantiated.

This concludes the matter on the declaration of classes and access modifiers to them, in the next post will deal with the declaration of interfaces.