Java的四个主要面向对象编程概念

Java是一种面向对象编程语言，面向对象编程具有许多优点，如代码的灵活性、可扩展性和易维护性。在Java中，有四个主要的面向对象编程概念。

1. 封装

封装是指将数据和方法组合在一起，形成一个类。类中的数据被称为属性，方法被称为方法。封装的目的是为了保护数据，防止外部程序的误操作导致数据出错。封装还能帮助我们隐藏实现细节，简化复杂性。在Java中，我们使用关键字public/private/protected来控制类的访问权限。

下面是一个简单封装的实例：

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(25);
        System.out.println("姓名：" + person.getName() + " 年龄：" + person.getAge());
    }
}

在上面的实例中，Person类中的数据name和age被私有化了，外部无法直接访问。我们通过public的getter和setter方法来访问和修改数据。

2. 继承

继承是指一个类可以派生出子类，子类可以继承父类的属性和方法，并且可以在此基础上进行扩展。继承的主要作用是提高代码的复用性和可扩展性。在Java中，我们使用关键字extends来实现继承。

下面是一个简单的继承实例：

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void bark() {
        System.out.println("汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出："狗吃骨头"
        dog.bark(); // 输出："汪汪叫"
    }
}

在上面的实例中，Dog类继承了Animal类，它不仅可以使用Animal类的方法，还能在此基础上进行扩展，添加新的方法和属性。

3. 多态

多态是指同一种数据类型可以以多种形式表示，实现方式是子类可以以其父类的类型进行实例化。多态的主要作用是提高代码的灵活性和可扩展性。在Java中，多态的实现方式有两种：方法重载和方法重写。

方法重载的示例：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

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

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.add(1, 2)); // 输出："3"
        System.out.println(calculator.add(1, 2, 3)); // 输出："6"
    }
}

在上面的示例中，Calculator类实现了方法重载，它包含两个add方法，分别接受两个整数和三个整数，这两个方法都可以被称为add方法。

方法重写的示例：

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        animal.eat(); // 输出："动物吃东西"
        dog.eat(); // 输出："狗吃骨头"
    }
}

在上面的示例中，Animal类中的eat方法被Dog类进行重写，当我们用Dog类的实例来调用eat方法时，会执行Dog类中的eat方法。

4. 接口

接口是指类与类之间的一种协议，规定了类的公共方法和属性。接口能够实现类之间的解耦，提高了系统的灵活性和可扩展性。在Java中，我们使用关键字interface来定义接口。

下面是一个简单的接口实例：

public interface Shape {
    double getArea();
    double getPerimeter();
}

public class Circle implements Shape {
    private double radius;

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

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

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

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

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

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

    public double getPerimeter() {
        return 2 * (width + height);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(2, 3);
        System.out.println("圆的面积为：" + circle.getArea() + " 周长为：" + circle.getPerimeter());
        System.out.println("矩形的面积为：" + rectangle.getArea() + " 周长为：" + rectangle.getPerimeter());
    }
}

在上面的实例中，Shape接口定义了两个方法getArea和getPerimeter，Circle类和Rectangle类分别实现了Shape接口，并重写了其中的方法。我们可以用Shape类型的引用来引用这两个类的实例，调用getArea和getPerimeter方法来计算它们的面积和周长。