Java-Lernen: objektorientiert (1)

Viertens objektorientiert (1)

4.1 Prozessorientiert und objektorientiert

Prozessorientiert (POP) vs. Objektorientiert (OOP)

• Beide sind eine Art Denken, und objektorientiert ist relativ zu prozessorientiert. Prozessorientiert liegt der Schwerpunkt auffunktionelles VerhaltenBetrachten Sie die Funktion als kleinste EinheitWie es geht. Objektorientiert, Funktionen in Objekte kapseln, hervorhebenFunktionsobjektDenken Sie darüber nach, Klasse/Objekt als kleinste Einheit zu betrachtenwer wird es tun。
• Objektorientiert betont die Verwendung von Denkmethoden und -prinzipien, die Menschen in der täglichen Denklogik verwenden, wie z. B. Abstraktion, Klassifizierung, Vererbung, Aggregation, Polymorphismus usw.

Drei Merkmale der Objektorientierung

• Verkapselung
• Nachlass
• Polymorphismus

4.2 Grundelemente der Java-Sprache: Klassen und Objekte

Klasse (Klasse) und Objekt (Objekt) sind die Kernkonzepte der Objektorientierung.

• Eine Klasse ist eine Beschreibung einer Klasse von Dingen, eine abstrakte, konzeptionelle Definition
• Ein Objekt ist jedes tatsächlich existierende Individuum dieser Art von Dingen und wird daher auch als Instanz bezeichnet.
• Es kann verstanden werden als: Klasse = abstrakte Konzeptperson; Objekt = reale Person
• Der Schwerpunkt der objektorientierten Programmierung liegt auf
  dem Design der Klasse. Das Design der Klasse ist eigentlich das Design der Mitglieder der Klasse.

Klassenmitglieder
Gemeinsame Klassenmitglieder sind:

• Attribut: Mitgliedsvariable in der entsprechenden Klasse
• Verhalten: Das grammatikalische Format der Mitgliedsmethodenklasse in der entsprechenden Klasse
  
  

修饰符 class 类名 {
    
    
	属性声明;
	方法声明;
}
说明：修饰符public：类可以被任意访问
		类的正文要用{
    
     }括起来

举例：
public class Person{
    
    
	private int age ; //声明私有变量 age
	public void showAge(int i) {
    
     //声明方法showAge( )
		age = i;
	}
}

4.3 Erstellung und Nutzung von Objekten

Objektsyntax erstellen: Klassenname Objektname = neuer Klassenname ();
verwenden Sie „ Objektname. Objektmitglied “, um auf Objektmitglieder (einschließlich Eigenschaften und Methoden) zuzugreifen.

举例：
public class Zoo{
    
    
	public static void main(String args[]){
    
    
		//创建对象
		Animal xb=new Animal();
		xb.legs=4;//访问属性
		System.out.println(xb.legs);
		xb.eat();//访问方法
		xb.move();//访问方法
	}
}

Übung: Schreiben Sie eine Lehrerklasse und eine Schülerklasse und erstellen Sie über die Testklasse Objekte zum Testen

//Student类
package demo04;

public class Student {
    
    
    private String name;
    private int age;
    private String major;
    private String interests;

    public Student(String name, int age, String major, String interests) {
    
    
        this.name = name;
        this.age = age;
        this.major = major;
        this.interests = interests;
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public String getMajor() {
    
    
        return major;
    }

    public void setMajor(String major) {
    
    
        this.major = major;
    }

    public String getInterests() {
    
    
        return interests;
    }

    public void setInterests(String interests) {
    
    
        this.interests = interests;
    }
    public void study(){
    
    
        System.out.println("学生姓名："+name);
        System.out.println("学生年龄："+age);
        System.out.println("学科："+major);
        System.out.println("兴趣："+interests);
    }
}

//Teacher类
package demo04;

public class Teacher {
    
    
    private String name;
    private int age;
    private int teachAge;
    private String course;

    public Teacher(String name, int age, int teachAge, String course) {
    
    
        this.name = name;
        this.age = age;
        this.teachAge = teachAge;
        this.course = course;
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    public int getTeachAge() {
    
    
        return teachAge;
    }

    public void setTeachAge(int teachAge) {
    
    
        this.teachAge = teachAge;
    }

    public String getCourse() {
    
    
        return course;
    }

    public void setCourse(String course) {
    
    
        this.course = course;
    }
    public void teach(){
    
    
        System.out.println("教师姓名："+name);
        System.out.println("教师年龄："+age);
        System.out.println("教龄："+teachAge);
        System.out.println("教授课程："+course);
    }
}

//test类
package demo04;

public class test {
    
    
    public static void main(String[] args) {
    
    
        //教师类创建新对象
        Teacher teacher = new Teacher("李老师",35,10,"数学");
        teacher.teach();

        //学生类创建新对象
        Student student = new Student("田天赐",20,"Java","编程");
        student.study();
    }
}

->运行结果：
教师姓名：李老师
教师年龄：35
教龄：10
教授课程：数学
学生姓名：田天赐
学生年龄：20
学科：Java
兴趣：编程

Ergänzung: Ideen-Tastenkombination

„Alt +“-Serie

Alt + / Schneller Vervollständigungscode (muss man sich merken, wird auch am häufigsten verwendet)
Alt + Geben Sie die schnelle Vervollständigung der Eingabeaufforderung ein. Wenn der Code möglicherweise grammatikalische Probleme aufweist, fordert IDEA Sie auf, diese Tastenkombination zur schnellen und automatischen Korrektur zu verwenden (sehr leistungsstark). , die häufigste Verwendung)
Alt + Einfügen , um schnell Konstruktoren mit beliebigen Parametern und Getter/Setter-Methoden für private Eigenschaften usw. zu generieren. (am häufigsten verwendet) Alt +
Q Zeigt die Deklaration der aktuellen Methode an.
Alt + 7 Zeigt schnell die Klasse an Struktur, die die Klasse anzeigen kann, enthält alle Eigenschaften und Methoden von
Alt + links/rechts. Codeansicht schnell wechseln
Alt + hoch/runter. Schnelles Bewegen und Suchen zwischen Methoden (d. h. der Cursor bewegt sich in Methodeneinheiten).

„Strg + „Serie

Strg + W Wählen Sie den Text aus, drücken Sie kontinuierlich, um den ausgewählten Bereich (in Wörtern) zu erweitern.
Strg + Y. Löschen Sie die aktuelle Zeile.
Strg + D. Kopieren Sie die aktuelle Zeile. Kopieren Sie die aktuelle Zeile direkt in die nächste Zeile (Kopie duplizieren).
Strg + / Hinzufügen Kommentare und Kommentare abbrechen, [das erste Mal dient zum Hinzufügen von Kommentaren, das zweite Mal zum Entfernen von Kommentaren]
Strg + F zum Suchen nach Text in der aktuellen Datei (Suche suchen)
Strg + R zum Suchen und Ersetzen von Text (kann im Grunde die Funktion von vervollständigen). Strg + F), unterstützt mehrere Zeilen Suchen, oder nur im Code suchen oder nur in den Kommentaren suchen oder reguläre Ausdrücke zum Suchen verwenden (Ersetzen Ersetzen) Strg + O, um die Methode
in der Basisklasse oder Schnittstelle schnell neu zu schreiben (Überschreiben). Umschreiben)
Strg + H zum Anzeigen des Klassenstrukturdiagramms (Klassenvererbungshierarchie) (Hierarchieebene)
Strg + G Navigieren Sie schnell zur angegebenen Zeile und angegebenen Spalte.
Strg + [Navigieren Sie schnell zum Anfang des Codeblocks.
Strg +] Navigieren Sie schnell zu Das Ende des Codeblocks
Strg + N Suchen Sie schnell nach der Klasse und öffnen Sie sie.
Strg + B Suchen Sie schnell den Quellcode, setzen Sie den Cursor auf die Methode und geben Sie ein. Sie können schnell zum Quellcode der Methode gehen.
Strg + U Gehen Sie schnell zu übergeordnete Klasse der aktuellen Klasse

Kombinationsschlüsselserie

Strg + Alt + T Umschließen Sie den ausgewählten Code mit if, while, try/catch und anderen Codeblöcken (leistungsstark).
Strg + Alt + L Formatieren Sie den Code schnell
. Strg + Alt + I Automatisch einrücken
Strg + Alt + O , um Importklassen zu optimieren und Pakete

4.4 Eines der Mitglieder der Klasse: Attribut (Feld)

Grammatikformat : Modifikatordatentyp-Attributname = Initialisierungswert;

• Hinweis 1: Modifikatoren
  Häufig verwendete Berechtigungsmodifikatoren sind: private, default, protected, public
  Andere Modifikatoren: static, final (noch nicht berücksichtigt)
• Hinweis 2: Datentyp
  Jeder grundlegende Datentyp (z. B. int, Boolean) oder jeder Referenzdatentyp.
• Hinweis 3: Der Attributname
  ist ein Bezeichner und muss lediglich den Benennungsregeln und -spezifikationen entsprechen.

举例：
public class Person{
    
    
	private int age; //声明private变量 age
	public String name = “Lila”; //声明public变量 name
}

Klassifizierung von Variablen: Mitgliedsvariablen und lokale Variablen

• Außerhalb des Methodenkörpers werden die im Klassenkörper deklarierten Variablen als Mitgliedsvariablen bezeichnet.

• Im Methodenkörper deklarierte Variablen werden als lokale Variablen bezeichnet.
  
  == Hinweis ==: Die Ähnlichkeiten und Unterschiede zwischen den beiden hinsichtlich der Initialisierungswerte:

    同：都有生命周期
    异：局部变量除形参外，均需显式初始化。
  

Der Unterschied zwischen Mitgliedsvariablen (Attributen) und lokalen Variablen:

4.5 Das zweite Mitglied der Klasse: Methode (Methode)

• Eine Methode ist eine Abstraktion der Verhaltensmerkmale einer Klasse oder eines Objekts und wird verwendet, um einen bestimmten Funktionsvorgang abzuschließen. In einigen Sprachen auch als Funktion oder Prozedur bekannt.
• Der Zweck der Kapselung von Funktionen als Methoden besteht darin, die Wiederverwendung von Code zu erreichen und den Code zu vereinfachen
• Methoden in Java können nicht unabhängig voneinander existieren, alle Methoden müssen in der Klasse definiert werden.

Format der Methodendeklaration:

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值;
｝
其中：
修饰符：public,缺省,private, protected等
返回值类型：
>没有返回值：void。
>有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。

举例：
public class Person{
    
    
	private int age;
	public int getAge() {
    
     //声明方法getAge()
		return age; 
}
	public void setAge(int i) {
    
     //声明方法setAge
		age = i; //将参数i的值赋给类的成员变量age
	}
}

Klassifizierung der Methoden: danach, ob formale Parameter und Rückgabewerte vorhanden sind

Notiz:
(1) Sie muss zuerst deklariert und dann verwendet werden, und die Methode muss innerhalb der Klasse definiert werden.
(2) Sie wird ausgeführt, sobald sie aufgerufen wird, und sie wird nicht ausgeführt, wenn sie nicht aufgerufen wird.
(3) Methoden oder Attribute in der Klasse können in der Methode aufgerufen werden, und Methoden können nicht innerhalb der Methode definiert werden.

Richtiges Beispiel:

类{
    
    
    方法1(){
    
    
        
    }
    方法2(){
    
    
        
    }
}

Fehlerbeispiel:

类{
    
    
    方法1(){
    
    
        方法2(){
    
      //位置错误
        
   		}
    }
}

4.5.1 Methodenüberladung

Das Konzept der Überladung:
In derselben Klasse ist mehr als eine Methode mit demselben Namen zulässig, sofern ihre Anzahl an Parametern oder Parametertypen unterschiedlich ist.
Merkmale der Überladung:
Es hat nichts mit dem Rückgabewerttyp zu tun. Sehen Sie sich nur die Parameterliste an. Die Parameterliste muss unterschiedlich sein. (Parameternummer oder Parametertyp). Beim Aufruf wird anhand der Methodenparameterliste unterschieden.
Überladener Methodenaufruf : Die JVM ruft die passende Methode über die Parameterliste der Methode auf.

Suchen Sie zunächst die Nummer und den Typ, die am besten übereinstimmen,
und suchen Sie dann die Nummer und den Typ, die kompatibel sind. Wenn mehrere Methoden gleichzeitig kompatibel sind, wird ein Fehler gemeldet

Beispiel für Überladung :

//返回两个整数的和
int add(int x,int y){
    
    return x+y;}
//返回三个整数的和
int add(int x,int y,int z){
    
    return x+y+z;}
//返回两个小数的和
double add(double x,double y){
    
    return x+y;}

举例：
public class PrintStream {
    
    
	public static void print(int i) {
    
    ……}
	public static void print(float f) {
    
    ……}
	public static void print(String s) {
    
    ……}
	public static void main(String[] args) {
    
    
		print(3);
		print(1.2f);
		print("hello!");
	}
}

4.5.2 Wertübergabemechanismus von Methodenparametern

Eine Methode muss von ihrer Klasse oder ihrem Objekt aufgerufen werden, um sinnvoll zu sein. Wenn die Methode Parameter hat:

• Formaler Parameter: Der Parameter, wenn die Methode deklariert wird
• Aktualparameter: Der Parameterwert, der beim Aufruf der Methode tatsächlich an den Formalparameter übergeben wird

Wie übergebe ich den tatsächlichen Parameterwert von Java an die Methode?

In Java gibt es nur eine Möglichkeit, Parameter an Methoden zu übergeben: die Übergabe als Wert. Das heißt, eine Kopie (Replikation) des tatsächlichen Parameterwerts wird an die Methode übergeben, während der Parameter selbst davon nicht betroffen ist.
Der formale Parameter ist ein Basisdatentyp: der tatsächliche Parameter der Basisdatentypvariable.Datenwert„An formalen Parameter übergeben
. Der formale Parameter ist ein Referenzdatentyp: der tatsächliche Parameter ist eine Referenzdatentypvariable.“Adresswert"an den Parameter übergeben

练习：
1.定义一个int型的数组：int[] arr = new int[]{
    
    12,3,3,34,56,77,432};
让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组
//正确写法1
for(int i = arr.length – 1;i >= 0;i--){
    
    
	arr[i] = arr[i] / arr[0];
}
//正确写法2
int temp = arr[0];
for(int i= 0；i < arr.length;i++){
    
    
	arr[i] = arr[i] / temp;
}

2.
int[] arr = new int[10];
System.out.println(arr);//地址值? [I@d716361
char[] arr1 = new char[10];
System.out.println(arr1); //地址值?           10个空值

3.
（1）定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积
（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time)在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。
（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。

//Circle类
package demo05;

public class Circle {
    
    
    private double radius;

    public Circle(double radius) {
    
    
        this.radius = radius;
    }

    public double getRadius() {
    
    
        return radius;
    }

    public void setRadius(double radius) {
    
    
        this.radius = radius;
    }

    public double findArea(){
    
    
        return  radius*radius*Math.PI;

    }
}
//PassObject类
package demo05;

public class PassObject {
    
    
    public void printAreas(Circle c,int time){
    
    
        System.out.println("Radius\t\tArea");
        for (int i = 1;i <= time;i++) {
    
    
            c.setRadius(i);
            System.out.println(c.getRadius() + "\t\t" + c.findArea());
        }
    }
}

//Main类
package demo05;

public class Main {
    
    
    public static void main(String[] args) {
    
    
        PassObject passObject = new PassObject();
        Circle circle = new Circle(0);
        passObject.printAreas(circle, 5);
        System.out.println("nuw radius is: " + circle.getRadius());
    }
}

>运行结果
Radius		Area
1.0		3.141592653589793
2.0		12.566370614359172
3.0		28.274333882308138
4.0		50.26548245743669
5.0		78.53981633974483
nuw radius is: 5.0

4.5.3 Rekursive Methoden

**Rekursiver Methodenaufruf:** Das Phänomen, dass sich eine Methode selbst aufruft, wird Rekursion genannt.

Klassifizierung der Rekursion: direkte Rekursion, indirekte Rekursion.

• Direkte Rekursion: Die Methode selbst ruft sich selbst auf.

  public void methodA(){
        
        
  	methodA();
  }
  

• Indirekte Rekursion: Es versteht sich, dass die A()-Methode die B()-Methode aufruft, die B()-Methode die C()-Methode aufruft und die C()-Methode die A()-Methode aufruft.

```java
  ```java
  public static void A(){
    
    
  	B();
  }
  
  public static void B(){
    
    
  	C();
  }
  
  public static void C(){
    
    
  	A();
  }

Beschreibung :

• Eine rekursive Methode enthält eine 隐式的循环.
• Eine rekursive Methode führt 重复执行einen bestimmten Codeabschnitt aus, diese wiederholte Ausführung erfordert jedoch keine Schleifensteuerung.
• Die Rekursion muss zur Rekursion gehen 已知方向, sonst wird diese Rekursion zu einer unendlichen Rekursion, die nicht gestoppt werden kann, ähnlich wie bei 死循环. irgendwann ist es passiert 栈内存溢出.

Beispiel 1: Berechnen Sie die Summe von 1 ~ n.

Beispiel 2:
Berechnen Sie den n-ten Wert der Fibonacci-Folge (Fibonacci). Die Fibonacci-Folge erfüllt die folgenden Regeln:

1,1,2,3,5,8,13,21,34,55,....

Das heißt, ab der dritten Zahl ist eine Zahl gleich der Summe der ersten beiden Zahlen. Angenommen, f(n) stellt den n-ten Wert der Fibonacci-Folge dar, dann erfüllt f(n) Folgendes: f(n)
= f(n-2) + f(n-1);

	//使用递归的写法
    int f(int n) {
    
    //计算斐波那契数列第n个值是多少
        if (n < 1) {
    
    //负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if (n == 1 || n == 2) {
    
    
            return 1;
        }
        return f(n - 2) + f(n - 1);
    }

    //不用递归
    int fValue(int n) {
    
    //计算斐波那契数列第n个值是多少
        if (n < 1) {
    
    //负数是返回特殊值1，表示不计算负数情况
            return 1;
        }
        if (n == 1 || n == 2) {
    
    
            return 1;
        }
        //从第三个数开始，  等于 前两个整数相加
        int beforeBefore = 1; //相当于n=1时的值
        int before = 1;//相当于n=2时的值
        int current = beforeBefore + before; //相当于n=3的值
        //再完后
        for (int i = 4; i <= n; i++) {
    
    
            beforeBefore = before;
            before = current;
            current = beforeBefore + before;
            /*
            假设i=4
                beforeBefore = before; //相当于n=2时的值
                before = current; //相当于n=3的值
                current = beforeBefore + before; //相当于n = 4的值
            假设i=5
                beforeBefore = before; //相当于n=3的值
                before = current; //相当于n = 4的值
                current = beforeBefore + before; //相当于n = 5的值
                ....
             */
        }
        return current;
    }

4.6 Arrays von Objekten

Die Elemente eines Arrays können entweder primitive Datentypen oder Referenzdatentypen sein. Wenn die Elemente Klassen in einem Referenztyp sind, nennen wir ihn ein Array von Objekten.
Beispiel:

1.定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：
1) 生成随机数：Math.random()，返回值类型double; 
2) 四舍五入取整：Math.round(double d)，返回值类型long。

//Student类
public class Student {
    
    
	int number;//学号
	int state;//年级
	int score;//成绩		
	public void info(){
    
    
		System.out.println("number : " + number 
				+ ",state : " + state + ",score : " + score);
	}	
}
//StudentTest类
public class StudentTest {
    
    
    public static void main(String[] args) {
    
    
        // 数组的创建
        Student[] students = new Student[20];
        // 通过循环结构给数组的属性赋值
        for (int i = 0; i < students.length; i++) {
    
    
            // 数组元素的赋值
            students[i] = new Student();
            // 数组元素是一个对象，给对象的各个属性赋值
            students[i].number = (i + 1);
            students[i].state = (int) (Math.random() * 6 + 1);// [1,6]
            students[i].score = (int) (Math.random() * 101);// [0,100]
        }

        // 问题一：打印出3年级(state值为3）的学生信息。
        System.out.println("问题一：打印出3年级(state值为3）的学生信息。");
        for (int i = 0; i < students.length; i++) {
    
    
            if (students[i].state == 3) {
    
    
//				System.out.println(
//						"number:" + students[i].number + ",state:" + students[i].state + ",score:" + students[i].score);
                students[i].info();

            }

        }
        System.out.println("******************************");
        // 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
        // 排序前
        System.out.println("问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息");
        System.out.println("排序前");
        for (int i = 0; i < students.length; i++) {
    
    
//			System.out.println(
//					"number:" + students[i].number + ",state:" +
//							students[i].state + ",score:" + students[i].score);

            students[i].info();
        }

        System.out.println();
        // 排序：
        for (int i = 0; i < students.length - 1; i++) {
    
    
            for (int j = 0; j < students.length - 1 - i; j++) {
    
    
                if (students[j].score > students[j + 1].score) {
    
    
                    Student temp = students[j];
                    students[j] = students[j + 1];
                    students[j + 1] = temp;
                }
            }
        }

        // 排序后：
        System.out.println("排序后");
        for (int i = 0; i < students.length; i++) {
    
    
//			System.out.println(
//					"number:" + students[i].number + ",state:" +
//							students[i].state + ",score:" + students[i].score);

            students[i].info();
        }

    }

}

>运行结果：
问题一：打印出3年级(state值为3）的学生信息。
number : 1,state : 3,score : 98
number : 2,state : 3,score : 60
number : 5,state : 3,score : 71
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 9,state : 3,score : 24
number : 14,state : 3,score : 0
number : 16,state : 3,score : 68
number : 18,state : 3,score : 29
number : 20,state : 3,score : 61
******************************
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
排序前
number : 1,state : 3,score : 98
number : 2,state : 3,score : 60
number : 3,state : 1,score : 22
number : 4,state : 6,score : 78
number : 5,state : 3,score : 71
number : 6,state : 5,score : 72
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 9,state : 3,score : 24
number : 10,state : 1,score : 73
number : 11,state : 2,score : 0
number : 12,state : 2,score : 99
number : 13,state : 6,score : 65
number : 14,state : 3,score : 0
number : 15,state : 5,score : 61
number : 16,state : 3,score : 68
number : 17,state : 2,score : 41
number : 18,state : 3,score : 29
number : 19,state : 2,score : 14
number : 20,state : 3,score : 61

排序后
number : 11,state : 2,score : 0
number : 14,state : 3,score : 0
number : 19,state : 2,score : 14
number : 3,state : 1,score : 22
number : 9,state : 3,score : 24
number : 18,state : 3,score : 29
number : 17,state : 2,score : 41
number : 2,state : 3,score : 60
number : 15,state : 5,score : 61
number : 20,state : 3,score : 61
number : 13,state : 6,score : 65
number : 16,state : 3,score : 68
number : 5,state : 3,score : 71
number : 6,state : 5,score : 72
number : 7,state : 3,score : 72
number : 8,state : 3,score : 72
number : 10,state : 1,score : 73
number : 4,state : 6,score : 78
number : 1,state : 3,score : 98
number : 12,state : 2,score : 99

4.7 Schlüsselwörter: Paket, Import

4.7.1 Paket (Paket)

Ein Paket, auch Paket genannt, wird verwendet, um das Paket anzugeben, in dem sich die in der Datei definierten Klassen, Schnittstellen und anderen Strukturen befinden.

package 顶层包名.子包名 ;

Beispiel: pack1\pack2\PackageTest.java

package pack1.pack2;    //指定类PackageTest属于包pack1.pack2

public class PackageTest{
    
    
	public void display(){
    
    
		System.out.println("in  method display()");
	}
}

veranschaulichen:

• Eine Quelldatei kann nur eine Paketanweisung enthalten, die ein Paket deklariert
• Die Paketanweisung erscheint als erste Anweisung in einer Java-Quelldatei. Wenn diese Anweisung standardmäßig verwendet wird, wird ein unbenanntes Paket angegeben.
• Der Paketname, der zum Bezeichner gehört, entspricht den Regeln und Spezifikationen für die Benennung des Bezeichners (alles in Kleinbuchstaben), sieht den Namen
  • Pakete verwenden normalerweise die Umkehrung des Domänennamens des Unternehmens. Verwenden Sie nicht „ java.xxpackage“ , wenn Sie den Paketnamen verwenden
• Das Paket entspricht dem Verzeichnis des Dateisystems, und „.“ wird in der Paketanweisung verwendet, um die Ebene des Pakets (Verzeichnis) anzugeben, und bedeutet jedes Mal eine Ebene des Dateiverzeichnisses.
• Unter demselben Paket können mehrere Strukturen (Klassen, Schnittstellen) deklariert werden, Strukturen (Klassen, Schnittstellen) mit demselben Namen können jedoch nicht definiert werden. Strukturen (Klassen, Schnittstellen) mit demselben Namen können unter verschiedenen Paketen definiert werden

Die Rolle des Pakets

• Pakete können Klassen und Unterpakete enthalten, die 项目层次zur einfachen Verwaltung unterteilt sind
• Hilfesystem 管理大型软件: Teilen Sie Klassen mit ähnlichen Funktionen in dasselbe Paket auf. Beispiel: MVC-Entwurfsmuster
• 类命名冲突Problem gelöst
• Kontrolle访问权限

MVC-Entwurfsmuster

MVC ist ein Softwarekomponentenmuster, dessen Zweck darin besteht, die Kopplung von Codegeschäften bei der Programmentwicklung zu reduzieren.

Das MVC-Entwurfsmuster unterteilt das gesamte Programm in drei Ebenen: 视图模型(Viewer)层, 控制器(Controller)层und 数据模型(Model)层. Dieses Entwurfsmuster trennt Programmeingabe und -ausgabe, Datenverarbeitung und Datenanzeige, macht die Programmstruktur flexibel und klar und beschreibt auch die Kommunikationsmethode zwischen verschiedenen Objekten des Programms, wodurch die Kopplung des Programms verringert wird.

视图层viewer：显示数据,为用户提供使用界面，与用户直接进行交互。
 >相关工具类   view.utils
 >自定义view  view.ui

控制层controller：解析用户请求，处理业务逻辑，给予用户响应
 >应用界面相关    controller.activity
 >存放fragment   controller.fragment
 >显示列表的适配器 controller.adapter
 >服务相关的        controller.service
 >抽取的基类        controller.base
    
模型层model：主要承载数据、处理数据
 >数据对象封装 model.bean/domain
 >数据库操作类 model.dao
 >数据库      model.db

Einführung des Hauptpakets im JDK

java.lang---- Enthält einige Kernklassen der Java-Sprache, wie String, Math, Integer, System und Thread, die allgemeine Funktionen bereitstellen.
java.net---- Enthält Klassen und Schnittstellen, die netzwerkbezogene Vorgänge ausführen.
java.io---- Enthält Klassen, die verschiedene Ein-/Ausgabefunktionen bereitstellen können.
java.util---- Enthält einige Dienstprogrammklassen, z. B. das Definieren von Systemeigenschaften, Sammlungsrahmenklassen von Schnittstellen und die Verwendung von Funktionen im Zusammenhang mit Datum und Kalender.
java.text---- Enthält einige Klassen im Zusammenhang mit der Java-Formatierung
java.sql---- Enthält verwandte Klassen/Schnittstellen für die JDBC-Datenbankprogrammierung in Java
java.awt---- Enthält mehrere Klassen, die die abstrakten Fenster-Toolkits bilden. Diese Klassen werden zum Erstellen und Verwalten der Anwendungen verwendet grafische Benutzeroberfläche (GUI).

4.7.2 Import (Import)

Um in anderen Paketen definierte Java-Klassen zu verwenden, müssen Sie die Importanweisung verwenden, um die für das angegebene Paket erforderlichen Klassen explizit einzuführen. Entspricht import语句告诉编译器到哪里去寻找这个类.

grammatikalisches Format

import 包名.类名;

Anwendungsbeispiele

import pack1.pack2.Test;   //import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

public class PackTest{
    
    
	public static void main(String args[]){
    
    
		Test t = new Test();          //Test类在pack1.pack2包中定义
		t.display();
	}
}

Vorsichtsmaßnahmen

• Die Importanweisung, deklariert zwischen der Paketdeklaration und der Klassendeklaration.

• Wenn Sie mehrere Klassen oder Schnittstellen importieren müssen, können Sie explizit mehrere Importanweisungen parallel angeben

• a.*Wenn Sie die Importstruktur verwenden , bedeutet dies, dass Sie alle Strukturen unter einem Paket importieren können. Beispiel: Sie können java.util.* verwenden, um alle Klassen oder Schnittstellen unter dem util-Paket gleichzeitig zu importieren.

• Wenn sich die importierte Klasse oder Schnittstelle im Paket java.lang oder im aktuellen Paket befindet, kann diese Importanweisung weggelassen werden.

• Wenn die Klassen unter dem Paket java.a importiert wurden, müssen Sie sie trotzdem importieren, wenn Sie die Klassen unter den Unterpaketen des Pakets a verwenden müssen.

• Wenn Sie in Ihrem Code Klassen mit demselben Namen in verschiedenen Paketen verwenden, müssen Sie den vollständigen Klassennamen der Klasse verwenden, um anzugeben, welche Klasse aufgerufen wird.

• (Verstehen) import staticder Verwendung von Kombinationen: Rufen Sie die statische Eigenschaft oder Methode unter der angegebenen Klasse oder Schnittstelle auf

4.8 Merkmal 1: Kapselung

Die sogenannte Kapselung besteht darin, objektive Dinge in Klassen abstrakter Konzepte zu kapseln. Klassen können ihre Daten und Methoden nur für vertrauenswürdige Klassen oder Objekte öffnen und Informationen vor unnötigen Klassen oder Objekten verbergen.

Um es mit Laienbegriffen auszudrücken: Verbergen Sie, was verborgen werden sollte, und enthüllen Sie, was enthüllt werden sollte. Dies ist die Designidee der Kapselung.

Java implementiert die Datenkapselung

• Um eine Kapselung zu erreichen, muss der Sichtbarkeitsbereich einer Klasse oder eines Mitglieds gesteuert werden. Dies muss mithilfe von Zugriffskontrollmodifikatoren, auch Berechtigungsmodifikatoren genannt, gesteuert werden.
• Berechtigungsmodifikatoren: public, protected, 缺省, private. Der spezifische Zugriffsbereich ist wie folgt:

Modifikator	Innerhalb dieser Klasse	in diesem Paket	Unterklassen anderer Pakete	anderes Paket, keine Unterklasse
Privatgelände	√	×	×	×
Standard	√	√	×	×
geschützt	√	√	√	×
öffentlich	√	√	√	√

• Speziell geänderter Aufbau:
  • Externe Klasse: öffentlich, Standard
  • Mitgliedsvariablen, Mitgliedsmethoden, Konstruktoren, innere Mitgliedsklassen: öffentlich, geschützt, Standard, privat

4.8.1 Ausführungsform der Kapselung

Übersicht über die Privatisierung von Mitgliedsvariablen/Eigenschaften
: Privatisieren Sie die Mitgliedsvariablen der Klasse, stellen Sie öffentliche Get- und Set-Methoden bereit und legen Sie die Funktion zum Abrufen und Ändern von Eigenschaften offen.

Umsetzungsschritte:

①private Zum Ändern von Mitgliedsvariablen verwenden

private 数据类型 变量名 ；

Code wie folgt anzeigen:

public class Person {
    
    
    private String name;
  	private int age;
    private boolean marry;
}

②Stellen Sie Methoden getXxx/ setXxxMethoden für den Zugriff auf Mitgliedsvariablen bereit. Der Code lautet wie folgt:

public class Person {
    
    
    private String name;
  	private int age;
    private boolean marry;

	public void setName(String n) {
    
    
		name = n;
    }

    public String getName() {
    
    
        return name;
	}

    public void setAge(int a) {
    
    
        age = a;
    }

    public int getAge() {
    
    
        return age;
    }
    
    public void setMarry(boolean m){
    
    
        marry = m;
    }
    
    public boolean isMarry(){
    
    
        return marry;
    }
}

③Test :

public class PersonTest {
    
    
    public static void main(String[] args) {
    
    
        Person p = new Person();

        //实例变量私有化，跨类是无法直接使用的
		/* p.name = "张三";
        p.age = 23;
        p.marry = true;*/

        p.setName("张三");
        System.out.println("p.name = " + p.getName());

        p.setAge(23);
        System.out.println("p.age = " + p.getAge());

        p.setMarry(true);
        System.out.println("p.marry = " + p.isMarry());
    }
}

Die Vorteile der Kapselung von Mitgliedsvariablen:

• Lassen Sie den Benutzer nur die vordefinierte Methode verwenden 访问数据, sodass der Methode Steuerlogik hinzugefügt werden kann, um den unangemessenen Zugriff auf Mitgliedsvariablen zu begrenzen. Auch eine Datenprüfung kann durchgeführt werden, um die Integrität der Objektinformationen sicherzustellen.
• 便于修改, Verbessern Sie die Wartbarkeit des Codes. Die Hauptsache ist, dass der verborgene Teil intern geändert wurde. Wenn die externe Zugriffsmethode gleich bleibt, ist die Änderung äußerlich überhaupt nicht spürbar. Beispiel: Java8->Java9, String wird für die interne Implementierung von char[] in byte[] konvertiert, aber die externe Methode bleibt unverändert und unsere Benutzer können ihre interne Änderung überhaupt nicht spüren.

4.8.2 Privatisierungsmethoden

public class ArrayUtil {
    
    
	/**
	 * 
	 * @Description 求int型数组的最大值
	 * @param arr
	 * @return
	 */
	public int max(int[] arr) {
    
    
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
    
    
			if(maxValue < arr[i]){
    
    
				maxValue = arr[i];
			}
		}
		return maxValue;
	}

	/**
	 * 
	 * @Description 求int型数组的最小值
	 * @param arr
	 * @return
	 */
	public int min(int[] arr){
    
    
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
    
    
			if(minValue > arr[i]){
    
    
				minValue = arr[i];
			}
		}
		return minValue;
	}

	/**
	 * 
	 * @Description 求int型数组的总和
	 * @param arr
	 * @return
	 */
	public int sum(int[] arr) {
    
    
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
    
    
			sum += arr[i];
		}
		return sum;
	}

	/**
	 * 
	 * @Description 求int型数组的元素的平均值
	 * @param arr
	 * @return
	 */
	public int avg(int[] arr) {
    
    
		int sumValue = sum(arr);
		return sumValue / arr.length;
	}

	// 创建一系列重载的上述方法
	// public double max(double[] arr){}
	// public float max(float[] arr){}
	// public byte max(byte[] arr){}

	/**
	 * 
	 * @Description 遍历数组
	 * @param arr
	 */
	public void print(int[] arr) {
    
    
		for(int i = 0;i < arr.length;i++){
    
    
			System.out.print(arr[i] + "  ");
		}
		System.out.println();
	}

	/**
	 * 
	 * @Description 复制数组arr
	 * @param arr
	 * @return
	 */
	public int[] copy(int[] arr) {
    
    
		int[] arr1 = new int[arr.length];
		for(int i = 0;i < arr.length;i++){
    
    
			arr1[i] = arr[i];
		}
		return arr1;
	}

	/**
	 * 
	 * @Description 反转数组
	 * @param arr
	 */
	public void reverse(int[] arr) {
    
    
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
    
    
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}

	/**
	 * 
	 * @Description 数组的排序
	 * @param arr
	 * @param desc 指明排序的方式。 ascend:升序    descend:降序
	 */
	public void sort(int[] arr,String desc) {
    
    
		
		if("ascend".equals(desc)){
    
    //if(desc.equals("ascend")){
    
    
			for (int i = 0; i < arr.length - 1; i++) {
    
    
				for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
					if (arr[j] > arr[j + 1]) {
    
    
//						int temp = arr[j];
//						arr[j] = arr[j + 1];
//						arr[j + 1] = temp;
						swap(arr,j,j+1);
					}
				}
			}
		}else if ("descend".equals(desc)){
    
    
			for (int i = 0; i < arr.length - 1; i++) {
    
    
				for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
					if (arr[j] < arr[j + 1]) {
    
    
//						int temp = arr[j];
//						arr[j] = arr[j + 1];
//						arr[j + 1] = temp;
						swap(arr,j,j+1);
					}
				}
			}
		}else{
    
    
			System.out.println("您输入的排序方式有误！");
		}
	}
	
	private void swap(int[] arr,int i,int j){
    
    
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	/**
	 * 
	 * @Description 查找指定的value值在arr数组中出现的位置
	 * @param arr
	 * @param value
	 * @return 返回value值出现的位置 或 -1：未找到
	 */
	public int getValue(int[] arr, int value) {
    
    
		//方法：线性查找
		for(int i = 0;i < arr.length;i++){
    
    
			if(value == arr[i]){
    
    
				return i;
			}
		}
		
		return - 1;
	}
}

Notiz:

In der Entwicklung werden allgemeine Mitgliedsinstanzvariablen verwendet, um private Änderungen vorzunehmen und dann entsprechende öffentliche Zugriffsberechtigungen für Get/Set-Methoden bereitzustellen.

Für letzte Instanzvariablen wird die Methode set() nicht bereitgestellt. (Apropos letztes Schlüsselwort später)

Für statische endgültige Mitgliedsvariablen ist es üblich, öffentliche Änderungen zu verwenden.

4.9 Das dritte Mitglied der Klasse: der Konstruktor (Konstruktor)

Die Rolle des Konstrukteurs

Erstellen Sie ein neues Objekt und weisen Sie Instanzvariablen Werte zu, wenn neue Objekte erstellt werden.

Beispiel: Person p = new Person(“Peter”,15);

Erläuterung: So wie wir festlegen, dass jede „Person“ sofort nach der Geburt ein Bad nehmen muss, können wir den Programmcode zum Abschließen des „Bades“ im Konstruktor der „Person“ hinzufügen, sodass jede „Person“ dies tun kann Das Programm schließt das „Bad“ automatisch ab, sobald es geboren ist. „Baden nehmen“, anstatt jedem Einzelnen als Neugeborenes einzeln zu sagen, dass er einzeln „ein Bad nehmen“ soll.

Die Syntax des Konstruktors

[修饰符] class 类名{
    
    
    [修饰符] 构造器名(){
    
    
    	// 实例初始化代码
    }
    [修饰符] 构造器名(参数列表){
    
    
        // 实例初始化代码
    }
}

veranschaulichen:

1. Der Konstruktorname muss mit dem Klassennamen übereinstimmen, in dem er sich befindet.
2. Es hat keinen Rückgabewert, daher ist weder ein Rückgabetyp noch void erforderlich.
3. Der Modifikator des Konstruktors kann nur ein Berechtigungsmodifikator sein und kann von keinem anderen geändert werden. Es kann beispielsweise nicht durch statische, endgültige, synchronisierte, abstrakte oder native Änderungen geändert werden und kann keinen Rückgabewert der Return-Anweisung haben.

Code wie folgt anzeigen:

public class Student {
    
    
    private String name;
    private int age;

    // 无参构造
    public Student() {
    
    }

    // 有参构造
    public Student(String n,int a) {
    
    
        name = n;
        age = a;
    }

    public String getName() {
    
    
        return name;
    }
    public void setName(String n) {
    
    
        name = n;
    }
    public int getAge() {
    
    
        return age;
    }
    public void setAge(int a) {
    
    
        age = a;
    }

    public String getInfo(){
    
    
        return "姓名：" + name +"，年龄：" + age;
    }
}

public class TestStudent {
    
    
    public static void main(String[] args) {
    
    
        //调用无参构造创建学生对象
        Student s1 = new Student();

        //调用有参构造创建学生对象
        Student s2 = new Student("张三",23);

        System.out.println(s1.getInfo());
        System.out.println(s2.getInfo());
    }
}

Gebrauchsanweisung

1. Wenn wir den Konstruktor in der Klasse nicht explizit deklarieren, stellt das System standardmäßig einen Konstruktor ohne Parameter bereit und der Modifikator des Konstruktors ist standardmäßig derselbe wie der Modifikator der Klasse.

2. Wenn wir den Klassenkonstruktor explizit definieren, stellt das System keinen Standardkonstruktor ohne Argumente mehr bereit.

3. In einer Klasse gibt es mindestens einen Konstruktor.

4. Konstruktoren können überladen sein.

üben:

(1)定义Student类,有4个属性：
  String name; 
  int age; 
  String school; 
  String major;

(2)定义Student类的3个构造器:

- 第一个构造器Student(String n, int a)设置类的name和age属性；
- 第二个构造器Student(String n, int a, String s)设置类的name, age 和school属性；
- 第三个构造器Student(String n, int a, String s, String m)设置类的name, age ,school和major属性；

(3)在main方法中分别调用不同的构造器创建的对象，并输出其属性值。


public class Student {
    
    
    String name;
    int age;
    String school;
    String major;

    public Student(String n, int a) {
    
    
        name = n;
        age = a;
    }

    public Student(String n, int a, String s) {
    
    
        name = n;
        age = a;
        school = s;
    }

    public Student(String n, int a, String s, String m) {
    
    
        name = n;
        age = a;
        school = s;
        major = m;
    }

    public static void main(String[] args) {
    
    
        Student s1 = new Student("田大赐", 20);
        Student s2 = new Student("田二赐", 21, "北大");
        Student s3 = new Student("田三赐", 22, "清华", "Java");

        System.out.println(s1.name + " " + s1.age + " " + s1.school + " " + s1.major);
        System.out.println(s2.name + " " + s2.age + " " + s2.school + " " + s2.major);
        System.out.println(s3.name + " " + s3.age + " " + s3.school + " " + s3.major);
    }
}

>运行结果
田大赐 20 null null
田二赐 21 北大 null
田三赐 22 清华 Java