Nichtzugriffsmodifikatoren in Java

Nichtzugriffsmodifikatoren sind die in Java 7 eingeführten Schlüsselwörter, um JVM über das Verhalten, Methoden oder Variablen usw. einer Klasse zu informieren. Dies hilft bei der Einführung zusätzlicher Funktionalitäten, wie z. B. das letzte Schlüsselwort, das angibt, dass die Variable nicht zweimal initialisiert werden kann. Es wurden insgesamt 7 Nichtzugriffsmodifikatoren eingeführt.

1. Statisch
2. Finale
3. Zusammenfassung
4. Synchronisiert
5. vorübergehend
6. strictfp
7. einheimisch

Typen von Nichtzugriffsmodifikatoren in Java

Im Folgenden sind die Arten von Nichtzugriffsmodifikatoren in Java aufgeführt:

WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 Probetests

1. Letzte Nichtzugriffsmodifikatoren

Dieser Modifikator kann angewendet werden mit:

1. Klasse
2. Methode
3. Instanzvariable
4. Lokale Variable
5. Methodenargumente

• Final Class: Das Final-Schlüsselwort wird mit einer Klasse verwendet, wenn wir deren Vererbung durch eine andere Klasse einschränken möchten. Wenn wir beispielsweise eine endgültige Klasse Honda haben, kann jeder Versuch, diese Klasse zu erweitern, zu einem Fehler bei der Kompilierung führen.

Code:

final class Honda{
public void myFun1(){
System.out.println("Honda Class");
}
}
class Bike extends Honda{
public void myFun1(){
System.out.println("Bike Class");
}
}

Ausgabe:

• Final Method: Final Keyword wird verwendet, um Java Runtime Environment anzugeben, dass diese Methode in keiner ihrer Unterklassen überschrieben werden soll.

Code:

class Honda{
public final void myFun1(){
System.out.println("Honda Class");
}
}
class Bike extends Honda{
public void myFun1(){
System.out.println("Bike Class");
}
}

Ausgabe:

• Finale Variable: Das Schlüsselwort final wird mit einer Variablen verwendet, um jegliche Änderung des Variablenwerts einzuschränken und so JVM anzuweisen, sie als Konstante zu behandeln. Dies bedeutet, dass endgültige Variablen nur einmal initialisiert werden können.

2. Abstrakter Nichtzugriffsmodifikator

• Abstrakte Klasse: Eine Klasse wird als abstrakt deklariert, um anzuzeigen, dass diese Klasse nicht instanziiert werden kann, was bedeutet, dass für diese Klasse keine Objekte gebildet, sondern vererbt werden können. Dennoch verfügt diese Klasse über einen Konstruktor, der innerhalb des Konstruktors ihrer Unterklasse aufgerufen wird. Es kann sowohl abstrakte als auch endgültige Methoden enthalten, wobei abstrakte Methoden in der Unterklasse überschrieben werden.

Code:

public abstract class MyActivity{
public MyActivity(){
}
public final String myFun1(){
}
}

• Abstrakte Methode: Abstrakte Methoden sind Methoden ohne Definition. Es enthält nur die Signatur der Methode und soll darauf hinweisen, dass diese in der Unterklasse überschrieben werden müssen.

Beispiel: public abstract void fun1();

Code:

abstract class Electronics
{
abstract void display();
abstract void display(String msg);
}
class Computers extends Electronics
{
@Override
void display() {
System.out.println("Abstract method is called");
}
@Override
void display(String txt) {
System.out.println(txt);
}
}
public class AbstractDemo {
public static void main(String[] args) {
Computers obj=new Computers();
obj.display();
obj.display("Method with arguments");
}
}

Ausgabe:

3. Synchronisierter Nichtzugriffsmodifikator

Dieses Schlüsselwort hilft, den Zugriff auf eine Methode durch mehrere Threads gleichzeitig zu verhindern, wodurch der Ablauf eines Programms synchronisiert und mithilfe der Multithreading-Funktion die gewünschten Ergebnisse erzielt werden.

Code:

class Person1
{
public synchronized void sendFun(String txt)
{
System.out.println("Sending message\t" + txt );
try
{
Thread.sleep(1000);
}
catch (Exception e)
{
System.out.println("Thread interrupted.");
}
System.out.println("\n" + txt + "Sent");
}
}
class DemoThread extends Thread
{
private String txt;
Person1  person;
DemoThread(String m,  Person1 obj)
{
txt = m;
person = obj;
}
public void run()
{
synchronized(person)
{
person.sendFun(txt);
}
}
}
public class HelloWorld
{
public static void main(String args[])
{
Person1 snd = new Person1();
DemoThread S1 =
new DemoThread( " Hi " , snd );
DemoThread S2 =
new DemoThread( " Bye " , snd );
S1.start();
S2.start();
// wait for threads to end
try
{
S1.join();
S2.join();
}
catch(Exception e)
{
System.out.println("Interrupted");
}
}
}

Ausgabe:

4. Statischer Nichtzugriffsmodifikator

Diese Variable wird für die Speicherverwaltung verwendet und ist das erste, was beim Laden einer Klasse referenziert wird. Diese Mitglieder werden auf Klassenebene behandelt; Daher können sie nicht mithilfe eines Objekts aufgerufen werden. Stattdessen wird der Name der Klasse verwendet, um auf sie zu verweisen.

• Static Variable: If a variable is declared as static, then only a single copy of the variable is created and shared among all the objects. Thus any change made to the variable by one object will be reflected in other others. Therefore,  the variables that hold value on the class level is declared as static.
• Static Class: Static keyword can only be used with nested classes.
• Static Methods: Since Static Methods are referenced by class name thus can only access static member variables and other static methods. Also, these methods cannot be referred to using this or super pointer. The main method is the most common example of a static method that always get loaded while its class is being loaded.
• Static Block: This is said to be a block being used to perform certain operations while class is being loaded. Since it is static thus can use only static members of the class.

Code:

public class Demo
{
// static variable
static int x = 10;
static int y;
//static class
public static class DemoInnerClass{
static int z=10;
}
// static block
static {
System.out.println("Static block initialized.");
y = x + 4;
}
//static method
public static void main(String[] args)
{
System.out.println("from main");
System.out.println("Value of x : "+x);
System.out.println("Value of y : "+y);
System.out.println("Value of z : "+DemoInnerClass.z);
}
}

Output:

5. Native Non Access Modifier

The native keyword is used only with the methods to indicate that the particular method is written in platform -dependent. These are used to improve the system’s performance, and the existing legacy code can be easily reused.

Note: Static, as well as abstract methods, cannot be declared as native.

Example: Consider a function myfun1 in class NativeDemo that is written in C++. To use this code, we will create a link library mylib1 and load it using the class’s static block.

public class DateTimeUtils {
public native String getSystemTime();
static {
System.loadLibrary("nativedatetimeutils");
}
}

6. Strictfp Non-Access Modifier

• Strictfp Class / Method: This keyword is used to ensure that results from an operation on floating-point numbers brings out the same results on every platform. This keyword can not be used with abstract methods, variables or constructors as these need not contain operations.

Code:

public class HelloWorld
{
public strictfp double calSum()
{
double n1 = 10e+07;
double n2 = 9e+08;
return (n1+n2);
}
public static strictfp void main(String[] args)
{
HelloWorld t = new HelloWorld ();
System.out.println("Result is -" + t.calSum());
}
}

Output:

7. Transient Non-Access Modifier

While transferring the data from one end to another over a network, it must be serialised for successful receiving of data, which means convert to byte stream before sending and converting it back at receiving end. To tell JVM about the members who need not undergo serialization instead of being lost during transfer, a transient modifier comes into the picture.

Syntax:

private transient member1;

Code:

import java.io.*;
class Demo implements Serializable
{
int x = 10;
transient int y = 30;
transient static int z = 40;
transient final int d = 50;
public static void main(String[] args) throws Exception
{
Demo input = new Demo();
FileOutputStream tos = new FileOutputStream("abc.txt");
ObjectOutputStream tin = new ObjectOutputStream(tos);
tin.writeObject(input);
FileInputStream fis = new FileInputStream("abc.txt");  ObjectInputStream ois = new ObjectInputStream(fis);
Demo output = (Demo)ois.readObject();
System.out.println("x = " + output.x);
System.out.println("y = " + output.y);
System.out.println("z = " + output.z);
System.out.println("d = " + output.d);
}
}

Output:

Conclusion

Non-access modifiers are the type of modifiers that tell JVM about the behavior of classes, methods, or variables defined and prepared accordingly. It also helps in synchronizing the flow as well as displaying similar results from operations being performed irrespective of the platform used for execution.

Recommended Article

This is a guide to Non Access Modifiers in Java. Here we discuss the Types of Non Access Modifiersand their methods and code implementation in Java. You can also go through our other suggested articles to learn more –

1. Layout in Java
2. Java Compilers
3. Merge Sort In Java
4. Java BufferedReader

Das obige ist der detaillierte Inhalt vonNichtzugriffsmodifikatoren in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!