Java Scala之面向对象

Java Scala之面向对象：完整攻略

什么是面向对象

面向对象（Object Oriented Programming，简称OOP）是一种编程范式，主要思想是将数据和对数据的相关操作封装在一个单元中，形成对象。通过对对象的定义、组合和继承等机制实现程序的可扩展性、灵活性和可维护性。

面向对象的三大特征

封装（Encapsulation）

封装就是将程序中的某些部分抽象成单独的对象，只向外部公布特定的接口，而隐藏其余的操作。从而增强程序的模块化、安全性和可重用性。

Java示例：用private修饰符限制了变量x的访问权限

public class Example {
    private int x; // 私有变量，只能在该类中访问

    public int getX() {
        return x; // 可以通过访问器方法间接访问
    }

    public void setX(int x) {
        this.x = x; // 可以通过修改器方法修改私有变量
    }
}

Scala示例：用private修饰符限制了变量x的访问权限

class Example {
  private var x = 0 // 私有变量，只能在该类中访问

  def getX = x // 可以通过访问器方法间接访问

  def setX(value: Int): Unit = x = value // 可以通过修改器方法修改私有变量
}

继承（Inheritance）

继承就是子类（派生类）自动获得父类（基类）的所有属性和方法。通过继承可以减少代码量，提高复用性和可维护性。

Java示例：Man继承了Person的属性和方法

public class Person {
    protected String name;
    protected int age;

    public void eat(){
        System.out.println(name + " is eating");
    }
}

public class Man extends Person {
    private boolean isMarried;

    public void work(){
        System.out.println(name + " is working");
    }
}

Scala示例：Man继承了Person的属性和方法

class Person {
  protected var name: String = _
  protected var age: Int = _

  def eat(): Unit = {
    println(name + " is eating")
  }
}

class Man extends Person {
  private var isMarried: Boolean = _

  def work(): Unit = {
    println(name + " is working")
  }
}

多态（Polymorphism）

多态就是在不同的情况下，同一个方法可以表现出不同的行为。通过多态可以增强程序的可扩展性和灵活性。

Java示例：不同的动物都可以eat()

public abstract class Animal {
    public abstract void eat();
}

public class Dog extends Animal {
    public void eat() {
        System.out.println("Dog is eating");
    }
}

public class Cat extends Animal {
    public void eat() {
        System.out.println("Cat is eating");
    }
}

Scala示例：不同的动物都可以eat()

abstract class Animal {
  def eat(): Unit
}

class Dog extends Animal {
  def eat(): Unit = {
    println("Dog is eating")
  }
}

class Cat extends Animal {
  def eat(): Unit = {
    println("Cat is eating")
  }
}

面向对象的设计原则

单一职责原则（Single Responsibility Principle）

单一职责原则就是一个对象只负责一项职责，避免职责耦合和职责扩散。这样可以增强代码的可维护性和可扩展性。

Java示例：Person只负责个人信息的存取，而不负责其他逻辑

public class Person {
    private String name;
    private int age;
    private String address;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }
}

Scala示例：Person只负责个人信息的存取，而不负责其他逻辑

class Person(val name: String, val age: Int, val address: String)

开闭原则（Open Closed Principle）

开闭原则就是开放已有的代码对扩展，关闭对修改。这样可以避免因改动已有代码而带来的风险和不必要的成本。

Java示例：Shape和Rectangle都实现了Area接口，当要增加Circle时，不需要改动已有代码，只需要增加新的类即可。

public interface Area {
    public double getArea();
}

public class Shape implements Area {
    public double getArea() {
        // 计算图形的面积
    }
}

public class Rectangle implements Area {
    private double width;
    private double height;

    public double getArea() {
        return width * height;
    }
}

public class Circle implements Area {
    private double radius;

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

Scala示例：Shape和Rectangle都实现了Area接口，当要增加Circle时，不需要改动已有代码，只需要增加新的类即可。

trait Area {
  def getArea: Double
}

class Shape extends Area {
  def getArea: Double = {
    // 计算图形的面积
  }
}

class Rectangle(val width: Double, val height: Double) extends Area {
  def getArea: Double = width * height
}

class Circle(val radius: Double) extends Area {
  def getArea: Double = Math.PI * radius * radius
}

里氏替换原则（Liskov Substitution Principle）

里氏替换原则就是子类能够替换父类，在程序中使用父类对象的地方都能够使用子类对象，不产生意外的行为。这样可以增强程序的可扩展性和灵活性。

Java示例：Rectangle是Shape的子类，可以替换Shape对象

public class Shape {
    public double getArea() {
        // 计算图形的面积
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public double getArea() {
        return width * height;
    }
}

Scala示例：Rectangle是Shape的子类，可以替换Shape对象

class Shape {
  def getArea: Double = {
    // 计算图形的面积
  }
}

class Rectangle(val width: Double, val height: Double) extends Shape {
  override def getArea: Double = width * height
}

总结

面向对象是一种重要的编程范式，具有封装、继承和多态三大特征。在面向对象的设计中，要遵循单一职责原则、开闭原则和里氏替换原则等设计原则。通过这些原则可以增强程序的可维护性、可扩展性和灵活性，提高代码的质量和可靠性。