以Java爲例，闡釋面向對象的特點
封裝
private最能體現封裝的特點，使外部不能隨便訪問
public class Fengzhuang
{
public static void main(String args[])
{
Person p1=new Person();
p1.setSno(99001);
System.out.println (p1.getSno());
p1.setSno("99001x");
System.out.println (p1.getSno());
}
}
class Person
{
//情況例子：本來是數字，後來想改成String
//private int sno;
//變爲
private String sno;
//sno面向外部的接口
/*public int getSno()
{
return sno;
}*/
//變爲
public String getSno()
{
return sno;
}
public void setSno(int sno)
{
this.sno=sno+"";
}
public void setSno(String sno)
{
this.sno=sno;
}
}
重載和重寫
重載利用了方法可以有不同種類和數量的特性：方法名相同但參數的種類和數量不完全相同。注：返回值不同不叫重載。
重寫：子類對父類方法的重寫，子類重寫一個與父類方法名字相同的方法。返回值類型必須相同，否則不構成重寫，而且如果名字相同會出錯（無法覆蓋）。如果父類方法返回值類型是對象類型，子類重寫方法的返回值可以是父類方法返回值的子類。
父類中的final方法不能重寫。
可以直接通過子類對象調用父類的方法（方法未在子類中被重寫）
注：重寫方法權限不能比父類方法訪問權限低（如父類位public，子類爲默認爲不可以的）
如果訪問權限和返回值類型都不相同，僅名字相同，則不構成重寫
構成重寫的異常拋出問題，父類的方法拋出的異常必須能包含子類方法拋出的異常（但調用子類方法所在的方法拋異常類型與父類拋出的異常類型無關），父類拋子類不拋也是可以的。
import java.io.IOException;
public class Fengzhuang
{
public static void main(String args[]) throws IOException
{
Son s=new Son();
s.kk();
}
}
class Person
{
public void kk() throws Exception
{
System.out.println ("Person kk");
}
}
class Son extends Person
{
/*對重寫方法：
*子類方法拋異常父類方法必須拋，且要把子類方法的異常包含在內（子類拋出的異常必須比父類更嚴謹、仔細）
*父類方法有異常對子類方法沒有限制
*調用子類方法所在的位置要拋的異常種類與父類方法拋出的異常沒有關係，只與子類有關係
**/
public void kk() throws IOException//重寫父類的方法
{
System.out.println ("Son kk");
return ;
}
}
多態
父類引用指向子類對象：Father f = new Son();
多態的作用：借用子類中重寫的父類的方法（抽象類和接口中被覆蓋的方法），僅包括方法，不包括變量
可以用抽象類或接口的引用指向其子類的引用，從而可以使用抽象類或接口中被覆蓋的方法，變量則還會使用父類中的值
public class Fengzhuang
{
/*多態：父類引用指向子類對象
*可以在某些方面解決接口或抽象類無法實例對象（只能有引用）的問題
**/
public static void main(String args[])
{
Son s=new Son();
System.out.println (s.x+s.y);//若子類中沒有名字和父類相同的元素，會直接使用父類中的元素
Father f=s;//父類引用指向子類對象
f.kk();//方法看對象
f=new Son2();
f.kk();
System.out.println (f.y+";"+f.s);//成員變量看引用，用的是父類的變量,輸出9;0(用的是父類的值)
FF ff=f;
ff.kk();
System.out.println (ff.x);//輸出0
}
}
abstract class FF
{
/*
*可以用抽象類或接口的引用指向其子類的引用，
*從而可以使用抽象類或接口中被覆蓋的方法，
*變量則還會使用父類中的值*/
int x=0;
abstract void kk();
}
class Father extends FF
{
int x=6;//若子類中沒有出現名字類型相同的
int y=9;
String s="0";
public void kk()
{
System.out.println ("father.kk");
}
}
class Son extends Father
{
long y=19;
String s="1";
public void kk()
{
System.out.println ("Son .kk");
}
}
class Son2 extends Father
{
long y=199;
String s="2";
public void kk()
{
System.out.println ("Son2 .kk");
}
}
重載
同一個類中，名字相同，參數序列不同的方法。返回值不同不構成重載。一個類中不能存在名字和參數序列都相同的兩個方法，即使返回值不同。
構造器
和類名相同，沒有返回類型，可帶參數，在每次new 對象時執行，只是引用時不會調用
沒有構造其實，系統會自動生成空參構造器，但如果自己寫了帶參的，則不會自動生成再空參的
public class Gouzao
{
//構造器
public static void main(String args[])
{
new SS();
/*輸出：Father
Son
SS
生成子類對象時，會先走父類的構造器（空參），
然後再走自己的構造器。*/
new SSSS();
/*當父類沒有空參構造器時，直接繼承會報錯，
*要在子類構造器中調用父類的帶參構造器super(int x,....);
*因爲默認子類構造器中存在且在第一行有super();
*
*或者寫this();調用自己的構造器。(適用於有空參構造器，並且有多個構造器（重載）的)
**/
}
}
class Father
{
public Father()
{
System.out.println ("Father");
}
}
class Son extends Father
{
public Son()
{
System.out.println ("Son");
}
}
class SS extends Son
{
public SS()
{
System.out.println ("SS");
}
}
class SSS extends SS
{
public SSS(int a)
{
System.out.println ("SSS");
}
}class SSSS extends SSS
{
public SSSS()
{
super(5);
System.out.println ("SSSS");
}
public SSSS(int a)
{
//super(5);
this();
System.out.println ("SSSS");
}
}
靜態成員，非靜態成員，構造器在創建對象時的執行順序
public class OO
{
//構造器
/*靜態成員變量也會先走父類的
*靜態的會最先執行
*類成員和構造器在同一等級，看先後位置決定執行順序，先父後子
**/
public static void main(String args[])
{
new Son();
/*輸出：父類靜態
子類靜態
父類構造器
子類構造器*/
/*輸出：父類靜態
子類靜態
父類非靜態
父類構造器
子類非靜態
子類構造器*/
}
}
class Father
{
Pr p2=new Pr("父類非靜態成員變量");
static Pr p1=new Pr("父類靜態成員變量");
public Father()
{
System.out.println ("父類構造器");
}
}
class Son extends Father
{
Pr p2=new Pr("子類非靜態成員變量");
static Pr p1=new Pr("子類靜態成員變量");
public Son()
{
System.out.println ("子類構造器");
}
}
class Pr
{
public Pr(String s)
{
System.out.println (s);
}
}
返回類型
方法的返回類型只能低於聲明的返回類型（聲明父類，返回子類）