设计模式面向对象基础

OperateCode
0 阅读4分钟

设计模式面相对象基础

1 概述

  • 在学习设计模式中，为什么要这这里进行 Java 面向对象基础知识的科普？
  • 这是因为设计模式是针对面向对象编程（OOP）问题提供的解决方案，所以在学习设计模式时，理解 Java 的面向对象基础非常重要。或者可以这么说了解 Java 面向对象的基础，是掌握设计模式的前提。这些基础概念是设计模式的构建模块，理解这些概念可以帮助你更好地理解和应用设计模式，提高代码的灵活性、可维护性和可扩展性。

2 Java 面相对象基础

2.1 类与实例

2.1.1 类（Class）

  • 类是对象的模板，定义了对象的属性和方法。
public class Person {
    private String name;
    private int age;

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

2.1.2 实例（Object）

  • 实例是类的具体对象，通过类来创建。
public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.display();
    }
}

2.2 构造方法（Constructor）

  • 构造方法用于初始化对象。与类同名，没有返回类型。
public class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

2.3 方法重载（Method Overloading）

  • 方法重载指同一类中多个方法具有相同名字但参数不同。
public class MathUtil {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

2.4 属性和修饰符（Properties and Modifiers）

2.4.1 属性（Properties）

  • 属性是类的成员变量。
public class Person {
    private String name;
    private int age;
}

2.4.2 修饰符（Modifiers）

  • 修饰符用于控制属性和方法的访问级别。
  • 1）public：公有的，任何地方都可以访问
  • 2）private：私有的，只能在类内部访问
  • 3）protected：受保护的，在同一包内及子类中访问
  • 4）default(无修饰符)：在同一包内访问

2.5 封装（Encapsulation）

  • 封装是将数据隐藏在类内部，通过方法公开访问。
public class BankAccount {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

2.6 继承（Inheritance）

  • 继承是类继承另一个类的属性和方法。
public class Employee extends Person {
    private String jobTitle;

    public Employee(String name, int age, String jobTitle) {
        super(name, age);
        this.jobTitle = jobTitle;
    }
}

2.7 多态（Polymorphism）

  • 多态是指一个对象可以有多种形态，通常通过方法重写实现。
public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();
    }
}

2.8 重构（Refactoring）

  • 重构是改进代码的内部结构而不改变其外部行为。
// 原始代码
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public int subtract(int a, int b) {
        return a - b;
    }
}

// 重构后
public class Calculator {
    public int calculate(int a, int b, char operation) {
        switch (operation) {
            case '+': return a + b;
            case '-': return a - b;
            default: throw new IllegalArgumentException("Invalid operation");
        }
    }
}

2.9 抽象类（Abstract Class）

  • 抽象类不能实例化，只能被继承。它可以包含抽象方法（没有实现的方法）。
public abstract class Animal {
    public abstract void makeSound();
}

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

2.10 接口（Interface）

  • 接口是抽象方法的集合，类通过实现接口来定义这些方法。
public interface Drivable {
    void drive();
}

public class Car implements Drivable {
    @Override
    public void drive() {
        System.out.println("Car is driving");
    }
}

2.11 集合（Collections）

  • Java 提供了一些用于存储和操作对象的集合类，如 ArrayList、HashSet、HashMap 等。
import java.util.ArrayList;
import java.util.HashSet;
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");

        // HashSet
        HashSet<String> set = new HashSet<>();
        set.add("A");
        set.add("B");

        // HashMap
        HashMap<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
    }
}

2.12 泛型（Generics）

  • 泛型使类和方法能够操作特定类型的对象，增加了代码的重用性和安全性。
public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello");
        System.out.println(stringBox.getContent());
    }
}

2.13 委托与事件（Delegates and Events）

  • Java 中没有原生的委托和事件机制，但可以通过接口和匿名类模拟。
public interface EventListener {
    void onEvent();
}

public class Button {
    private EventListener listener;

    public void setListener(EventListener listener) {
        this.listener = listener;
    }

    public void click() {
        if (listener != null) {
            listener.onEvent();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Button button = new Button();
        button.setListener(new EventListener() {
            @Override
            public void onEvent() {
                System.out.println("Button clicked");
            }
        });

        button.click();
    }
}

3 总结

  • 上述这些是 Java 面向对象编程的基础概念和示例，通过理解和应用这些概念，可以更好地掌握和使用设计模式基础，从而更好地去进行开发。
avatar
文章
阅读
粉丝