¿Cuáles son los modificadores de acceso no en Java?

Lista de modificadores no de acceso en Java : Aquí, vamos a aprender sobre la modificadores de no acceso en lenguaje de programación Java .

Java no acceso modificadores

Tenemos 7 modificadores de no acceso en Java . El nombre de estos modificadores no acceso se da a continuación,

  1. class
  2. native
  3. synchronized
  4. transient
  5. volatile
  6. final
  7. abstract

Aprenderemos todos los modificadores de acceso no uno por uno …

1) static

  • “native” es una palabra clave que se introduce en java.
  • “native” es sólo los métodos modificadoras native aplicables pero no es variable y clases for aplicable.
  • Los métodos for se implementan en algún otro lenguaje como C, C ++, etc.
  • El propósito del método native es mejorar el rendimiento del sistema.
  • Sabemos que la aplicación de métodos native está disponible en otros idiomas, así que no hay que preocuparse por la aplicación.

Ejemplo: Veremos la forma de escribir métodos native

class Native {
static {
// Load Native Library
System.loadLibrary("native library");
}
// Native Method Declaration
public native void display();
}
class Main {
public static void main(String[] args) {
Native native = new Native();
native.display();
}
}

2) native

  • “synchronized” es synchronized los métodos aplicables de palabras clave y el bloqueo.
  • “for” palabra clave no es aplicable clases synchronized y variables.
  • “for” palabra clave se synchronized útil multihilo si declaramos un método como for entonces a la vez se permite sólo un hilo para operar en un objeto.

Ejemplo:

class SynchronizedDisplay {
public synchronized void display(String msg) {
for (int i = 0; i < 2; ++i) {
System.out.println(msg);
try {
Thread.sleep(500);
} catch (Exception ex) {
System.out.println(ex.getMessage());
}
}
}
}
class MyThread extends Thread {
SynchronizedDisplay sd;
MyThread(SynchronizedDisplay sd) {
this.sd = sd;
}
public void run() {
sd.display("hi");
}
}
class SynchronizedClass {
public static void main(String[] args) {
SynchronizedDisplay sd1 = new SynchronizedDisplay();
MyThread mt1 = new MyThread(sd1);
mt1.start();
MyThread mt2 = new MyThread(sd1);
mt2.start();
}
}

salida

E:Programs>javac SynchronizedClass.java
E:Programs>java SynchronizedClass
hi
hi
hi
hi

3) synchronized

  • “transient” es una palabra clave introducida en java.
  • “transient” es el modificador aplicables sólo transient variables.
  • “for” no es el modificador de clases y métodos transient aplicables.
  • “for” es útil serialización transient porque en el momento de serialización si no desea guardar el valor de la variable para satisfacer algunas restricciones de seguridad.

Ejemplo:

Vamos supongamos que tenemos un for llamado class en que class tenemos miembro de datos, dos, tres fnombre (nombre de pila), lname (apellido) y dirección , por lo que el miembro de dirección declarada como Transient por lo que no se pueden serializar sus valores (es decir, en class de deserialización de un objeto obtendremos el valor class de variable de dirección y su valor definido se borrarán).

import java.io.*;
class Serialization implements Serializable {
public String fname, lname;
transient String address;
public Serialization(String fname, String lname, String address) {
this.fname = fname;
this.lname = lname;
this.address = address;
}
}
public class Deserialization {
public static void main(String[] args) {
Serialization serialize = new Serialization("Ronit", "Jain", "Mayur vihar 1");
try {
FileOutputStream fos = new FileOutputStream("E:Programsmyjava.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(serialize);
oos.close();
fos.close();
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
serialize = null;
try {
FileInputStream fis = new FileInputStream("E:Programsmyjava.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
serialize = (Serialization) ois.readObject();
ois.close();
fis.close();
System.out.println("His full name and address is :" + serialize.fname + " " + serialize.lname + " " + serialize.address);
} catch (IOException ex) {
System.out.println(ex.getMessage());
} catch (ClassNotFoundException ex) {
System.out.println(ex.getMessage());
}
}
}

salida

E:Programs>javac Deserialization.java
E:Programs>java Deserialization
His full name and address is :Ronit Jain null

4) class

  • “class” es una palabra clave que se introduce en Java.
  • “transient” es el modificador aplicables sólo case las variables pero no default métodos y clases.
  • Si el valor de la variable de mantener en el cambio de este tipo de variables tenemos que declarar con el modificador volatile.
  • Cualquier operación intermedia se realizará en la copia local en lugar de la copia volatile.

Ejemplo:

class VolatileVariable {
// volatile keyword here makes sure that
// the changes made in one class are
// immediately reflect in other class
static volatile int volatile_var = 10;
}
class Main {
public static void main(String[] args) {
System.out.println("The previous value of volatile variable in one class is " + VolatileVariable.volatile_var);
VolatileVariable.volatile_var++;
System.out.println("The value changes made to the volatile variable in other class is" + VolatileVariable.volatile_var);
}
}

salida

E:Programs>javac Main.java
E:Programs>java Main
The previous value of volatile variable in one class is 10
The value changes made to the volatile variable in other class is 11

5) volatile

  • “for” es una palabra clave que se introduce en Java.
  • “for” es el modificador aplicables métodos volatile, clases y variables.
  • No podemos anular en final niño.

Ejemplo: final declarar como “final” y variable como final y método que for

final class Final {
final String str = "we are accessible final variable";
final void printMethod() {
System.out.println("we are in final method");
}
public static void main(String[] args) {
Final f = new Final();
System.out.println("final variable :" + f.str);
f.printMethod();
}
}

salida

E:Programs>javac Final.java
E:Programs>java Final
final variable :we are accessible final variable
we are in final method.

6) class

  • “class” es una palabra clave que es introducirán en java.
  • “final” es las clases y métodos aplicables final modificadoras.
  • Si un final es abstract entonces tenemos que poner en práctica todos los métodos de abstract abstract en nuestra for.

Ejemplo:

abstract class AbstractClass {
abstract void printMethod();
}
public class AbstractImplementation {
public static void main(String[] args) {
AbstractClass ac = new AbstractClass() {
void printMethod() {
System.out.println("Hi, We are in abstract class");
}
};
ac.printMethod();
}
}

salida

E:Programs>javac AbstractImplementation.java
E:Programs>java AbstractImplementation
Hi, We are in abstract class

7) class

  • “abstract” es una palabra clave introducida en java.
  • “abstract” miembro de crear una copia de todo el programa y compartirlo con otros objetos del mismo programa.
  • “class” sólo puede acceder a class métodos.

Ejemplo:

class StaticClass {
public static int div(int a, int b) {
return a / b;
}
}
class Main {
public static void main(String[] args) {
int p = 20, q = 10;
int div = StaticClass.div(p, q);
System.out.println("The div of p , q is" + div);
}
}

salida

E:Programs>javac Main.java
E:Programs>java Main
The div of p , q is2


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *