在Java中，有三种常见的面向对象编程 (OOP) 概念：重写、重载和隐藏封装。

重写 (Override) 是指子类通过继承父类的方法，在自己的类中重新定义一遍该方法。重写发生在两个类之间，其中一个是子类，另一个是父类。

<code>public class Animal {
public void makeSound() {
System.out.println("Animal makes sound.");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow!");
}
}
public class Example {
public static void main(String[] args) {
Animal animal = new Animal();
animal.makeSound(); // 输出 "Animal makes sound."
Cat cat = new Cat();
cat.makeSound(); // 输出 "Meow!"
}
}
</code>

在上述示例中，Cat 类重写 (Override) 了 Animal 类的 makeSound() 方法。在调用 Cat 类的 makeSound() 方法时，会输出 "Meow!"，而不是 Animal 类的 makeSound() 方法中输出的 "Animal makes sound."。

重载 (Overload) 是指在同一个类中，为一个方法定义多个签名。这些签名应该有不同的参数类型和/或参数数量。当使用重载函数时，编译器会自动选择最匹配的函数进行调用。

<code>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 Example {
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
}
}
</code>

在上述示例中，Calculator 类中的 add() 方法被重载了两次，分别有两个参数和三个参数。在使用 add() 方法时，编译器会自动匹配最匹配的 add() 方法。

隐藏封装 (Encapsulation) 的意义是：把类设置为私有，使得只有类内部的代码可以访问它。这个意义被称为数据隐藏 (Data Hiding)。为了保证类中的私有成员不会被外部程序访问，我们需要以访问修饰符 private 来定义这些成员。

<code>public class Person {
private int age;
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
public class Example {
public static void main(String[] args) {
Person person = new Person();
person.setAge(20);
System.out.println("Age: " + person.getAge());
}
}
</code>

在上述示例中，Person 类中的 age 成员被隐藏封装。它只能在 Person 类中被访问，因为它被定义为私有成员。不过，通过 setAge() 和 getAge() 方法可以在外部访问 age 成员，但这些方法已经封装了对 age 成员的访问，并且设定了 get 和 set 方法的规则，所以可以在外部使用。