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()方法。