java最重要的特征就是面向对象思想，面向对象三大体现是封装、继承、多态。
1.封装：把所有具有共性属性的对象封装成一个类，这个类中包括他们共有的属性和功能，使用者不需要知道这些功能是怎样实现的，只需要知道怎样用这些功能。就好比如一台电视机对于使用者来说，绝大部分人不知道电视机内部是怎么工作的，但是几乎每个人都会用，这就是封装。下面看一个程序：
package com.dr.test3;
class Per{
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 void eat(){
System.out.println(name+"正在吃饭***");
}
public void sleep(){
System.out.println(name+"正在睡觉***");
}
}
public class Demo02 {
public static void main(String args[]){
Per p1=new Per();
Per p2=new Per();
p1.setName("张三");
p1.setAge(20);
p2.setName("李四");
p2.setAge(21);
p1.eat();
p2.sleep();
}
}
程序运行结果是：
张三正在吃饭***
李四正在睡觉***
在这个程序新建了一个Per类，在Per类中有两个属性name和age，有两个方法sleep和eat方法。又新建了一个测试类Demo02，在这个类中我们只调用sleep和eat这两个方法，但我们并不知道它是怎样实现的。这就是封装。
2.继承：一个孩子身上的优点可以说是继承了其父亲和母亲的优点，但并不是他父母所有的优点这个孩子都继承了，并且这个孩子还有可能有其父母没有的优点。java类也是这样，子类可以继承父类的非私有的方法和属性，并且还可以拥有自己独特的属性和方法。下面看程序：
package com.dr.test4;
class A{
public String name;
public int age;
public void fun(){
System.out.println("玩***");
}
}
class B extends A{
String school;
void fun1(){
System.out.println("好好玩***");
}
}
public class Demo01{
public static void main(String args[]){
B p1=new B();
p1.name="张三";
p1.age=20;
p1.school="南京大学";
p1.fun();
p1.fun1();
}
}
程序运行结果是：
玩***
好好玩***
在这个程序新建一个A类，A类中有两个声明public的属性name和age，又一个声明public的方法fun()。新建一个继承A类的B类，那么B类就会继承A类中的name、age属性和fun()方法。如果将A类中的属性声明为private就会出现编译错误，错误提示为‘属性不可见’，如果fun()方法声明为private也会提示‘方法不可见’。在B类中，又有自己的school属性和fun1()方法。
3.多态：多态主要体现在方法的重载和方法的复写。
重载就是同一个类中又好多方法，这些方法名字相同但列表参数（数据类型和参数个数）不同，这就是方法的重载。
看下面程序：
package com.dr.test4;
class YuanGong{
String name;
int age;
float salary;
String depart;
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 float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
public String getDepart() {
return depart;
}
public void setDepart(String depart) {
this.depart = depart;
}
public YuanGong(String name,int age){
this.setName(name);
this.setAge(age);
this.setSalary(1000);
this.setDepart("后勤");
}
public YuanGong(String name,int age,float salary,String depart){
this.setName(name);
this.setAge(age);
this.setSalary(salary);
this.setDepart(depart);
}
public void print(){
System.out.println("姓名:"+'\n'+name+'\n'+"年龄:"+'\n'+
age+'\n'+"薪水:"+'\n'+salary+'\n'+"部门:"+'\n'+depart);
}
}
public class Demo02 {
public static void main(String args[]){
YuanGong a=new YuanGong("张三",20);
YuanGong b=new YuanGong("李四",21,2000,"技术");
a.print();
b.print();
}
}
程序运行结果是：
姓名:
张三
年龄:
20
薪水:
1000.0
部门:
后勤
姓名:
李四
年龄:
21
薪水:
2000.0
部门:
技术
上面程序新建一个YuanGong类，类中定义了两个构造函数YuanGong，但两者的列表参数不同。在测试类Demo02中建立两个YuanGong对象a和b，a对象使用两参的进行初始化，b对象使用四参的进行初始化。
复写就是子类和父类又同名的方法并且列表参数也相同，那么子类对象调用这个方法时就会复写或是隐藏父类的方法。下面看程序：
package com.dr.test4;
class A{
public String name;
public int age;
public void fun(){
System.out.println("父类中方法***");
}
}
class B extends A{
String school;
public void fun(){
System.out.println("子类中的方法***");
}
}
public class Demo01{
public static void main(String args[]){
B p1=new B();
p1.name="张三";
p1.age=20;
p1.school="南京大学";
p1.fun();
}
}
程序运行结果为：
子类中的方法***
此程序中父类A和子类B中又同名的方法fun()，B类对象p1调用fun()方法时就会覆盖A类中的fun()方法，而去调用自己本身的fun()方法。