Java面向对象基础知识之封装,继承,多态和抽象

首先，我们需要了解什么是面向对象编程（Object-oriented Programming，OOP），面向对象编程是一种编程模式，其核心思想是将数据和操作数据的行为封装到一个对象中，从而实现抽象、封装、继承、多态等特性。Java是一门典型的面向对象编程语言，带有成熟的面向对象特性。Java面向对象基础知识主要包含以下几个方面：封装、继承、多态和抽象。下面我们分别进行讲解：

封装

封装是一种将数据和操作数据的方法放在一起的思想。它可以隐藏对象的内部细节，使外部无法直接触及和修改内部数据，从而保证了数据的安全性和完整性。在Java中，封装通过访问修饰符来实现。通常将属性声明为 private，提供公有的 getter/setter 方法来访问私有属性，以此来控制属性的访问，保证了数据的安全性。下面是一个示例代码：

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;
    }
}

在上面的示例中，定义了一个Person类，其中name和age属性被设置成了private，不允许外部直接访问。通过与公共的getter和setter方法一起使用，可以很安全地操作私有属性。

继承

继承是一种面向对象编程中重要的概念，它是指子类可以继承父类的属性和方法，并且还可以扩展新的属性和方法。在Java中，使用extends关键字来实现继承。下面是一个示例代码：

public class Animal {
    protected String name;

    public void eat() {
        System.out.println("I'm eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Wang!Wang!");
    }
}

在上面的示例中，定义了一个Animal类，其中包含了name属性和一个eat方法。在Dog类中通过使用extends关键字，让它继承了Animal类的属性和方法，并增加了bark方法。

多态

多态是一种允许子类对象在不同的情况下表现出不同的特性的概念。Java中的多态有两种形式：运行时多态和编译时多态。运行时多态通常是通过方法重写来实现，编译时多态通常是通过向上转型实现。下面是一个运行时多态的示例代码：

public class Animal {
    public void eat() {
        System.out.println("I'm eating.");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("I'm eating Dog Food.");
    }

    public void bark() {
        System.out.println("Wang!Wang!");
    }
}

public class Person {
    public void feed(Animal animal) {
        animal.eat();
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Animal animal = new Animal();
        Dog dog = new Dog();

        person.feed(animal); // I'm eating.
        person.feed(dog); // I'm eating Dog Food.
    }
}

在上面的示例中，定义了一个Animal类和Dog类，它们都有一个eat方法，其中Dog类的eat方法被重写了并输出了不同的内容。Person类中有一个feed方法，接受一个Animal对象类型的参数。在Test类中，分别传递了Animal对象和Dog对象并调用了feed方法，在运行时多态的作用下，animal.eat()执行Animal的eat方法，而dog.eat()会执行Dog的eat方法。

抽象

抽象是面向对象编程中一个非常重要的概念，用于定义接口和抽象类。在Java中，可以通过abstract关键字来定义抽象类和抽象方法。抽象类不能被实例化，只能被继承，并且可以包含非抽象的方法。下面是一个抽象类的示例代码：

public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    public abstract void move();
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void move() {
        System.out.println(name + " is running.");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("Tom");
        animal.move(); // Tom is running.
    }
}

在上面的示例中，定义了一个抽象类Animal，其中定义了一个抽象方法move。抽象方法没有方法体，子类必须重写该方法。在Dog类中重写了move方法。在Test类中，实例化了一个Dog对象，并将其赋值给Animal类型变量，通过这种方式实现了向上转型。最后调用animal.move()方法，输出了正确的结果。

总结：

在Java中，面向对象编程的基础知识主要包含封装、继承、多态和抽象。理解并掌握这些概念以及对应的语法是非常重要的程序员的基本素养。