Java-Klassen, Kapselung, geerbte Methoden

Was sind Klassenmitglieder?

Mit Statik modifizierte Mitgliedsmethoden und Mitgliedsvariablen werden Klassenmitglieder genannt.

Mit Statik modifizierte Mitgliedsvariablen werden Klassenvariablen genannt.

Mit Statik modifizierte Mitgliedsmethoden werden Klassenmethoden genannt.

Was sind Instanzvariablen? Mitglied Methoden und Mitgliedsvariablen, die nicht durch Statik geändert werden, werden Instanzmitglieder genannt.

Mitgliedsvariablen, die nicht durch Statik geändert werden, werden Instanzvariablen genannt Was ist dann der Unterschied zwischen Instanzvariablen und Klassen?

Alle Objekte dieser Klasse teilen sich die gleiche Klassenvariable, aber jedes Objekt hat seine eigene eindeutige Instanzvariable

Alle Objekte dieser Klasse können den Wert der Klassenvariablen ändern, aber jedes Objekt kann nur den Wert der Klassenvariablen ändern Wert der Klassenvariablen. Ihr eigener Instanzvariablenwert

• Instanzvariablen müssen vor der Verwendung ein Objekt erstellen, entsprechend dem Objektnamen, aber Klassenvariablen müssen keine Objekte erstellen

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)
}

• Verwenden diese Klasse:

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

  Dann die Klassenmethode und Was ist der Unterschied zwischen Instanzmethoden?

• Alle Objekte dieser Klasse teilen Klassenmethoden und Instanzmethoden

Klassenmethoden können unter Verwendung des Klassennamens Methodenname ([Parameter]) aufgerufen werden, es ist nicht erforderlich, das Objekt vor der Verwendung zu instanziieren

• Instanzmethoden verwenden den Objektnamen.Methodenname ([Parameter]) aufrufen

• statisches Schlüsselwort
  Java-Klassen stellen zwei Arten von Variablen bereit: statische Variablen, die mit dem statischen Schlüsselwort geändert wurden, und Instanzvariablen, die ohne das statische Schlüsselwort geändert wurden. Statische Variablen gehören zu Klassen und haben nur eine Kopie im Speicher. Solange die Klasse geladen ist, in der sich die statische Variable befindet, wird der statischen Variablen Speicherplatz zugewiesen, sodass sie verwendet werden kann. Es gibt zwei Möglichkeiten, auf statische Variablen zu verweisen, nämlich „class.static variable“ und „object.static variable“. , nicht statische Methoden sind Methoden von Objekten. Sie können nur verwendet werden, nachdem das Objekt erstellt wurde. Nicht statische Methoden können nicht aufgerufen werden Die Klasse, zu der sie gehören, und Mitgliedsmethoden, da das Objekt dieser Klasse möglicherweise noch nicht erstellt wurde, selbst wenn es erstellt wurde, ist es unmöglich zu bestimmen, welche Methode des Objekts aufgerufen werden soll.

• Verwendung von Statik:

Mitgliedsvariablen ändern

Mitgliedsmethoden ändern

• Statischer Codeblock

• Klassen ändern [Nur innere Klassen können geändert werden, dh statische innere Klassen]

Statisches Importpaket

• Statische Hinweise: Statisch kann nur auf statisch zugreifen, nichtstatisch kann sowohl auf nichtstatisch als auch statisch zugreifen.
• Kapselung:
  Das Konzept der Kapselung
• kapselt objektive Dinge in abstrakte Klassen, und Klassen können nur vertrauenswürdigen Klassen oder Objekten erlauben, ihre Eigenschaften und Methoden zu betreiben, und nicht vertrauenswürdige Klassen oder Objekte verbergen, sodass der Prozess als Kapselung bezeichnet wird. Kurz gesagt: Versiegeln Sie Ihre Informationen und erlauben Sie nur Personen, denen Sie vertrauen, sie zu sehen und zu verwenden

  Kapselung von Methoden: Setzen Sie für die Methodenkapselung extern zugängliche Methoden auf öffentlich und extern nicht zugängliche Methoden auf privat innerhalb der Klasse verwendet werden (d. h. die von private geänderten Methoden und Attribute können nur innerhalb dieser Klasse gefunden und verwendet werden, außerhalb dieser Klasse ist dies der Fall Die Existenz dieses Attributs kann nicht gefunden werden, wodurch auch der Effekt der Kapselung erzielt wird)

  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("小王");  将会输出小王
  }
  //通过这个就可以明白每个对象都有属于自己的实例变量（属性）

Da es gekapselt ist, muss es Möglichkeiten geben, diese Kapselung zu ändern und zu verwenden. Der Ausgabewert ist Xiaohong

• Vererbung:
• Was ist Vererbung?1: Eine neue Klasse kann von einer vorhandenen Klasse abgeleitet werden Unterklasse, und die vorhandene Klasse wird als übergeordnete Klasse bezeichnet. Die Unterklasse erbt die Attribute und Verhaltensweisen der übergeordneten Klasse.
  Vererbungssyntax:

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

Hinweis: Die Vererbung kann die privaten Eigenschaften und Methoden der übergeordneten Klasse nicht erben! ! ! Solange es privat geändert wird, wird es nicht vererbt! ! !

Über Unterklassen: Zusätzlich zu den nicht-privaten Eigenschaften und Methoden der übergeordneten Klasse können Unterklassen auch ihre eigenen Eigenschaften und Methoden erweitern.

Vererbung:

Vererbung ist eine Einzelvererbung, also eine Klasse kann nur Es gibt eine übergeordnete Klasse.

• Wenn eine Klasse eine bestimmte Klasse nicht explizit erbt, verfügt sie über eine standardmäßige übergeordnete Klasse, die java.lang.Object-Klasse.

• Erbt die nicht privaten Mitgliedsvariablen und Mitgliedsmethoden der übergeordneten Klasse. Aber bitte beachten Sie: Unterklassen können die Konstruktionsmethode der übergeordneten Klasse nicht erben. Kurz gesagt: Eine Unterklasse kann nur eine übergeordnete Klasse erben. Wenn diese Klasse keine anderen Klassen erbt, erbt sie standardmäßig die Objektklasse (kommt mit Java).

  Die Konstruktormethode der übergeordneten Klasse kann nicht geerbt werden.

  方法的重写：

  @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关键字。

Das obige ist der detaillierte Inhalt vonJava-Klassen, Kapselung, geerbte Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!