public class Student {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Test{
public static void main(String[] args) {
Student firstStudent = new Student();
firstStudent.setName("John");
// The name field is private, so you can no longer do this: firstStudent.name = "John";
}
}
public class Android extends Phone {
// Some new fields
String androidVersion;
int screenSize;
String secretDeviceCode;
// Constructor
public Android(int price, double weight, String androidVersion, int screenSize, String secretDeviceCode) {
super(price, weight); // Android inherits Phone’s fields
//this - reference to the current object
//super - reference to the parent object
this.androidVersion = androidVersion;
this.screenSize = screenSize;
this.secretDeviceCode = secretDeviceCode;
}
// New Android-specific method, does not exist in the Phone class
void installNewAndroidVersion() {
System.out.println("installNewAndroidVersion invoked...");
}
}
public class IPhone extends Phone {
boolean fingerPrint;
public IPhone(int price, double weight, boolean fingerPrint) {
super(price, weight);
System.out.println("IPhone constructor was invoked...");
this.fingerPrint = fingerPrint;
}
void deleteIPhoneFromDb() {
System.out.println("deleteIPhoneFromDb invoked...");
}
@Override // This is about polymorphism, see below
void orderPhone(){
System.out.println("Ordering my new iPhone and deleting the old one...");
}
}
public class Musician {
String name;
int age;
// Default constructor
public Musician() {
}
// Parameterized constructor
public Musician(String name, int age) {
this.name = name;
this.age = age;
}
void play() {
System.out.println("I am playing my instrument...");
}
}
public class Pianist extends Musician {
String favoritePianoType;
public Pianist(String name, int age, String favoritePianoType) {
super(name, age);
this.favoritePianoType = favoritePianoType;
}
@Override
void play(){
System.out.println("I am playing the piano...");
}
}
小提琴手可以是獨奏者或管弦樂隊的成員。讓我們在覆蓋play()方法時考慮到這一點。
public class Violinist extends Musician {
boolean isSoloist;
public Violinist(String name, int age, boolean isSoloist) {
super(name, age);
this.isSoloist = isSoloist;
}
@Override
void play(){
if (isSoloist)
System.out.println("I am playing the violin solo...");
else
System.out.println("I am playing the violin in an orchestra...");
}
}
public class Pianist extends Musician {
String favoritePianoType;
@Override
void play(){
super.play();
System.out.println("I am playing the piano...");
}
}
現在讓我們在Demo類中調用我們的main()方法。結果如下：
Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
public class Pianist extends Musician {
String name;
int age;
String favoritePianoType;
@Override
void play(){
super.play();
System.out.println("I am playing the piano...");
}
void play(boolean isElectricity){
if (isElectricity) {
System.out.println("The electricity is on.");
System.out.println("I am playing the piano...");
}
else System.out.println("I can't play this without electricity.");
}
}
順便說一下，您可以通過這種方式在第二個play(boolean)方法中使用第一個play()方法：
void play(boolean isElectricity){
if (isElectricity) {
System.out.println("The electricity is on.");
play();
}
else System.out.println("I can't play this without electricity.");
}
讓我們在Demo類中添加一些行來演示我們的重載：
public class Demo {
public static void main(String[] args) {
Musician musician = new Musician();
Violinist violinist = new Violinist("John", 23, true);
Pianist pianist = new Pianist("Glen", 30, "Acoustic");
System.out.println("Musician said:");
musician.play();
System.out.println("Violinist said:");
violinist.play();
System.out.println("Pianist said:");
pianist.play();
System.out.println("The pianist will now try the electric piano:");
pianist.play(true);
System.out.println("The electricity has been shut off. Now when trying the electric piano, the pianist says:");
pianist.play(false);
}
}
這是結果：
Musician said:
I am playing my instrument...
Violinist said:
I am playing the violin solo...
Pianist said:
I am playing my instrument...
I am playing the piano...
The pianist will now try the electric piano:
The electricity is on.
I am playing my instrument...
I am playing the piano...
The electricity has been shut off. Now when trying the electric piano, the pianist says:
I can't play this without electricity.
Java 根據其參數和對像類型知道應該使用哪個方法。這就是多態。
抽象
當我們定義一個類時，我們正在嘗試構建某種事物的模型。例如，假設我們正在用不同的賽車編寫一個名為 MyRacer 的視頻遊戲。玩家可以選擇其中之一，然後更新它或購買不同的。那麼……什麼是汽車？汽車是一件相當複雜的事情，但如果我們正在嘗試創建賽車視頻遊戲（而不是駕駛模擬器），那麼我們不需要描述它包含的所有數千個齒輪和墊圈。我們需要它的型號、最高速度、機動性、價格、顏色……也許這就足夠了。這是我們遊戲的汽車模型。稍後在 MyRacer 2 中，假設我們決定添加影響道路操控性的輪胎。這裡的模型不同，因為我們添加了更多細節。讓' s 將數據抽象定義為僅識別對象的重要（或必要）特徵並忽略任何不相關細節的過程。有不同層次的抽象。例如，如果您是公共汽車上的乘客，您需要知道您的公共汽車長什麼樣以及它要去哪裡，但您不需要知道如何駕駛它。如果您是公交車司機，您不需要知道如何創建一輛新公交車——您只需要知道如何駕駛它。但是如果你是一個總線製造商，你需要去更底層的抽象層次，因為總線設計的細節對你來說非常重要。我希望你明白我的意思。您需要知道您的公共汽車長什麼樣以及它要去哪裡，但您不需要知道如何駕駛它。如果您是公交車司機，您不需要知道如何創建一輛新公交車——您只需要知道如何駕駛它。但是如果你是一個總線製造商，你需要去更底層的抽象層次，因為總線設計的細節對你來說非常重要。我希望你明白我的意思。您需要知道您的公共汽車長什麼樣以及它要去哪裡，但您不需要知道如何駕駛它。如果您是公交車司機，您不需要知道如何創建一輛新公交車——您只需要知道如何駕駛它。但是如果你是一個總線製造商，你需要去更底層的抽象層次，因為總線設計的細節對你來說非常重要。我希望你明白我的意思。
interface Human {
public void struggle();
public void protect();
}
interface Vulcan {
int angleOfPointyEars;
public void turnOffEmotions(boolean isOn);
public void telepathy();
}
您可以實現多個接口
The Spock class implements Human and Vulcan {
public void struggle() {
System.out.println("I am struggling...");
}
public void protect() {
System.out.println("You are under my protection!”);
}
public void turnOffEmotions(boolean isOn){
If (isOn) {
System.out.println("I am turning off my emotions.");
isOn= !isOn;
}
}
public void telepathy() {
System.out.println("Connecting to your brain...");
}
}
經典 OOP 包括 3 + 1 個主要概念。讓我們從經典開始。
GO TO FULL VERSION