详细理解JAVA面向对象的封装,继承,多态,抽象

JAVA面向对象的基本概念

在Java中，“一切皆对象”，Java程序就是通过面向对象的编程思想来实现的。面向对象的编程思想的核心概念主要包括封装、继承、多态和抽象。这些概念描述了Java对象与类之间的关系和相互作用。

封装

封装是指将数据和行为包装在一起，形成一个类。封装的主要目的是隐藏类的实现细节，只对外部暴露必要的接口，从而达到数据的安全性。

在Java中，我们通过访问控制修饰符(private、public、protected)来实现封装。将方法或变量定义为private时，就只能在本类中访问，而其他类则无法直接访问。继承后也不能访问，只能访问继承自基类的public和protected变量和方法。

示例1：一个简单的封装实例

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

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        System.out.println(person.getName() + "," + person.getAge());
    }
}

示例2：封装的一个好处就是细节的隐藏不会对其他模块造成影响

public class Timer {
    private final int interval;
    private long lastTick;

    public Timer(int interval) {
        this.interval = interval;
        this.lastTick = System.currentTimeMillis();
    }

    public boolean isTick() {
        long current = System.currentTimeMillis();
        if(current - lastTick>= interval) {
            lastTick = current;
            return true;
        }
        return false;
    }
}

public class Test {
    public static void main(String[] args) {
        Timer t = new Timer(1_000);
        for(int i=0; i<10; i++) {
            System.out.println(t.isTick());
            try { Thread.sleep(500);} catch (InterruptedException e) {}
        }
    }
}

继承

继承是指一个类可以集成另一个类的属性和方法。父类也称为基类或超类，子类称为派生类。继承的主要目的是提高代码的重用性，减少代码量。

在Java中，我们通过关键词extends来实现继承。子类可以重写父类中的方法，同时也可以访问父类中的public和protected函数和变量。

示例1：继承的基本实例

class Animal {
    private String name;

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

    public String getName() {
        return name;
    }

    public void move() {
        System.out.println(name + " can move");
    }
}

class Bird extends Animal {
    public void fly() {
        System.out.println(getName() + " can fly");
    }
}

public class Test {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.setName("鹦鹉");
        bird.move();
        bird.fly();
    }
}

示例2：继承的一个好处就是可以避免代码的重复

class Animal {
    private String name;

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

    public String getName() {
        return name;
    }

    public void move() {
        System.out.println(name + " can move");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println(getName() + " barks");
    }
}

class Cat extends Animal {
    public void meow() {
        System.out.println(getName() + " meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.move();
        dog.bark();

        Cat cat = new Cat();
        cat.setName("小花");
        cat.move();
        cat.meow();
    }
}

多态

多态是指同一个方法可以根据对象的不同，表现出不同的行为。多态有两种体现方式：方法重载和方法覆盖。

方法重载是指同一个类中可以定义多个方法名相同，但参数类型、个数或顺序不同的方法，也称为编译时多态。

方法覆盖是指子类重写父类中定义的方法，使得同名方法可以根据对象类型的不同，表现出不同的行为，也称为运行时多态。

示例1：多态的基本实现

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

class Cat extends Animal {
    public void sound() {
        System.out.println("喵喵");
    }
}

class Dog extends Animal {
    public void sound() {
        System.out.println("汪汪");
    }
}

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

示例2：多态的一个好处就是可以将对象看作它所实现的接口或父类来使用

interface Runnable {
    public void run();
}

class Car implements Runnable {
    public void run() {
        System.out.println("Car is running");
    }
}

class Person implements Runnable {
    public void run() {
        System.out.println("Person is running");
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable[] list = new Runnable[2];
        list[0] = new Car();
        list[1] = new Person();

        for(Runnable r : list) {
            r.run();
        }
    }
}

抽象

抽象是指将具体的实现细节抽象为通用的抽象类或接口。Java中可以使用abstract关键字来定义抽象类和抽象方法。

抽象类是指含有抽象方法的类。抽象方法是指只声明，而没有具体实现的方法。抽象类不能被实例化，只能被继承。继承的子类必须实现抽象类中的所有抽象方法，否则也必须被定义为抽象类。

接口是指具有方法签名，但没有实现的类。接口定义了一组规范，其实现类必须实现接口中的所有方法。接口中的方法默认为public，同时没有构造器和数据成员。

示例1：抽象类的基本实现

abstract class Shape {
    public abstract double area();
}

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

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

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

public class Test {
    public static void main(String[] args) {
        Shape shape = new Rectangle(2, 3);
        System.out.println("The area of rectangle is " + shape.area());
    }
}

示例2：接口的基本实现

interface Runnable {
    public void run();
}

class Car implements Runnable {
    public void run() {
        System.out.println("Car is running");
    }
}

public class Test {
    public static void main(String[] args) {
        Runnable run = new Car();
        run.run();
    }
}

以上就是JAVA面向对象的封装、继承、多态和抽象的完整攻略。