Java로 객체 지향 프로그래밍 마스터하기: 종합 가이드 FO♨

Objektorientierte Programmierung

Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das reale Entitäten als Objekte modelliert. Diese Objekte haben Eigenschaften (Attribute) und Verhaltensweisen (Methoden). OOP basiert auf den Konzepten Kapselung, Vererbung, Polymorphismus und Abstraktion.

Java ist eine Computerprogrammiersprache, die gleichzeitig, klassenbasiert und objektorientiert ist. Die Vorteile der Objektorientierung
Softwareentwicklung sind unten aufgeführt:

• Modulare Entwicklung: Dies erleichtert die Wartung und Änderung des Codes.
• Wiederverwendbarkeit des Codes: Dies reduziert die Notwendigkeit, denselben Code mehrmals zu schreiben.
• Verbesserte Codezuverlässigkeit und -flexibilität: Dies erleichtert die Erstellung robuster und anpassungsfähiger Software.
• Erhöhtes Codeverständnis: Dies verbessert die Lesbarkeit und Wartbarkeit des Codes.

Verkapselung

Kapselung in Java ist ein grundlegendes objektorientiertes Programmierkonzept, bei dem Daten (Attribute) und Methoden (Verhalten) innerhalb eines Objekts gebündelt werden. Es bietet Datenversteckung und Zugriffskontrolle und stellt sicher, dass Daten geschützt sind und nur über definierte Methoden darauf zugegriffen werden kann.

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Sam", 21);
        System.out.println("Person Name: "+ p.getName());
        System.out.println("Person Name: "+ p.getAge());
        /* 
         *  p.name = "Anderson";  -> We couldn't modify the varibale value directly. It's Error ❗.
         *  p.age = 20;
        */
    }
}

Stellen Sie sich eine Kiste vor. In der Box befinden sich Ihre persönlichen Gegenstände. Sie können die Schachtel sehen und wissen, was sich darin befindet, aber Sie können die Gegenstände nicht direkt berühren oder ändern, ohne die Schachtel zu öffnen. Dies ähnelt der Kapselung in Java.

Polymorphismus

Polymorphismus ist in Java die Fähigkeit von Objekten verschiedener Klassen, auf denselben Methodenaufruf auf unterschiedliche Weise zu reagieren. Es handelt sich um ein grundlegendes Konzept der objektorientierten Programmierung, das Flexibilität und Wiederverwendbarkeit des Codes ermöglicht. Es gibt zwei Arten von Polymorphismus: Polymorphismus zur Kompilierungszeit und Polymorphismus zur Laufzeit.

Beispiel

Stellen Sie sich vor, Sie hätten eine Fernbedienung. Sie können die „Play“-Taste drücken und es wird etwas abgespielt. Aber was es abspielt, hängt von dem Gerät ab, das es steuert: ein Fernseher, ein DVD-Player oder ein Musikplayer.

Das ist wie Polymorphismus in Java. Die „Play“-Taste ist die gleiche Methode, aber das Verhalten (was abgespielt wird) ist je nach Objekt (Fernseher, DVD-Player, Musikplayer) unterschiedlich.

Polymorphismus bedeutet also, dass dasselbe Ding (eine Methode) je nach Objekt, das es aufruft, unterschiedlich verhalten kann.

interface Playable {
    void play();
}

class TV implements Playable {
    public void play() {
        System.out.println("Playing TV show");
    }
}

class DVDPlayer implements Playable {
    public void play() {
        System.out.println("Playing DVD");
    }
}

class MusicPlayer implements Playable {
    public void play() {
        System.out.println("Playing music");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Playable[] devices = {new TV(), new DVDPlayer(), new MusicPlayer()};
        for (Playable device : devices) {
            device.play();
        }
    }
}

Nachlass

Vererbungskonzept, das es Klassen ermöglicht, Attribute, Eigenschaften und Methoden von einer übergeordneten Klasse zu erben. Dies fördert die Wiederverwendbarkeit des Codes, die Modularität und die Schaffung hierarchischer Beziehungen zwischen Klassen.

Vererbung in Java ist wie ein Stammbaum. Eine untergeordnete Klasse kann Merkmale von einer übergeordneten Klasse erben. Dafür gibt es verschiedene Möglichkeiten:

• Einzelvererbung: Ein Kind, ein Elternteil.
• Mehrstufige Vererbung: Das Kind erbt vom Elternteil, das auch ein Kind ist.
• Hierarchische Vererbung: Mehrere Kinder von einem Elternteil.

Java unterstützt die Mehrfachvererbung nicht direkt, aber Sie können Schnittstellen verwenden, um ein ähnliches Ergebnis zu erzielen.

class Animal {
    void makeSound() {
        System.out.println("Generic animal sound");
    }

    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Generic animal sound");
        }
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }

    @Override
    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Woof!");
        }
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow!");
    }

    @Override
    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Meow!");
        }
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};

        // Method overloading:
        animals[0].makeSound();
        animals[1].makeSound(3);

        // Method overriding:
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

Abstraktion

Abstraktion ist der Prozess, bei dem Ideen von bestimmten Instanzen getrennt werden und so Klassen im Hinblick auf ihre eigene Funktionalität und nicht auf ihre Implementierungsdetails entwickelt werden. Java unterstützt die Erstellung und Existenz abstrakter Klassen, die Schnittstellen verfügbar machen, ohne die tatsächliche Implementierung aller Methoden einzubeziehen. Die Abstraktionstechnik zielt darauf ab, die Implementierungsdetails einer Klasse von ihrem Verhalten zu trennen.

abstract class Shape {
    abstract double getArea();
}

class Circle extends Shape {
    private double radius;

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

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double getArea() {
        return length * width;
    }
}

public class ShapeExample {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 3.0);

        System.out.println("Circle area: " + circle.getArea());
        System.out.println("Rectangle area: " + rectangle.getArea());
    }
}

Stellen Sie sich vor, Sie hätten eine Fernbedienung für ein Auto, ein Fahrrad und ein Flugzeug. Sie können jedes Fahrzeug mit denselben Tasten auf der Fernbedienung starten, stoppen und bewegen, auch wenn sie sehr unterschiedlich sind. Das ist wie Abstraktion in der Programmierung.

Unterschiede zwischen Abstraktion und Kapselung

Abstraktion

• Fokus: Verbirgt die zugrunde liegende Komplexität eines Objekts und enthüllt nur die wesentlichen Merkmale.
• Zweck: Vereinfacht Code, indem der Schwerpunkt auf dem liegt, was ein Objekt tut, und nicht darauf, wie es es tut.
• Mechanismus:Erreicht durch abstrakte Klassen und Schnittstellen.
• Beispiel: Eine Fahrzeugschnittstelle, die Methoden wie start(), stop() und move() definiert, ohne die spezifische Implementierung für jeden Fahrzeugtyp (Auto, Fahrrad usw.) offenzulegen.

Kapselung

• 중점: 개체의 데이터를 무단 액세스 또는 수정으로부터 보호합니다.
• 목적: 코드 보안, 모듈성 및 유지 관리성을 향상합니다.
• 메커니즘: 데이터 멤버를 비공개로 만들고 해당 멤버에 액세스하거나 수정할 수 있는 공개 방법을 제공함으로써 달성됩니다.
• 예: 이름, 나이와 같은 비공개 필드와 이러한 필드에 액세스하거나 수정하기 위한 getName() 및 setAge()와 같은 공개 메소드가 있는 Person 클래스.

주요 차이점

Feature	Abstraction	Encapsulation
Focus	Essential features	Data protection
Purpose	Simplification	Security, modularity
Mechanism	Abstract classes, interfaces	Private fields, public methods
Example	Vehicle interface	Person class with private fields and public methods

본질:

• 추상화는 객체가 하는 일에 관한 것입니다.
• 캡슐화는 객체가 이를 수행하는 방식에 관한 것입니다.

OOP를 레고 블록으로 건물을 짓는 것과 같다고 생각하세요. 각 벽돌은 고유한 모양과 속성을 가진 객체입니다. 벽돌을 결합하여 더 크고 복잡한 구조물을 만들 수 있습니다. 이러한 개념을 이해하면 더욱 체계적이고 유연하며 효율적인 코드를 작성할 수 있습니다.

위 내용은 Java로 객체 지향 프로그래밍 마스터하기: 종합 가이드 FO♨의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!