1. 類的繼承

繼承的意義：

當一個類A繼承了一個已存在的類B后，類A就用于了類B所有的非PRivate的屬性和方法，但同時類A還可以根據需要，添加新的方法和屬性。

在Java語言中，一個類可以擁有多個子類，但是一個子類只能擁有一個父類。

如何定義子類：

class 子類名 extends 父類名

{}

public class ExtendsDemo1 {    Employee e;    Manager m;        public ExtendsDemo1()    {        e=new Employee("Wnag Xiao Yue", 3000.00, "2005/05/20");        System.out.println("Name: "+ e.getName() + "; Salary: "+ e.getSalary()+ "; Hireday: "+e.getHireDay()+"/n");                m=new Manager("Zhao XS", 8000.00, "2004/6/2", 4000.00, 20);        System.out.println("Name: "+ m.getName() + "; Salary: "+ m.getSalary()+ "; Hireday: "+m.getHireDay() + "; Bonus: "+m.getBonus()+"; Holidays: "+m.getHolidays());            }    public static void main(String[] args) {        new ExtendsDemo1();    }}class Employee{    String name;    double salary;    String hireDay;        public Employee(String name, double salary, String hireDay)    {        this.name=name;        this.salary=salary;        this.hireDay=hireDay;        System.out.println("I'm Employee");    }        public String getName()    {        return name;    }    public String getHireDay()    {        return hireDay;    }    public double getSalary()    {        return salary;    }}class Manager extends Employee{    private double bonus;    private int holidays;        public Manager(String name, double salary, String hireDay, double bonus, int holidays)    {        super(name, salary, hireDay);   //調用父類構造方法        this.bonus=bonus;        this.holidays=holidays;        System.out.println("I'm Manager");    }        public double getBonus()    {        return bonus;    }        public int getHolidays()    {        return holidays;    }}

I'm EmployeeName: Wnag Xiao Yue; Salary: 3000.0; Hireday: 2005/05/20

I'm EmployeeI'm ManagerName: Zhao XS; Salary: 8000.0; Hireday: 2004/6/2; Bonus: 4000.0; Holidays: 20

覆蓋父類中的方法（重載：方法名、參數、返回值均不變， 只有方法體發生了變化）：

public class ExtendsDemo1 {    Employee e;    Manager m;        public ExtendsDemo1()    {        e=new Employee("Wnag Xiao Yue", 3000.00, "2005/05/20");        e.getInfo();        System.out.println("Name: "+ e.getName() + "; Salary: "+ e.getSalary()+ "; Hireday: "+e.getHireDay()+"/n");                m=new Manager("Zhao XS", 8000.00, "2004/6/2", 4000.00, 20);        m.getInfo();        System.out.println(m.getSalary());        System.out.println("Name: "+ m.getName() + "; Hireday: "+m.getHireDay() + "; Bonus: "+m.getBonus()+"; Holidays: "+m.getHolidays());            }    public static void main(String[] args) {        new ExtendsDemo1();    }}class Employee{    String name;    double salary;    String hireDay;        public Employee(String name, double salary, String hireDay)    {        this.name=name;        this.salary=salary;        this.hireDay=hireDay;    }        public void getInfo()    {        System.out.println("I'm Eployee");    }    public String getName()    {        return name;    }    public String getHireDay()    {        return hireDay;    }    public double getSalary()    {        return salary;    }}class Manager extends Employee{    private double bonus;    private int holidays;        public Manager(String name, double salary, String hireDay, double bonus, int holidays)    {        super(name, salary, hireDay);   //調用父類構造方法        this.bonus=bonus;        this.holidays=holidays;    }        public void getInfo()    {        System.out.println("I'm Manager");    }    public double getSalary()    {        System.out.print("Manager Salary is: ");        return salary;    }    public double getBonus()    {        return bonus;    }        public int getHolidays()    {        return holidays;    }}

I'm EployeeName: Wnag Xiao Yue; Salary: 3000.0; Hireday: 2005/05/20

I'm ManagerManager Salary is: 8000.0Name: Zhao XS; Hireday: 2004/6/2; Bonus: 4000.0; Holidays: 20

this關鍵字的使用：

this關鍵字就好像創建一個虛擬的類對象實例，在定義類的時候，就提前使用其對象實例。

注意：由于this是指向當前類實例的一個引用，因此只能在實例方法的定義中使用。而在類方法（static型靜態方法）中，不能使用this關鍵字。

public class ThisDemo {    private String name;        public ThisDemo(String name)    {        this.name=name;    }        public String getName()    {        return name;    }        public void show()    {        String str=this.getName();        System.out.println(str);    }        public Object getObject()    {        return this;    }}

super的使用：

子類繼承父類后，若要在子類中直接調用父類的構造方法，就必須使用super（...）語句，注意一下兩點：

• 若要在子類構造方法中調用父類構造方法，super（）語句必須放在子類構造方法中的第一行；
• 不能在子類構造方法中同時調用this(...)和super(...)語句，因為這兩條語句都必須位于子類構造方法中的第一行

2. 抽象類與接口

抽象類和抽象方法：

abstract關鍵字是抽象修飾符，只能用于修飾類和方法。

• 抽象類：沒有具體實例對象的類。簡單的說，抽象類就是一種經過優化的概念組織方式，把所要描述的事物的共性抽象出來，使得所有的概念層次分明、簡潔
• 抽象方法：在定義的時候只有方法的聲明，而沒有方法體的實現部分。也就是說，抽象方法僅包含訪問修飾符、返回類型、方法名及參數表，而不包含方法體“{}”中的內容。至于方法的實現部分，需要在繼承該抽象方法的子類中，進行定義。

歸納總結后，使用抽象類和抽象方法要注意一下4點：

• abstract抽象類不能創建對象，必須通過子類繼承后，有子類來創建對象
• abstract抽象方法只允許方法聲明，不允許方法實現
• abstract抽象類中，可以沒有抽象方法，也可以有一個或多個抽象方法
• 若一個類中含有abstract抽象方法，那么這個類必須被聲明為抽象類

public class AbstractDemo {    Employee1 e;        public AbstractDemo()    {        e=new Employee1("Wnag Xiao Yue", 3000.00, "2005/05/20", 24);        e.getInfo();        System.out.println("Age: "+e.getAge());        System.out.println("Name: "+ e.getName() + "; Salary: "+ e.getSalary()+ "; Hireday: "+e.getHireDay()+"/n");    }    public static void main(String[] args) {        new AbstractDemo();    }}abstract class People{    String name;    int age;        abstract String getName();    abstract int getAge();}class Employee1 extends People{    double salary;    String hireDay;        public Employee1(String name, double salary, String hireDay, int age)    {        this.name=name;        this.salary=salary;        this.hireDay=hireDay;        this.age=age;    }        public void getInfo()    {        System.out.println("I'm Eployee");    }    public String getName()    {        return name;    }    public int getAge()    {        return age;    }    public String getHireDay()    {        return hireDay;    }    public double getSalary()    {        return salary;    }}

I'm EployeeAge: 24Name: Wnag Xiao Yue; Salary: 3000.0; Hireday: 2005/05/20

什么是接口：

Java語言中的接口不同于一般的類，通常稱為接口類，是用來描述類的功能的。在接口類中，定義了抽象的方法和常量，形成一個屬性集合，該屬性集合代表了一組功能的實現。在Java語言中，一個類只能繼承自一個父類；但是一個類可以實現多個接口，因此使用接口主要是為了實現類的多重繼承功能。

如何定義接口：

[public] interface 接口名 [extends 父類接口]

{

　　//借口體

　　//常量聲明

　　[public] [static] [final] 常量類型 常量名 = 常量值；

　　//抽象方法聲明

　　[public] [abstract] 返回類型 方法名（參數列表） [throw 異常列表]

}

在定義接口類的時候需要注意一下幾點：

• 與定義類相似，定義的接口類也具有繼承性。定義一個接口的時候，可以通過extends關鍵字來讓定義的接口繼承自一個已經存在的父類接口
• 接口體由兩部分組成，一部分是對接口屬性的聲明，另一部分是對接口中方法的聲明。接口中的屬性都是用final修飾的常量；而接口中的方法都是用abstract修飾的抽象方法，在接口類中，只能給出這些抽象方法的方法名、返回值、參數列表，而不能定義方法體
• 根據編程的習慣，接口類的名字，一般都已大寫字母“I”開頭

public interface IEmployee{    public static final double prize=1000.00;    public abstract void addSalary();}

實現接口：

在定義好接口后，就可以創建一個類來實現該接口類，同時在實現類中，完成接口類中抽象方法的定義。

public class UseIEmployee {    Employee2 e;        public UseIEmployee()    {        e=new Employee2("Wnag Xiao Yue", 3000.00, "2005/05/20");        e.addSalary(2);        e.getInfo();        System.out.println("Name: "+ e.getName() + "; Salary: "+ e.getSalary()+ "; Hireday: "+e.getHireDay()+"/n");    }        public static void main(String[] args) {        new UseIEmployee();    }}class Employee2 implements IEmplyee1{    private String name;    private double salary;    private String hireDay;        public Employee2(String name, double salary, String hireDay)    {        this.name=name;        this.salary=salary;        this.hireDay=hireDay;    }        public String getName()    {return name;}        public void getInfo()    {System.out.println("I'm Employee");}        public double getSalary()    {return salary;}        public String getHireDay()    {        return hireDay;    }        public void addSalary(int n)    {        salary+=prize*n;    }}interface IEmplyee1 {        public static final double prize = 1000.00;    public abstract void addSalary(int n);}

I'm EmployeeName: Wnag Xiao Yue; Salary: 5000.0; Hireday: 2005/05/20

3. 內部類和匿名類

什么是內部類：

內部類就是定義在其他類內部的類，而內部類所在的類一般稱為外部類。根據內部類在外部類中所處的位置，一般又分為定義在方法體的內部類以及定義在方法體外的成員內部類。同時，定義在方法體內的內部類又可以分為兩種，分別是有實例名稱的內部類和無實例名稱的匿名內部類。

如何使用內部類：

（1）對于定義在方法體外的內部類（成員內部類）

又可以分為以下兩種情況：

• 定義在方法體外的成員內部類：如同其他類成員一樣，也是附屬于類的，可以通過外部類的實例來引用，即先創建一個外部類的實例，再通過該外部類的對象實例來創建內部類實例。語法格式有以下兩種

new 外部類構造方法().內部類構造方法();

外部類對象實例.new 內部類構造方法();

public class InnerClassDemo1 {        private String s="World";        class InnerClass{         public InnerClass()         {             System.out.println("This is Inner Class constructor");         }                  //內部類對象能夠訪問其所在外部類的全部屬性，包括私有屬性         public void showMessage(String str)         {             System.out.println("Hello "+s+","+str);         }    }    public static void main(String[] args) {        InnerClass i1=new InnerClassDemo1().new InnerClass();        i1.showMessage("Lilian");        System.out.println();                InnerClassDemo1 demo=new InnerClassDemo1();        InnerClass i2=demo.new InnerClass();        i2.showMessage("Kira");    }}

This is Inner Class constructorHello World,Lilian

This is Inner Class constructorHello World,Kira

• 對于靜態內部類的引用：靜態內部類的附屬于外部類的，而不附屬于外部類的實例，因此不需要通過外部類的對象實例來創建內部類對象，直接通過外部類名就可以實現。語法格式如下：

new 外部類名.內部構造方法();

public class InnerClassDemo2 {        private static String s= "World";        static class InnerClass{        public InnerClass()        {            System.out.println("This is inner class constructor");        }                public void showMessage(String str)        {            System.out.println("Hello "+ s  +","+str);        }    }    public static void main(String[] args) {        InnerClass i=new InnerClassDemo2.InnerClass();        i.showMessage("Lilian");    }}

This is inner class constructorHello World,Lilian

（2）對于定義在方法體內的內部類

由于附屬于方法體，所以只能在方法體中創建對象實例，并且創建的實例也只能在方法體中被訪問。所創建的對象實例的生命周期與方法體相同，當方法結束后，對象也就隨之消失。

public class InnerClassDemo3 {    private String str="World";        public InnerClassDemo3()    {        showMessage();    }        public void showMessage()    {        System.out.println("Now you are in method!");                class InnerClass{            public InnerClass()            {                System.out.println("This is inner class constructor");            }                        public void showMesage()            {                System.out.println("Hello "+ str+"!");            }        }                InnerClass i=new InnerClass();        i.showMesage();                System.out.println("Method end!");    }    public static void main(String[] args) {        new InnerClassDemo3();    }}

Now you are in method!This is inner class constructorHello World!Method end!

什么是匿名類：

在創建類的對象的時候，會有兩種方式，第一種方式是創建對象后，將該對象保存在一個對象變量中，如下所示。

類名 對象名 = new 類構造方法();

另一種方式就是所謂的匿名類方式創建對象。使用匿名類方式創建對象時，并不將創建的對象保存在對象變量中，程序會根據創建對象的構造方法中的操作，來運行程序，當程序運行結束后，該對象的生命周期也就結束了。

new 類構造方法();

使用內部類需要注意的問題：

• Java程序中，對于內部類的繼承沒有限制，與普通的類一致，滿足單繼承。同時對內部類的嵌套層次也沒有限制
• 同一般類一樣，可以實現接口
• 非靜態的內部類可以看作是外部類中的普通方法，對整個類具有訪問權限，可以訪問其所在外部類的所有屬性。包括private私有屬性。但是非靜態的內部類中不能包含static類型的屬性。非靜態的內部類可以被不同訪問修飾符修飾，也可以被其他外部類的成員函數訪問。
• 靜態內部類可以看作是外部類中的static方法，只能訪問聲明為static的變量，以及調用static的方法
• 定義在方法體中的內部類，可以看作是方法中的局部變量，可以訪問外部類中的所有屬性，包括private私有屬性
• 定義在方法體中的內部類，可以訪問許哦在方法中被聲明為final型的局部變量
• 定義在方法體中的內部類，不能用認可訪問修飾符修飾，同時也不能使用static修飾符修飾

實戰練習：

簡單模擬一個雇員工資管理的程序系統。整個系統由5個源文件組成：

• IEmployee.java接口類，在其中定義常量prize，用來保存員工加薪的基本值，同時在接口類中聲明addSalary()抽象方法，用來聲明給員工加薪的方法

public interface IEmployee {        public static final double prize=1000.00;    public abstract void addSalary(); }

• People.java抽象類，用來描述人的屬性

abstract class People {    String name;    int age;        abstract String getName();    abstract int getAge();}

• Employee.java雇員類，用來表示一個特定的員工。該類繼承了People抽象類，同時實現了IEmployee接口，并在類方法體中定義了三個成員方法，用來獲取雇員屬性

public class Employee extends People implements IEmployee{    double salary;    String hireDay;        public Employee(String name, double salary, String hireDay, int age)    {        this.name=name;        this.salary=salary;        this.hireDay=hireDay;        this.age=age;    }        public void getInfo()    {        System.out.println("I'm Employee");    }    public double getSalary()    {        return salary;    }    public String getHireDay()    {        return hireDay;    }        //實現父類中的方法    public String getName()    {return name;}        public int getAge()    {return age;}        //實現接口中的方法    public void addSalary()    {        salary+=prize;    }}

• Manager.jave經理類，該類繼承了Employee雇員類，同時在Manager類中，使用方法重載重新定義getInfo(), getSalary(), addSalary()方法

public class Manager extends Employee{    private double bonus;    private int holidays;        public Manager(String name, double salary, String hireDay, int age, int holidays)    {        super(name, salary, hireDay, age);        this.holidays=holidays;    }        public void getInfo()    {        System.out.println("I'm Manager");    }    public double getSalary()    {        return salary;    }        public int getHolidays()    {return holidays;}        public void addSalary()    {        salary+=prize*2;    }}

• ManageEmployeeSalary.java程序主類，包含main方法，是本系統中所有程序的入口點，用來全局控制和運行整個系統

public class ManageEmployeeSalary {    Employee e1, e2;    Manager m;        public ManageEmployeeSalary()    {        e1=new Employee("Wang Xiao Yue", 3000.00, "2005/05/20", 24);        e2=new Employee("Xu Guang Yang", 2000.00, "2006/06/02", 22);        m=new Manager("Zhao XS", 8000.00, "2004/6/2", 26, 20);                System.out.println("name:"+e1.getName());        e1.getInfo();        System.out.println("Age:"+e1.getAge());        System.out.println("Salary:"+e1.getSalary());        System.out.println("Hireday:"+e1.getHireDay()+"/n");                System.out.println("name:"+e2.getName());        e2.getInfo();        System.out.println("Age:"+e2.getAge());        System.out.println("Salary:"+e2.getSalary());        System.out.println("Hireday:"+e2.getHireDay()+"/n");                System.out.println("name:"+m.getName());        m.getInfo();        System.out.println("Age:"+m.getAge());        System.out.println("Salary:"+m.getSalary());        System.out.println("Hireday:"+m.getHireDay()+"/n");                e1.addSalary();        e2.addSalary();        m.addSalary();        System.out.println("/nAfter adding salary:");        System.out.println(e1.getName()+"'s salary is:"+e1.getSalary());        System.out.println(e2.getName()+"'s salary is:"+e2.getSalary());        System.out.println(m.getName()+"'s salary is:"+m.getSalary());            }    public static void main(String[] args) {        new ManageEmployeeSalary();            }}

name:Wang Xiao YueI'm EmployeeAge:24Salary:3000.0Hireday:2005/05/20

name:Xu Guang YangI'm EmployeeAge:22Salary:2000.0Hireday:2006/06/02

name:Zhao XSI'm ManagerAge:26Salary:8000.0Hireday:2004/6/2

After adding salary:Wang Xiao Yue's salary is:4000.0Xu Guang Yang's salary is:3000.0Zhao XS's salary is:10000.0