Woche 04

0. Objektorientiert: OO:

0. OOA (Objektorientierte Analyse) OOD (Objektorientiertes Design) OOP (Objektorientierte Programmierung)

1. Ja Softwareentwicklungsmethoden

2. Erweiterte Bereiche: Datenbanksysteme, interaktive Schnittstellen, Anwendungsplattformen, verteilte Systeme, künstliche Intelligenz und andere Bereiche

3. Es ist ein Verständnis und Verständnis der realen Welt. Die abstrakte Methode ist das Produkt der Entwicklung der Computerprogrammiertechnologie bis zu einem bestimmten Stadium

1. Die Grundkonzepte von Klassen und Objekten

1. Klasse: Eine Klasse ist ein Paar von Objekten mit ähnliche Eigenschaften Eine Abstraktion einer Klasse von Dingen. Eine Klasse kapselt die Attribute (Merkmale) und Methoden (Verhalten) von Dingen ähnlicher Natur (d. h. Mitglieder einer Klasse)

2. Objekt: Ein Objekt ist ein spezifisches Individuum in einer Klasse von Dingen

3. Klasse – Objektbeziehung Referenzpopulation – Individuum

4. Klassenzusammensetzung: Null oder mehr Mitgliedsvariablen Null oder mehr Methoden Null oder Mehrere Konstruktoren

Mitgliedsvariablen: Definieren Sie die in der Klasse oder Instanzen der Klasse enthaltenen Zustandsdaten.

Methoden: Werden verwendet, um die Verhaltensmerkmale oder die funktionale Implementierung der Klasse oder Instanzen der Klasse zu definieren

Konstruktor: Wird zum Erstellen von Instanzen dieser Klasse verwendet (der Konstruktor wird später erläutert)

5. Generierung und Verwendung von Objekten:

Nach der Erstellung kann es verwendet werden . Java-Objekte haben im Allgemeinen die folgenden Funktionen: Zugriff auf Instanzvariablen von Objekten und Aufrufen von Methoden von Objekten. Der Konstruktor einer bestimmten Klasse wird über das Schlüsselwort new aufgerufen Erstellen Sie eine Instanz (Objekt) dieser Klasse

Objektname. Instanzvariable | ; Deklaration und Erstellung von Objekten; Programmeintragsklasse (Hauptklasse), Klasse mit Hauptmethode

7. Eine Person (Zhang San) ging auf der Straße und traf einen Hund (Rhubarb). ), der Hund (Rhabarber) hat den Mann (Zhang San) gebissen, der Mann (Zhang San) hat den Hund (Rhabarber) geschlagen und der Hund (Rhabarber) ist weggelaufen~!

2. Übung: Fahrzeugklasse, Beschreibung der Eigenschaften des Fahrzeugs (Marke, Hubraum, Farbe, Preis)

und Methoden (Start, Beschleunigung, normaler Fahrbetrieb, Begegnung mit einem Treffer (Person))

Schreiben Sie eine People-Klasse mit Attributen (Name, Geschlecht, Alter),

package Chapter7_2;
//Dog类的申明
public class Dog {
          String name;
          public void beatPersion(People p){
                   System.out.println(name+"咬了"+p.name);
          }
          public void dogRun(){
                   System.out.println(name+"跑了......");
          }
}
 
 
 
package Chapter7_2;
//People类的申明
public class People {
          String name;
          public void walk(){
                   System.out.println(name+"街上散步");
          }
          public void meetDog(Dog dog){
                   System.out.println(name+"遇到"+dog.name);
          }
          public void beatDog(Dog dog){
                   System.out.println(name+"打了"+dog.name);
          }
}
 
 
package Chapter7_2;
//主类
public class DogAndPeople {
 
          public static void main(String[] args) {
                   People peo=new People();
                   Dog dog =new Dog();
                   peo.name="张三";
                   dog.name="大黄";
                   peo.walk();
                   peo.meetDog(dog);
                   dog.beatPersion(peo);
                   peo.beatDog(dog);
                   dog.dogRun();
          }
 
}

Methode (Antrieb (Auto), mit Car-Klassenobjekt als Parameter),

in der Hauptklasse

1) Lassen Sie eine Person Zhang San ein BMW-Auto fahren, das die Straße entlang rast

2) Treffen Sie einen Mann namens Li Si

3. Zusammenfassung der Verwendung von Klassen und Objekten

1. Abstrahieren Sie eine Art von Dingen mit ähnlichen Eigenschaften (Eigenschaften) und Verhaltensweisen (Methoden) und kapseln Sie sie in Klassen ri

2. Instanziieren (neu) ein bestimmtes Objekt entsprechend den Geschäftsanforderungen

package Chapter7_3;
//定义Car类
public class Car {
          String mark;
          int power;
          String color;
          int price;
 
          public void start(People p) {
                   System.out.println(p.name + "启动了"+mark);
          }
          public void speedUp(){
                   System.out.println(mark+"加速");
          }
          public void run(){
                   System.out.println(mark+"正常行驶");
          }
          public void hit(People p){
                   System.out.println(mark+"撞了"+p.name);
          }
}
package Chapter7_3;
//People类申明
public class People {
          String name ;
          char sex;
          short age;
          public void dirve(Car car){
                   System.out.println(name+"驾驶"+car.mark);
          }
 
}

package Chapter7_3;
//主类
public class CarAndPerple {
public static void main(String[] args) {
          Car car=new Car();
          People p1=new People();
          People p2=new People();
          car.color="black";
          car.mark="宝马";
          car.power=123;
          car.price=123143;
          p1.age=20;
          p1.name="张三";
          p1.sex='m';
          p2.age=21;
          p2.name="李四";
          p2.sex='m';
          car.start(p1);
          car.speedUp();
          p1.dirve(car);
          car.run();
          car.hit(p2);
}
}

3. Initialisieren Sie das Objekt und weisen Sie ihm Werte zu, um die Eigenschaften des spezifischen Objekts zu erhalten

4. Gemäß Unternehmen müssen Verhaltensweisen (Methoden) zwischen Objekten kombinieren

4. Mitgliedsvariablen und lokale Variablen

1. Mitgliedsvariablen werden in der Klasse definiert , außerhalb der Methode; auch globale Variablen genannt, der effektive Gültigkeitsbereich ist der gesamte Klassenkörper

2. Lokale Variablen werden innerhalb der Methode definiert und der Gültigkeitsbereich liegt innerhalb der Methode

3. Wann Lokale Variablen und Mitglieder Wenn die Variablennamen identisch sind, wird die Mitgliedsvariable in der Methode ausgeblendet, in der sich die lokale Variable befindet. Wenn Sie in dieser Methode eine versteckte globale (Mitglieds-)Variable verwenden müssen, müssen Sie das Schlüsselwort this

wie folgt verwenden: Wenn die lokale Variable und die Mitgliedsvariable denselben Namen haben, können Sie die Mitgliedsvariable aufrufen im Codeblock, in dem sich die lokale Variable befindet

5. Über das Design der Methode

1. Attribute der Methode

2. Die Zusammensetzung der Methode: Zugriffsmodifikator Rückgabewert Methodenname Methodenparameterliste

3. Überladung: Methodenüberladung bedeutet, dass es in einer Klasse mehrere Methoden mit demselben Namen geben kann, aber die Die Parameter dieser Methoden müssen unterschiedlich sein, dh die Anzahl der Parameter ist unterschiedlich oder die Parametertypen sind unterschiedlich.

Übung: Einfacher Taschenrechner (kann zwei, drei oder vier Zahlen addieren)

6. Konstruktionsmethode ( Konstruktor)

1. Was ist eine Bauweise? Was sind die Merkmale?

2. Welche Rolle spielt die Bauweise?

3. Wann wird der Konstruktor aufgerufen?

Beispiel: 7

Übung: 8

4. Kann der Konstruktor überladen werden?

5. Weitere Anweisungen:

Der Konstruktor ist eine wichtige Methode zum Erstellen von Objekten. Eine Klasse muss mindestens einen Konstruktor enthalten

        程序员如果不给一个类加构造器，则系统会默认添加一个没有参数的构造器

 

 

7.示例：建立一个学生类，有学号、姓名、年龄、性别属性，有描述个人信息的方法，通过键盘输入获取两个学生的信息，并且打印出描述信息

略

8.构建一个员工信息类（Employee），有员工编号、员工姓名、性别、年龄、工龄、工资等属性，有工作和休息的方法，还有打印自身信息的方法；

     在入口类中通过键盘输入，获取两个员工的对象，要求通过带参数的构造方法来进行成员变量的初始化。然后根据输入星期几，来输出员工当前的状态（周一至周五工作、周六和周日休息）

package Chapter8_2;
//所有类与方法在同一个文件中
import java.util.Scanner;
 
public class Staff {
          int number;
          String name;
          char sex;
          short age;
          short w_age;
          long mon;
 
          public Staff(String name, int number, char sex, short age, short w_age,
                             long mon) {
 
                   this.name = name;
                   this.number = number;
                   this.sex = sex;
                   this.age = age;
                   this.w_age = w_age;
                   this.mon = mon;
 
          }
 
          public void rest() {
                   System.out.println(name + "今天休息");
          }
 
          public void work() {
                   System.out.println(name + "今天工作");
          }
 
          public void printSelf() {
                   System.out.println(name + "\t" +number+"\t" +sex + "\t" + age + "\t" + w_age + "\t"
                                      + mon + "\t");
          }
 
          public static void main(String[] args) {
                   Scanner scan = new Scanner(System.in);
                   System.out.println("请输入第一个员工的信息：姓名，工号，性别，年龄，工龄，工资");
                   String name = scan.next();
                   int number = scan.nextInt();
                   char sex = scan.next().charAt(0);
                   short age = scan.nextShort();
                   short w_age = scan.nextShort();
                   long mon = scan.nextLong();
                   Staff sta = new Staff(name, number, sex, age, w_age, mon);
                   System.out.println("今天星期几");
                   short day = scan.nextShort();
                   if (day < 6) {
                             sta.work();
                   } else if (day >= 6 && day <= 7) {
                             sta.rest();
                   } else {
                             System.out.println("error!");
                   }
                   System.out.println("员工信息如下");
                   System.out.println("姓名"+"\t"+"工号"+"\t"+"性别"+"\t"+"年龄"+"\t"+"工龄"+"\t"+"工资");
                   sta.printSelf();
          }
 
}

9.变量、方法的分类：

 

    内存的分配：栈内存  堆内存

    创建对象时，通过new关键字调用构造函数，返回当前类的对象：People p=new People();

    对象里有成员变量，会在堆内存中开辟连续的空间存储成员变量。

    p是People类型的引用，p存储在栈内存中，它指向堆内存中的对象

 

    这种引用就是C语言中的指针，只是Java语言把这个指针封装了起来

 

    变量：成员变量   局部变量

        成员变量：类变量（有static关键字修饰） 和 实例变量（没有static关键字修饰）

        局部变量：形参、方法内的变量、代码块的变量

 

    方法：类方法（有static关键字修饰）、实例方法（没有static关键字修饰）

 

    java中类的生命周期：加载(Loading)-->验证(Verification)-->准备(Preparation)-->解析(Resolution)-->

                初始化(Initialization)-->使用(Using)-->卸载(Unloadling)

 

    1、类变量和实例变量的区别：类变量共享 ，类变量在类加载时分配入内存；实例变量每个对象独有 ，实例变量在类初始化的时候分配内存。

    2、类方法和实例方法的区别：类方法在类加载时分配入口地址；实例方法在类初始化时分配入口地址 （创建第一个对象时）

 

    3、访问和调用规则：

        1、实例方法既能能访问实例变量又能访问类变量

        2、类方法只能访问类变量

        3、实例方法能调用类方法，但是类方法只能调用类方法

 

10.对象默认初始化

 

11.总结

    1.类的概念、对象的概念；通过群体和个体的概念理解类和对象的关系

    2.类的成员包括—— 属性、方法 （有啥，能干啥）

    3.方法的设计

        a.方法名首字母小写；望文生义；多个单词组成的方法名首字母小写，第二个单词开始首字母大写

        b.返回类型

        c.方法的重载（参数的不同，要么参数个数不同，要么参数类型不同）

    4.成员变量和局部变量的区别；this关键字的作用（this相当于对象自身的意思）

    5.关于构造方法

        a.每一个类都有构造方法，不写不代表没有（默认无参的构造方法）

        b.构造函数与new关键字息息相关，直接决定了对象的构成方式

        c.带参数构造方法的常用方式（给成员变量进行赋值）

    6.实例变量和类变量、实例方法和类方法；关键字static

13.作业

    1．比较大小：写一个有两个int型的参数的方法，要求方法能够比较这两个参数的大小，并且返回比较大的一个，在另外一个类里使用这个方法。

 

    2．判断 ：在一个类里有一个方法，能判断给定的参数是否为偶数，如果是偶数返回true，否则返回false。在另一个类里调用该方法。

 

    3．写一个方法，有三个参数，分别为三个线段的长度，判断三条线段是否能组成一个三角形，如果能返回true，否则返回false。在另一个类中使用

 

    4．写一个三个参数的方法，判断给定的三个参数能否构成直角三角形。另一个类里使用。