Classes Java, encapsulation, méthodes héritées

Que sont les membres de la classe

Les méthodes membres et les variables membres modifiées avec static sont appelées membres de classe

Les variables membres modifiées avec static sont appelées variables de classe

Les méthodes membres modifiées avec static sont appelées méthodes de classe

Que sont les variables d'instance

Member les méthodes et les variables membres qui ne sont pas modifiées avec static sont appelées membres d'instance

Les variables membres qui ne sont pas modifiées avec static sont appelées variables d'instance

Les méthodes membres qui ne sont pas modifiées avec static sont appelées méthodes d'instance

Par exemple :

public String name;  //这个就是实例成员（属性） 
public static int age;//这个就是类成员（属性） 

public void a(){
	System.out.println("我叫："+this.name)
}                                    //这个没有加static的方法就是实例方法

public static void a(){           	//这个加了static的方法就是类方法
	System.out.println("我叫："+this.name)
}

Puis variables d'instance et classes Quelle est la différence entre les variables ?

• Tous les objets de cette classe partagent la même variable de classe, mais chaque objet aura sa propre variable d'instance unique

• Tous les objets de cette classe peuvent modifier la valeur de la variable de classe, mais chaque objet ne peut modifier que la valeur de la variable de classe. Votre propre valeur de variable d'instance

• Les variables d'instance doivent créer un objet avant utilisation, selon le nom de l'objet, mais les variables de classe n'ont pas besoin de créer des objets

//定义一个类
public class stu {
    public String name;  //这个类有一个名字这个属性，属于实例成员，也就是需要实例化对象了才可以使用
    //定义构造方法
    public stu(){}    //不管怎么样，都定义一个无参构造
    public stu(String name){    //定义有参构造，需要传入一个字符串名字
       this.name = name;         //这里若不使用this 关键字，那么是不会与上面的实例属性匹配
    }
    //定义方法
    public void a(){
        System.out.println(this.name);
    }
}

Utiliser. cette classe :

public class stu_Test {
    public static void main(String[] args) {
        //实例化两个对象，基于stu类
        stu s1 = new stu("小红");   
        stu s2 = new stu("小王");
        //使用stu类里面的方法
        s1.a();
        s2.a();
    }
    
    //stu s1 = new stu("小红");  将会输出小红
    //stu s2 = new stu("小王");  将会输出小王
}
//通过这个就可以明白每个对象都有属于自己的实例变量（属性）

Ensuite, la méthode de classe et Quelle est la différence entre les méthodes d'instance ?

• Tous les objets de cette classe partagent des méthodes de classe et des méthodes d'instance

• La méthode de classe peut être appelée en utilisant le nom de la classe. Le nom de la méthode ([paramètre]) n'a pas besoin d'être utilisé après l'instanciation de l'objet

.

• La méthode d'instance utilise l'appel Nom de l'objet.Nom de la méthode ([paramètre])

mot-clé statique

Les classes Java fournissent deux types de variables : les variables statiques modifiées avec le mot-clé static et les variables d'instance modifiées sans le mot-clé static. Les variables statiques appartiennent à des classes et n'ont qu'une seule copie en mémoire Tant que la classe où se trouve la variable statique se verra attribuer de l'espace, elle pourra donc être utilisée. Il existe deux façons de référencer des variables statiques, à savoir "class.static variable" et "object.static variable"

méthode membre statique :

• la méthode statique est une méthode d'une classe, qui peut être appelée sans créer d'objet . , les méthodes non statiques sont des méthodes d'objets. Elles ne peuvent être utilisées qu'après la création de l'objet. Les mots clés this et super ne peuvent pas être utilisés dans les méthodes statiques. Elles ne peuvent pas accéder aux variables membres statiques de. la classe à laquelle ils appartiennent et les méthodes membres, car lorsque la méthode statique est appelée, l'objet de cette classe peut ne pas avoir encore été créé. Même s'il a été créé, il est impossible de déterminer quelle méthode d'objet appeler.

• USE DE STATIQUE:

Modifier les variables des membres

• Modifier les méthodes de membre

• Statique Block

• Modifier les classes [modifier uniquement les classes internes, c'est-à-dire les classes internes statiques]

Package d'importation statique
notes statiques : les statiques ne peuvent accéder qu'aux statiques, les non statiques peuvent accéder à la fois aux non statiques et aux statiques.

• Encapsulation :

Le concept d'encapsulation

encapsule des éléments objectifs dans des classes abstraites, et les classes ne peuvent permettre qu'à des classes ou des objets de confiance d'exploiter leurs propriétés et méthodes, et masquer des classes ou des objets non fiables, de sorte que le processus est appelé encapsulation. En bref : scellez vos informations et autorisez uniquement les personnes de confiance à les voir et à les utiliser

Classification encapsulée

Encapsulation des attributs : définissez l'attribut sur privé (privé) et limitez-le uniquement à la classe Utilisation interne

.

Encapsulation des méthodes : pour l'encapsulation des méthodes, définissez les méthodes accessibles de l'extérieur sur public et définissez les méthodes inaccessibles de l'extérieur sur private
Utilisation de l'encapsulation

• Avant l'encapsulation, apprenons d'abord un nouveau modificateur : private private : limitez-le à seulement être utilisé à l'intérieur de la classe (c'est-à-dire que les méthodes et les attributs modifiés par private ne peuvent être trouvés et utilisés que dans cette classe, en dehors de cette classe, c'est l'existence de cet attribut qui est introuvable, ce qui permet également d'obtenir l'effet d'encapsulation)

  //给name这个属性进行封装
  private Strint name; //即可，这也我们在类外是找不到这个属性的存在的

Puisqu'il est encapsulé, il doit y avoir des moyens de modifier et d'utiliser cette encapsulation Oui, c'est la méthode get/set

get/set méthode

public class stu {
    private String name; 
    public void setName(String name){    //set方法：对象调用这个方法，即可对私有属性进行修改
        this.name = name;   
    }
    public String getName(){         //get方法：对象调用这个方法，就可以使用该方法
        return name;
    }
}

Utilisation :

public class stu_Test {
    public static void main(String[] args) {
    stu s =new stu();
    s.setName("小红");  //给name 这个私有属性修改值为小红
        System.out.println(s.getName());
   
}

//Une fois le programme exécuté, la valeur de sortie est Xiaohong

Héritage :

Qu'est-ce que l'héritage

1 : Une nouvelle classe peut être dérivée d'une classe existante. Ce processus est appelé héritage

2 : Pendant le processus d'héritage, la nouvelle classe est appelée un. sous-classe, et la classe existante est appelée classe parent. La sous-classe héritera des attributs et des comportements de la classe parent.

Syntaxe d'héritage :

public class stu extends Student{   //在类名后加上extends，在写上继承的父类即可
//这里可以写父类没有发属性及方法
	public String ID;  //等等等等

}

Remarque : L'héritage ne peut pas hériter des propriétés et méthodes privées de la classe parent ! ! ! Tant qu'il est modifié par private, il ne sera pas hérité ! ! !

À propos des sous-classes : en plus d'avoir les propriétés et méthodes non privées de la classe parent, les sous-classes peuvent également étendre leurs propres propriétés et méthodes

Utilisation de l'héritage :

L'héritage est un héritage unique, c'est-à-dire une classe peut seulement Il existe une classe parent.

Si une classe n'hérite pas explicitement d'une certaine classe, alors elle a une classe parent par défaut qui est la classe java.lang.Object
Hérite des variables membres non privées et des méthodes membres de la classe parent, mais veuillez noter : les sous-classes ne peuvent pas hériter de la méthode de construction de la classe parent. En bref : une sous-classe ne peut hériter que d'une seule classe parent. Si cette classe n'hérite pas d'autres classes, elle héritera de la classe Object par défaut (fournie avec Java)
• .

  Impossible d'hériter de la méthode constructeur de la classe parent.

  方法的重写：

  @overriding

  什么是方法重写？：

  • 子类根据需求从父类继承的方法进行重新编写（方法名一样）

  • 重写是可以使用super方法的方式来保留父亲的方法（super在后面讲到）

  注意：构造方法不能被重写

  方法重写的规则：

  • 方法名相同，参数列表相同（数量，顺序，数据类型）

  • 如果有返回值，返回值相同或者是其子类，访问权限不能严于父类

  • 父类的静态方法不能被重写为非静态方法，反之父类的非静态方法不能被重写为静态方法

  • 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法**（静态方法中无法使用super、this）**

  • 父类的私有方法不能被子类重写（private修饰的）

  上代码：

  1：定义一个类，有名字和年龄的属性，分别有get/set方法，成员方法是输出名字和年龄:

  public class Person {
      private String name;
      private int age;
  
      //get/ste方法
      public void setName(String name){
          this.name = name;
      }
      public String getName(){
          return name;
      }
  
      public void setAge(int age){
          this.age = age;
      }
      public int getAge(){
          return age;
      }
      //成员方法：
      public void print(){
          System.out.println("我叫："+this.name+","+"我今年："+this.age+"岁");
      }
  }

  2：写一个类，继承Person类，并且这个类拥有自己的一个sex属性，提供get/set方法 并且重写父类的print方法，输出名字+年龄+性别

  public class child extends Person{
      private String sex;      //这个child类继承了Person类，但也拥有自己的属性 sex性别
      public void setSex(String sex){
          this.sex = sex;
      }
      public String getSex(){
          return sex;
      }
      @Override
      //重写父类方法： 因为父类是输出名字和年龄，这里要输出名字，年龄和性别
      public void print(){
          System.out.println("我叫："+getName()+","+"我今年："+getAge()+"岁"+","+"我是"+sex+"孩子");
      }
  }

  3：新建测试类，测试两个类的继承、重写

  //测试类，
  public class Test {
      public static void main(String[] args) {
          child c = new child();
          c.setName("小红");
          c.setAge(20);
          c.setSex("男");
          c.print();
      }
  }
  //分别执行child继承person的set方法，使用重写后的方法，

  //输出结果为： 我叫：小红,我今年：20岁我是男孩子

  super关键字：

  super代表的是父类对象

  super的使用方式：

  1：super.属性名 用于在子类中调用父类被隐藏的同名实例变量

  2：super([参数列表]) 用于在子类的构造方法中调用父类的构造方法

  注意事项：

  • 每一个子类的构造方法在没有显示调用super()，系统都会提供一个默认的super()

  • super() 书写在第一行

  • 可以在子类构造方法中显示调用super(),完成对特定父类构造方法的调用

  简而言之：super就是调用父亲的属性和方法来使用

  上代码：

  1:新建一个类：定义age为20

  public class super_test {
      public int age=20;
      public void print(){
          System.out.println(this.age);
      }
  }

  2：建第二个类，继承第一个类；

  public class su2 extends super_test{
      public int age = 10;
      @Override
      public void print(){
          System.out.println(super.age);  //这里使用super，意思是使用父类的age
      }
  }

  3：建立测试类：

  public class test {
      public static void main(String[] args) {
      su2 s = new su2();
      s.print();
  	}
  }

  这样输出的就是20，是父类的age

  this与super的区别:

  • super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函 数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

  • this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的 形参与类中的成员数据同名，这时需用this来指明成员变量名

  • super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其 它构造方法。

  • super()和this()均需放在构造方法内第一行,尽管可以用this调用一个构造器，但却不能调用两个

  • this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造 函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意 义，编译器也不会通过。

  • this()和super()都指的是对象，所以，均不可以在static环境中使用。包括： static变量,static方法，static语句块。

  • 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!