Objektorientierter:
Drei Merkmale der objektorientierten: Einkapselung, Vererbung, Polymorphismus
Ein Paket
1. Die Methode ist eine Art Verpackung
2. Das Schlüsselwort privat ist auch eine Art Kapselung
Die Kapselung dient dazu, einige detaillierte Informationen zu verbergen, die für die Außenwelt unsichtbar sind
package com.dcits.day05.demo03;
public class Demo02Method {
public static void main(String[] args) {
int[] array = {5,15,25,35,111};
int max = getMax(array);
System.out.println(max);
}
public static int getMax(int[] array) {
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
} private关键字的作用以及使用Sobald das Private für Änderungen verwendet wird, kann nach Belieben auf diese Klasse zugegriffen werden, es kann jedoch nicht mehr über den Umfang dieser Klasse hinaus zugegriffen werden
Sie können ein Paar Getter / Setter-Methoden durch indirekten Zugriff anpassen, der als setXxx oder getXxx bezeichnet werden muss
Für Getter können keine Parameter vorhanden sein, und der Rückgabewerttyp entspricht der Elementvariablen
Für Setter kann es keinen Rückgabewert geben, der Parametertyp entspricht der Mitgliedsvariablen
// Person类
package com.dcits.day05.demo03;
public class Person {
String name;
private int age;
public void show() {
System.out.println("我叫：" + name +",今年" + age);
}
public void setAge(int num) {
if (num < 100 && num >=9) {
age = num;
} else {
age = 0;
System.out.println("数据不合理");
}
}
public int getAge() {
return age;
}
}
// 调用
package com.dcits.day05.demo03;
public class Demo03Person {
public static void main(String[] args) {
Person person = new Person();
person.name = "赵丽颖";
// person.age = 18; 当成员变量被private修饰的时候，外部无法访问，只能通过间接的方式Setter，Getter
person.setAge(-20);
person.show();
}
}Sonderfall vom Booleschen Typ
// 类
package com.dcits.day05.demo03;
public class Student {
private String name;
private int age;
private boolean male;
public void setMale(boolean b){
male = b;
}
public boolean isMale() {
return male;
}
public void setName(String str){
name = str;
}
public String getName() {
return name;
}
public void setAge(int num) {
age = num;
}
public int getAge() {
return age;
}
}
// 调用
package com.dcits.day05.demo03;
public class Demo04Student {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("alex");
stu.setAge(10);
stu.setMale(true);
System.out.println(stu.getName());
System.out.println(stu.getAge());
System.out.println(stu.isMale());
}
}
this关键字的使用Wenn die lokale Variable der Methode und die Mitgliedsvariable der Klasse nach dem Prinzip der Nähe denselben Namen haben, wird die lokale Variable bevorzugt. Wenn Sie auf die Mitgliedsvariable in dieser Klasse zugreifen müssen, müssen Sie das Format verwenden: this. Mitgliedsvariable
Von wem heißt die Methode, wer ist das?
// 类
package com.dcits.day05.demo04;
public class Person {
String name;
public void sayHi(String name) {
System.out.println(this.name + "你好，我是" + name);
}
}
// 调用
package com.dcits.day05.demo04;
public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
person.name = "6666";
person.sayHi("777");
}
} 构造方法Die Konstruktionsmethode ist eine Methode, die speziell zum Erstellen eines Objekts verwendet wird. Wenn wir zum Erstellen eines Objekts das Schlüsselwort new verwenden, rufen wir die Konstruktionsmethode tatsächlich auf
Vorsichtsmaßnahmen:
* 构造方法的名称必须和所在的类名称完全一样，就连大小写也要完全一样
* 构造方法不要写返回值类型，连void都不要写
* 构造方法不能return一个具体的返回值
* 如果没有编写任何构造方法，那么编译器默认会赠送一个构造方法，没有参数、方法体什么都不做
* 一旦编写了一个构造方法，那么编译器就不再赠送
* 构造 方法也是可以重载的// 类
package com.dcits.day05.demo04;
public class Student {
private String name;
private int age;
public Student(String name,int age) {
this.name = name;
this.age = age;
System.out.println("有参数的构造方法！！");
}
public Student() {
System.out.println("无参数的构造方法执行啦！！");
}
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;
}
}
// 调用
package com.dcits.day05.demo04;
public class Demo02Student {
public static void main(String[] args) {
Student stu = new Student();
Student stu1 = new Student("aaa",20);
stu1.setAge(23);
System.out.println(stu1.getAge());
System.out.println(stu1.getName());
}
}
局部变量和成员变量1.定义的位置不一样
* 局部变量：在方法的内部
* 成员变量：在方法的外部，直接写在类当中
2.作用范围不一样
*局部变量：只有方法 才可以使用，出了方法就不能再使用了
*成员变量：整个类都可以通用
3.默认值不一样
*局部变量：没有默认值，如果想要用，必须手动赋值
*成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样
*局部变量：位于栈内存
*成员变量：位于堆内存
5.生命周期不一样
*局部变量：随着方法进栈而诞生，随着方法出栈而消失
*成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失 标准类的组成部分Eine Standardklasse besteht normalerweise aus den folgenden vier Teilen:
1. 所有的成员变量都要使用private关键字来修饰
2. 为每一个成员变量编写一对Getter、Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法Zwei: Vererbung
Vererbung ist die Voraussetzung für Polymorphismus. Wenn es keine Vererbung gibt, gibt es keinen Polymorphismus
Das Hauptproblem, das durch Vererbung gelöst wird, ist: Gemeinsamkeitsextraktion
Zwei Überlegungen beim Definieren einer Klasse:
- Mitgliedsvariablen werden direkt in der Klasse außerhalb der Methode definiert
-
Schreiben Sie kein statisches Schlüsselwort in die Mitgliedsmethode
继承的格式：// 父类 package com.dcits.day08.demo01; public class Employee { public void method() { System.out.println("父类执行！"); } } // Teacher子类 package com.dcits.day08.demo01 public class Teacher extends Employee{ } // Assistant子类 package com.dcits.day08.demo01; public class Assistant extends Employee { } // 调用 package com.dcits.day08.demo01; public class Demo01Extends { public static void main(String[] args) { Teacher teacher = new Teacher(); Assistant assistant = new Assistant(); teacher.method(); assistant.method(); } }在父子类的继承关系当中，如果成员变量重名，则创建子类时，访问有两种方式：-
Greifen Sie direkt über Unterklassenobjekte auf Mitgliedsvariablen zu
Wer sich links vom Gleichheitszeichen befindet, gibt demjenigen Vorrang, der verwendet wird, und wenn nicht, schauen Sie nach
-
-
Greifen Sie indirekt über Mitgliedsmethoden auf Mitgliedsvariablen zu
该方法属于谁，就优先用谁，没有则向上找// 父类 package com.dcits.day08.demo02; public class Fu { int numFu = 10; int num = 100; public void methodFu() { System.out.println(num); } } // 子类 package com.dcits.day08.demo02; public class Zi extends Fu { int numZi = 20; int num = 200; public void methodZi() { System.out.println(num); } } // 调用 package com.dcits.day08.demo02; public class Demo01ExtendsField { public static void main(String[] args) { Fu fu = new Fu(); System.out.println(fu.numFu); Zi zi = new Zi(); System.out.println(zi.numFu); System.out.println(zi.numZi); // 当父类与子类的成员变量重名的时候 System.out.println(zi.num); // System.out.println(zi.abc); // zi.methodZi(); zi.methodFu(); } }区分子类方法中的三种重名变量 - Variablen in direkt verwendeten Methoden
- this. Variablenname: Rufen Sie die Mitgliedsvariable in dieser Klasse auf
-
super. Variablenname: Ruft die Mitgliedsvariable in der übergeordneten Klasse auf
// 父类 package com.dcits.day08.demo03; public class Fu { int num = 10; } // 子类 package com.dcits.day08.demo03; public class Zi extends Fu { int num = 20; public void method() { int num = 30; System.out.println(num); // 30 局部变量 System.out.println(this.num); // 20 本类的成员变量 System.out.println(super.num); // 10 父类的成员变量 } } // 调用 package com.dcits.day08.demo03; public class Demo01ExtendsField { public static void main(String[] args) { Zi zi = new Zi(); zi.method(); } } 继承中成员方法的访问特点In der Vererbungsbeziehung von übergeordneten und untergeordneten Klassen werden die Regeln zum Erstellen von Unterklassenobjekten und zum Zugreifen auf Elementmethoden: Wer auch immer das erstellte Objekt ist, wird zuerst verwendet. Wenn nicht, suchen Sie nach
Hinweis: Unabhängig davon, ob es sich um eine Member-Methode oder eine Member-Variable handelt, wird die übergeordnete Klasse u und niemals die untergeordnete Klasse nachgeschlagen
// 父类 package com.dcits.day08.demo04; public class Fu { public void methodFu() { System.out.println("父类中的方法执行啦！"); } public void method() { System.out.println("父类重名执行啦！"); } } // 子类 package com.dcits.day08.demo04; public class Zi extends Fu { public void methodZi() { System.out.println("子类中的方法执行啦！"); } public void method() { System.out.println("子类重名执行啦！"); } } // 调用 package com.dcits.day08.demo04; public class Zi extends Fu { public void methodZi() { System.out.println("子类中的方法执行啦！"); } public void method() { System.out.println("子类重名执行啦！"); } }继承方法中的覆盖重写Umschreiben: Der Name der Methode ist derselbe, die Parameterliste ist der gleiche, überschreiben, überschreiben
Überladung: Der Methodenname ist derselbe, die Parameterliste ist unterschiedlich
Methodenabdeckung und Umschreibeigenschaften: Erstellen Sie ein Unterklassenobjekt. Die Unterklassenmethode wird bevorzugt
Hinweis zur Methodenüberschreibung:
- Muss sicherstellen, dass der Methodenname und die Parameterliste zwischen der übergeordneten und der untergeordneten Klasse identisch sind
- @Override: Schreiben Sie vor die Methode, um zu überprüfen, ob das Überschreiben gültig und korrekt ist. Auch wenn dieser Kommentar nicht geschrieben wurde, handelt es sich um ein korrektes Überschreiben, sofern er den Anforderungen entspricht.
- Der Rückgabewert der Unterklassenmethode muss kleiner oder gleich dem Rückgabewertbereich der übergeordneten Methode sein. Die Objektklasse ist die übergeordnete Klasse aller Klassen
- Die Berechtigung der Unterklassenmethode muss größer oder gleich dem Berechtigungsmodifikator der übergeordneten Methode sein. public> protected> (Standard)> private Hinweis: (Standard) ist nicht das Standardwort, aber schreiben Sie nichts, lassen Sie es leer
und überschreiben Sie das Anwendungsszenario der Vererbungsmethode// 父类 package com.dcits.day08.demo06; // 本来的老款手机 public class Phone { public void call() { System.out.println("打电话"); } public void send() { System.out.println("发短信"); } public void show() { System.out.println("显示号码"); } } // 子类 package com.dcits.day08.demo06; // 上市的新款手机 public class NewPhone extends Phone { @Override public void show() { // System.out.println("显示号码"); super.show(); System.out.println("显示姓名"); System.out.println("显示头像"); } } // 调用 package com.dcits.day08.demo06; public class Demo01Phone { public static void main(String[] args) { Phone phone = new Phone(); phone.call(); phone.send(); phone.show(); System.out.println("==========="); NewPhone newPhone = new NewPhone(); newPhone.call(); newPhone.send(); newPhone.show(); } }继承中构造方法的访问特点- In der Unterklassenkonstruktionsmethode gibt es einen impliziten Standardaufruf "super ()". Daher muss zuerst die übergeordnete Klassenkonstruktion aufgerufen und die Unterklassenkonstruktion später ausgeführt werden
- Die Unterklassenstruktur kann die Überladungsstruktur der übergeordneten Klasse über das Schlüsselwort super aufrufen
- Der Superstrukturaufruf der Superklasse kann nur die erste Anweisung sein, und die Superstruktur kann für eine Unterklassenstruktur nicht mehrmals aufgerufen werden.
- Die Unterklasse muss die Konstruktionsmethode der übergeordneten Klasse aufrufen. Wenn Sie kein Geschenk super () schreiben, können Sie den Superaufruf durch Schreiben angeben. Es kann nur ein Super geben, und es muss das erste sein.
super关键字的用法（访问父类的内容）：- Greifen Sie in der Member-Methode der Unterklasse auf die Member-Variablen der übergeordneten Klasse zu
- Greifen Sie in den Mitgliedsmethoden der Unterklasse auf die Mitgliedsmethoden der übergeordneten Klasse zu
- Greifen Sie in der Konstruktionsmethode der Unterklasse auf die Konstruktionsmethode der übergeordneten Klasse zu
// 父类 package com.dcits.day08.demo08; public class Fu { int num = 10; public void method(){ System.out.println("父类方法"); } } // 子类 package com.dcits.day08.demo08; public class Zi extends Fu { int num = 20; public Zi(){ super(); } public void methodZi() { System.out.println(super.num); // 父类的num } public void method(){ super.method(); System.out.println("子类方法"); } } this关键字的三种使用方法（访问本类的内容）- Greifen Sie in den Mitgliedsmethoden dieser Klasse auf die Mitgliedsvariablen dieser Klasse zu
- Greifen Sie in der Mitgliedsmethode dieser Klasse auf eine andere Mitgliedsmethode dieser Klasse zu
- Besuchen Sie in der Konstruktionsmethode dieser Klasse eine andere Konstruktionsmethode dieser Klasse.
Hinweis:- Achten Sie auf die dritte Verwendung: Dieser (..) Aufruf muss eine Aussage in der Konstruktionsmethode sein, die einzige
- Die beiden Konstruktionsaufrufe von super und dies können nicht gleichzeitig verwendet werden
// 父类 package com.dcits.day08.demo09; public class Fu { int num = 30; } // 子类 package com.dcits.day08.demo09; public class Zi extends Fu { int num = 20; public Zi(){ this(123); // 本类的无参构造，调用本类的有参构造 // this(1,2) } public Zi(int n){ } public Zi(int n,int m){ } public void showNum(){ int num = 10; System.out.println(num); System.out.println(this.num); // 本类中的成员变量 System.out.println(super.num); // 父类中的 成员变量 } public void methodA() { System.out.println("AAA"); } public void methodB() { methodA(); this.methodA(); System.out.println("BBB"); } }this、super的关键字图解
Drei Merkmale der Java-Sprachvererbung: - Es kann nur einen direkten Elternteil einer Klasse geben
- Java-Sprache kann mehrere erben
- Das direkte übergeordnete Element einer Unterklasse ist eindeutig, ein übergeordnetes Element kann jedoch viele Unterklassen haben
Drei: Polymorphismus:
多态的定义以及基本使用Erweitert die Vererbung oder implementiert die Realisierung ist die Voraussetzung des Polymorphismus.
Das Objekt von Xiao Ming hat sowohl eine Studentenform als auch eine menschliche Form. Ein Objekt hat viele Formen. Dies ist: Polymorphismus
spiegelt sich im Polymorphismuscode des Objekts wider. Tatsächlich ist es nur ein Satz: Die Referenz der übergeordneten Klasse verweist auf das Unterklassenobjekt
Format:
- Name der übergeordneten Klasse Objektname = neuer Name der Unterklasse ()
-
Schnittstellenname Objektname = neuer Implementierungsklassenname ()
// 父类 package com.dcits.day09.demo04; public class Fu { public void method(){ System.out.println("父类方法"); } public void methodFu(){ System.out.println("父类特有方法"); } } // 子类 package com.dcits.day09.demo04; public class Zi extends Fu { @Override public void method() { System.out.println("子类方法"); } } // 调用 package com.dcits.day09.demo04; public class Demo01Multi { public static void main(String[] args) { // 使用多态的写法 // 左侧父类的引用指向右侧子类的对象 Fu obj = new Zi(); // new 的是谁就调用谁 的方法 obj.method(); // 子类方法 obj.methodFu(); // 父类特有方法 } } 多态中成员变量的使用特点Zwei Möglichkeiten, auf Mitgliedsvariablen zuzugreifen:
- Greifen Sie direkt über den Objektnamen auf Mitgliedsvariablen zu. Sehen Sie, wer sich auf der linken Seite des Gleichheitszeichens befindet und wer als erster verwendet wird. Wenn nicht, suchen Sie nach
- Indirekter Zugriff auf Mitgliedsvariablen über Mitgliedsmethoden, um zu sehen, wem die Methode gehört, wer zuerst verwendet werden soll, wenn nicht, suchen Sie sie wie oben beschrieben
// 父类 package com.dcits.day09.demo05; public class Fu { int num = 10; public void showNum(){ System.out.println(num); } } // 子类 package com.dcits.day09.demo05; public class Zi extends Fu { int num = 20; int age = 16; @Override public void showNum() { System.out.println(num); } } // 调用 package com.dcits.day09.demo05; public class Demo01MultiField { public static void main(String[] args) { Fu obj = new Zi(); System.out.println(obj.num); // 父类中的10 System.out.println("====================="); obj.showNum(); // 子类没有覆盖重写,就是父类中的num，一旦子类重写后就是子类中的num } } 多态中成员方法的使用特点Im polymorphen Code lautet die Prioritätszugriffsregel für Mitgliedsmethoden: Um zu sehen, wer neu ist, geben Sie jedem, der neu ist, Priorität. Wenn Sie dies nicht tun, werden Sie nachschlagen.
Hinweis: Zum Kompilieren siehe links, zum Ausführen rechts
Vergleichen Sie
-
Mitgliedsvariablen: Links kompilieren und links ausführen
- Mitgliedsmethode: kompilieren und links betrachten, ausführen und rechts betrachten
// 父类 package com.dcits.day09.demo05; public class Fu { int num = 10; public void showNum(){ System.out.println(num); } public void method(){ System.out.println("父类方法"); } public void methodFu(){ System.out.println("父类特有方法"); } } // 子类 package com.dcits.day09.demo05; public class Zi extends Fu { int num = 20; int age = 16; @Override public void showNum() { System.out.println(num); } @Override public void method() { System.out.println("子类方法"); } public void methodZi(){ System.out.println("子类特有方法"); } } // 调用 package com.dcits.day09.demo05; public class Demo01MultiField { public static void main(String[] args) { Fu obj = new Zi(); obj.method(); // 父子都有，优先使用子类 obj.methodFu(); // 子类没有，父类有，向上找到父类 // 编译看左，左边是Fu，没有methodZi方法，所以编译报错 // obj.methodZi(); // 错误写法 // System.out.println(obj.num); // 父类中的10 // System.out.println("====================="); // obj.showNum(); // 子类没有覆盖重写,就是父类中的num，一旦子类重写后就是子类中的num } } 使用多态的好处
对象的向上转型Die Aufwärtstransformation von Objekten ist eigentlich ein polymorpher Ansatz
Format: Name der übergeordneten Klasse Objektname = neuer Name der Unterklasse ()
Bedeutung: Erstellen Sie rechts ein Unterklassenobjekt und behandeln Sie es als übergeordnete Klasse
Vorsichtsmaßnahmen:
-
Der Übergang nach oben muss sicher sein, von einem kleinen Bereich zu einem großen Bereich
- Es gibt jedoch einen Nachteil: Sobald das Objekt in eine übergeordnete Klasse umgewandelt wurde, kann es den ursprünglichen eindeutigen Inhalt der Unterklasse nicht mehr aufrufen
Ähnlich wie: double num = 100 korrekt int ---- doppelte automatische Typkonvertierung
// 父类
package com.dcits.day09.demo06;
public abstract class Animal {
public abstract void eat();
}
// 子类
package com.dcits.day09.demo06;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼。。。");
}
}
// 调用
package com.dcits.day09.demo06;
public class Demo01Main {
public static void main(String[] args) {
Animal animal = new Cat();
animal.eat();
}
} 对象的向下转型Die Abwärtstransformation des Objekts ist eigentlich eine Reduktionsaktion
Format: Unterklassenname Objektname = (Unterklassenname) übergeordnetes Klassenobjekt
Bedeutung: Stellen Sie das übergeordnete Klassenobjekt im ursprünglichen Unterklassenobjekt wieder her
Vorsichtsmaßnahmen:
-
Es muss sichergestellt sein, dass das Objekt beim Erstellen eine Katze ist, bevor es in eine Katze umgewandelt werden kann
- Wenn das Objekt beim Erstellen keine Katze war, es aber jetzt in eine Katze umgewandelt werden muss, wird ein Fehler gemeldet
Ähnlich wie: int num = (int) 10.0 richtig int num = (int) 10.5 Fehler, Genauigkeitsverlust
// 父类
package com.dcits.day09.demo06;
public abstract class Animal {
public abstract void eat();
}
// 猫子类
package com.dcits.day09.demo06;
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼。。。");
}
public void catchMouse() {
System.out.println("猫抓老鼠！！");
}
}
// 狗子类
package com.dcits.day09.demo06;
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃shit");
}
public void watchMouse() {
System.out.println("狗看家！！");
}
}
// 调用
package com.dcits.day09.demo06;
public class Demo01Main {
public static void main(String[] args) {
Animal animal = new Cat(); // 对象的向上转型
animal.eat();
// 向下转型
Cat cat = (Cat) animal;
cat.catchMouse(); // 猫抓老鼠！！
// 下面是错误的向下转型
// 本来new的时候是一只猫，现在非要转成狗
// java.lang.ClassCastException
Dog dog = (Dog) animal; // 错误写法
}
}
接口多态的综合案例// USB接口类：两个抽象方法：打开USB、关闭USB
package com.dcits.day09.demo07;
public interface USB {
public abstract void open();
public abstract void close();
}
// 电脑类：开机、关机、连接USB接口并对USB设备进行对应操作
package com.dcits.day09.demo07;
public class Computer {
public void powerOn(){
System.out.println("笔记本电脑开机");
}
public void powerOff(){
System.out.println("笔记本电脑关机");
}
// 使用USB设备的方法,使用接口作为方法的参数
public void useDevice(USB usb) {
usb.open();
// 判断当前类是属于哪个类之后，在获取类中的特有方法
if (usb instanceof Mouse){
Mouse mouse = (Mouse) usb;
mouse.click();
} else if (usb instanceof KeyBoard){
KeyBoard keyboard = (KeyBoard) usb;
keyboard.type();
}
usb.close();
}
}
// 鼠标类：重写接口类中的打开、关闭功能，并实现自己的独有功能
package com.dcits.day09.demo07;
public class Mouse implements USB {
@Override
public void open() {
System.out.println("打开鼠标");
}
@Override
public void close() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("点击鼠标！");
}
}
// 键盘类：重写接口类中的打开、关闭功能，并实现自己的独有功能
package com.dcits.day09.demo07;
public class KeyBoard implements USB {
@Override
public void open() {
System.out.println("打开键盘");
}
@Override
public void close() {
System.out.println("关闭键盘");
}
public void type(){
System.out.println("敲键盘！");
}
}