Modificateurs Java | Exam-Lib
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Modificateurs Java

abdelouafiNov 10, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      893
      Likes Received:
      14
      Trophy Points:
      18
      Joined
      Sep 13, 2016
      Modificateurs
      A présent, vous connaissez bien le mot clé public qui apparaît dans presque tous nos exemples:
      Code:
      public class MyClass
      
      Le mot clé public est un modificateur d'accès, ce qui signifie qu'il est utilisé pour définir le niveau d'accès des classes, attributs, méthodes et constructeurs.

      Nous divisons les modificateurs en deux groupes:

      • Modificateurs d'accès - contrôle le niveau d'accès
      • Modificateurs sans accès - ne contrôlent pas le niveau d'accès, mais fournissent d'autres fonctionnalités


      Modificateurs d'accès
      Pour les classes, vous pouvez utiliser public ou default:

      • public La classe est accessible à toute autre classe.
      • default La classe n'est accessible que par les classes du même package. Ceci est utilisé lorsque vous ne spécifiez pas de modificateur. Vous en apprendrez plus sur les paquets dans le chapitre Paquets
      Code:
      public class MyClass {
        public static void main(String[] args) {
          System.out.println("Hello World");
        }
      }
      
      Code:
      class MyClass {
        public static void main(String[] args) {
          System.out.println("Hello World");
        }
      }
      
      Pour les attributs, les méthodes et les constructeurs, vous pouvez utiliser l'un des éléments suivants:
      • public Le code est accessible à toutes les classes
      • private Le code est uniquement accessible dans la classe déclarée
      • default Le code n'est accessible que dans le même package. Ceci est utilisé lorsque vous ne spécifiez pas de modificateur. Vous en apprendrez plus sur les paquets dans le chapitre Paquets
      • protected Le code est accessible dans le même package et les mêmes sous-classes. Vous en apprendrez plus sur les sous-classes et les super-classes dans le chapitre Héritage


      Code:
      /* Code from filename: Person.java
      public class Person {
        public String fname = "John";
        public String lname = "Doe";
        public String email = "john@doe.com";
        public int age = 24;
      }
      */
      
      class MyClass {
        public static void main(String[] args) {
          Person myObj = new Person();
          System.out.println("Name: " + myObj.fname + " " + myObj.lname);
          System.out.println("Email: " + myObj.email);
          System.out.println("Age: " + myObj.age);
        }
      }
      
      Code:
      public class Person {
        private String fname = "John";
        private String lname = "Doe";
        private String email = "john@doe.com";
        private int age = 24;
       
        public static void main(String[] args) {
          Person myObj = new Person();
          System.out.println("Name: " + myObj.fname + " " + myObj.lname);
          System.out.println("Email: " + myObj.email);
          System.out.println("Age: " + myObj.age);
        }
      }
      
      Code:
      class Person {
        String fname = "John";
        String lname = "Doe";
        String email = "john@doe.com";
        int age = 24;
       
        public static void main(String[] args) {
          Person myObj = new Person();
          System.out.println("Name: " + myObj.fname + " " + myObj.lname);
          System.out.println("Email: " + myObj.email);
          System.out.println("Age: " + myObj.age);
        }
      }
      
      Code:
      class Person {
        protected String fname = "John";
        protected String lname = "Doe";
        protected String email = "john@doe.com";
        protected int age = 24;
      }
      
      class Student extends Person {
        private int graduationYear = 2018;
        public static void main(String[] args) {
          Student myObj = new Student();
          System.out.println("Name: " + myObj.fname + " " + myObj.lname);
          System.out.println("Email: " + myObj.email);
          System.out.println("Age: " + myObj.age);
          System.out.println("Graduation Year: " + myObj.graduationYear);
        }
      }
      

      Modificateurs non d'accès
      Pour les cours, vous pouvez utiliser final ou abstract:
      • final La classe ne peut pas être héritée par d'autres classes (vous en apprendrez plus sur l'héritage dans le chapitre Héritage)
      • abstract La classe ne peut pas être utilisée pour créer des objets (pour accéder à une classe abstraite, elle doit être héritée d'une autre classe. Vous en apprendrez plus sur l'héritage dans le chapitre Héritage.)

      Code:
      final class MyClass {
        public static void main(String[] args) {
          System.out.println("Hello World");
        }
      }
      
      Code:
      /* Code from filename: Person.java
      // abstract class
      abstract class Person {
        public String fname = "John";
        public String lname = "Doe";
        public String email = "john@doe.com";
        public int age = 24;
        public abstract void study(); // abstract method
      }
      
      // Subclass (inherit from Person)
      class Student extends Person {
        public int graduationYear = 2018;
        public void study() {
          System.out.println("Studying all day long");
        }
      }
      */
      
      class MyClass {
        public static void main(String[] args) {
          // create an object of the Student class (which inherits attributes and methods from Person)
          Student myObj = new Student();
         
          System.out.println("Name: " + myObj.fname + " " + myObj.lname);
          System.out.println("Email: " + myObj.email);
          System.out.println("Age: " + myObj.age);
          System.out.println("Graduation Year: " + myObj.graduationYear);
          myObj.study(); // call abstract method
        }
      }
      

      Pour les attributs et les méthodes, vous pouvez utiliser l'un des éléments suivants:
      • final: les attributs et les méthodes ne peuvent pas être remplacés / modifiés
      • static: les attributs et méthodes appartiennent à la classe plutôt qu'à un objet
      • abstract: ne peut être utilisé que dans une classe abstraite et sur des méthodes. La méthode n'a pas de corps, par exemple, abstract void run () ;. Le corps est fourni par la sous-classe (héritée de). Vous en apprendrez plus sur l'héritage dans le chapitre Héritage
      • transitoire: les attributs et les méthodes sont ignorés lors de la sérialisation de l'objet les contenant
      • synchronized: les méthodes ne sont accessibles que par un thread à la fois
      • volatile: la valeur d'un attribut n'est pas cachée localement par le thread et est toujours lue dans la "mémoire principale"

      Final
      Si vous ne souhaitez pas pouvoir remplacer les valeurs d'attribut existantes, déclarez les variables en tant que final:

      Exemple
      Code:
      public class MyClass {
        final int x = 10;
        final double PI = 3.14;
      
        public static void main(String[] args) {
          MyClass myObj = new MyClass();
          myObj.x = 50; // will generate an error: cannot assign a value to a final variable
          myObj.PI = 25; // will generate an error: cannot assign a value to a final variable
          System.out.println(myObj.x);
        }
      }

      Statique
      Une méthode statique signifie qu'elle appartient à la classe et que vous ne pouvez pas y accéder depuis l'extérieur de la classe, contrairement à public:

      Exemple
      Code:
      ublic class MyClass {
       
        // Static method
        static void myStaticMethod() {
          System.out.println("Static methods can be called without creating objects");
        }
      
        // Public method
        public void myPublicMethod() {
          System.out.println("Public methods must be called by creating objects");
        }
      
      }

      Abstrait
      Une méthode abstraite appartient à une classe abstraite et n'a pas de corps. Le corps est fourni par la sous-classe:

      Exemple
      Code:
      // Code from filename: Person.java
      // abstract class
      abstract class Person {
        public String fname = "John";
        public int age = 24;
        public abstract void study(); // abstract method
      }
      
      // Subclass (inherit from Person)
      class Student extends Person {
        public int graduationYear = 2018;
        public void study() { // the body of the abstract method is provided here
          System.out.println("Studying all day long");
        }
      }
      // End code from filename: Person.java
      
      // Code from filename: MyClass.java
      class MyClass {
        public static void main(String[] args) {
          // create an object of the Student class (which inherits attributes and methods from Person)
          Student myObj = new Student();
      
          System.out.println("Name: " + myObj.fname);
          System.out.println("Age: " + myObj.age);
          System.out.println("Graduation Year: " + myObj.graduationYear);
          myObj.study(); // call abstract method
        }
      }
      Code:
      /* Code from filename: Person.java
      // abstract class
      abstract class Person {
        public String fname = "John";
        public int age = 24;
        public abstract void study(); // abstract method
      }
      
      // Subclass (inherit from Person)
      class Student extends Person {
        public int graduationYear = 2018;
        public void study() { // the body of the abstract method is provided here
          System.out.println("Studying all day long");
        }
      }
      */
      
      class MyClass {
        public static void main(String[] args) {
          // create an object of the Student class (which inherits attributes and methods from Person)
          Student myObj = new Student();
         
          System.out.println("Name: " + myObj.fname);
          System.out.println("Age: " + myObj.age);
          System.out.println("Graduation Year: " + myObj.graduationYear);
          myObj.study(); // call abstract method
        }
      }
      
       
      Older Threads
      Related Threads
      Loading...

      Merci de partager ce post sur facebook

Share This Page

Share