設計模式是在大量的實踐中總結和理論化之後優選的代碼結構、編程風格以及解決問題的思考方式。
所謂的單態設計模式指的是：採取一定的方法保證在整個軟件系統中，某個類只能存在一個對象，並且該類只提供一個取得其對象實例的方法。
單態設計模式的實現有兩種形式。
(1) 第一種形式：定義一個類，它的構造方法爲private，它有一個靜態的實例對象，並且此對象訪問範圍被設置爲private，通過getInstance方法獲取對此對象的引用，繼而調用此對象的相關方法。
【示例15】TestSingle.java
將構造方法定義爲私有的，然後通過方法將同一個對象對外公佈，代碼如下：
public class TestSingle{//形式一
private static final TestSingle onlyone=new TestSingle();
//前面加private static final修飾後只能產生一個對象
private TestSingle(){
//不能在類的外部使用new，但在類的內部可以
}
public static TestSingle getTestSingle(){
return onlyone;//外面只能通過方法調用獲得一個對象
}
}
2.嵌套類
聲明在類的內部的類稱之爲嵌套類（nested class）
定義語法:
[public] class OuterClass{
...
[public|proteceted|private] [static] class NestedClass{
...
}
}
嵌套類在編譯後會生成Outer$Inner.class類文件
1.成員內部類
內部類作爲外部類的一個成員存在，與外部類的成員變量、成員方法並列。
注意:
在外部類創建內部類的對象語法是:
外部類.內部類 對象名稱=new 外部類().new 內部類();
在內部類調用外部類的屬性或方法：
1.在內部類中可以直接調用外部類的成員屬性或成員方法
2.如果內部類的成員屬性和外部類的成員屬性一直，則需要以
外部類.this.屬性名稱的方式調用。
3.在內部類中如果直接使用this.屬性名稱表示調用的是內部類的
成員屬性。
示例：
/**
成員內部類
*/
public class Test2{
String name="zhangsan";
int age=30;
public void display(){
System.out.println("外部類的方法");
}
/**
成員內部類
*/
public class InnerTest2{
String name="lisi";
int age=20;
public void display2(){
System.out.println("內部類的方法");
}
//在內部類中，可以直接訪問外部類的屬性和方法
public void display3(){
System.out.println("外部類的屬性"+Test2.this.name+Test2.this.age);
display();
System.out.println("內部類的屬性："+this.name+this.age);
}
}
public static void main(String[]args){
//通過外部類訪問，內部類
Test2 t1=new Test2();
Test2.InnerTest2 t=t1.new InnerTest2();
t.display2();
t.display3();
}
}
定義在方法內部的類
注意：
只能在本方法中使用，外部類都無法訪問它
局部內部類不能使用訪問修飾符
它可以訪問外部類的成員，也能訪問本方法內用final修飾的局部變量(
但是在JDK8中也可以訪問沒有final修飾的局部變量).
示例：
/**
局部內部類
*/
public class Test3{
int nu2=22;
public void display(){
int age=20;
String name="zhangsan";
class InnerTest3{
int num=100;
public void test(){
System.out.println("局部內部類"+age);
}
}
InnerTest3 t=new InnerTest3();
t.test();
}
public static void main(String[]args){
Test3 t=new Test3();
t.display();
}
}
3.靜態內部類
示例：
/**
靜態內部類
*/
public class Test4{
String name="zhangsan";
static int age=20;
public void display(){
System.out.println("外部類普通方法");
}
public static void display2(){
System.out.println("外部類的靜態方法");
}
/**
靜態內部類
*/
public static class InnerTest4{
String n="ok";
static int num=100;
public void display3(){
System.out.println("內部類的普通方法");
display2();
}
public static void test(){
System.out.println("內部類的靜態方法");
}
}
public static void main(String[]args){
InnerTest4.test();
InnerTest4 t=new InnerTest4();
t.display3();
}
}
3.抽象類
定義:就是說如果在一個類中，沒有足夠的信息去描述一個具體的事物，那麼這個類
就是抽象類。比如:圖形類（width,height）圖形的面積周長如何計算？？？
特點:
1.抽象類中可以有構造方法。
2.抽象類不能實例化。
3.抽象類中可以有成員屬性，成員方法，也可以有靜態屬性和靜態方法，其普通類中可以存在的屬性和方法，在抽象類中都可以擁有。
4.抽象類必須是abstract關鍵字修飾的
5.如果一個類中有一個方法是抽象的那麼這個類一定是抽象類，但是抽象類中不一定有抽象方法。
6.聲明抽象類的語法:
[訪問修飾符] abstract class 類名{
...
}
7.抽象類的子類必須重寫所有的抽象方法後才能被實例化，否則這個子類也要聲明成抽象的。
8.抽象類中的靜態方法，不能使抽象的。
抽象方法，語法:
[訪問修飾符] abstract 返回值類型 方法名稱(參數列表);
注意:抽象方法不能有方法體。
示例：
/**
抽象類 示例
*/
public class Test6{
public static void main(String[]args){
ChangShape2 shape=new ChangShape2(10,20);
shape.area();
shape.zhouChang();
}
}
/**
抽象類
*/
abstract class Shape{
int width;
int height;
public Shape(int width,int height){
this.width=width;
this.height=height;
}
//計算面積的抽象方法
public abstract void area();
//計算周長的抽象方法
public abstract void zhouChang();
public void test(){
System.out.println("抽象類中的普通方法");
}
}
//定義一個長方形
abstract class ChangShape extends Shape{
public ChangShape(int width,int height){
super(width,height);
}
//實現父類中的抽象方法
public void area(){
System.out.println("長方形的面積:"+(super.width*super.height));
}
}
class ChangShape2 extends ChangShape{
public ChangShape2(int width,int height){
super(width,height);
}
public void area(){
super.area();
}
public void zhouChang(){
System.out.println("長方形的周長:"+(super.width+super.height)*2);
super.test();
}
}
接口就是標準，通過定義標準規範，然其它類來實現。
特點：
1.使用interface關鍵字聲明接口，語法爲:
[訪問修飾符] interface 接口名稱{
}
2.接口中聲明的變量永遠都是常量，因爲編譯時接口會爲變量自動添加上public static final
3.接口中聲明的方法，只能有方法的聲明，不能有方法體，而且方法永遠是public修飾的。
4.接口中沒有構造方法，所以接口不能被實例化。
5.接口可以繼承接口，而且可以繼承多個接口，這時，需要用逗號隔開即可
通過implements實現接口，類可以實現多個接口，語法:
[訪問修飾符] class 類名 implements 接口1,接口2{
}
如果一個類實現多個接口，用逗號隔開即可；不管實現多少接口，都必須把接口中的
方法實現了，否則當前類就要定義爲抽象類。
接口其實是一種特殊的類，在接口的實現類中，可以直接訪問接口中的常量或者用接口名稱.常量名稱。
實現類和接口之間存在着 "like a"像一個的關係。
示例：
/**
聲明接口
*/
public class Test7{
public static void main(String[]args){
TestImpl t=new TestImpl();
t.display();
t.test();
t.test2();
}
}
interface TestInterface1{
int num=100;
//聲明一個方法
public void display();
}
interface TestInterface2{
String name="zhangsan";
public void test();
}
interface TestInterface3 extends TestInterface1,TestInterface2{
String address="beijing";
public void test2();
}
//接口的實現類
class TestImpl implements TestInterface1,TestInterface2,TestInterface3{
public void display(){
System.out.println("實現了接口中的方法"+TestInterface1.num);
}
public void test(){
System.out.println(name);
}
public void test2(){
System.out.println(address);
}
}
練習題
1.定義一個手機(MobilePhone)接口，它有打電話(call())、接電話(receive())、發送短信息(sendMsg())、接收短信息(receiveMsg())的功能。
2.定義一個照相機(Camera)的接口，它有拍照(takePhoto())的功能。
3.定義一個照相手機(CameraPhone)的接口，它有手機的功能，也有照相機的功能。
4.定義一個NokiaPhone類和一個MotoPhone類，它們都是照相手機。
5.定義一個Student類，它有name、myPhone(類型爲CameraPhone)兩個屬性；有一個帶參數的構造方法(給他賦名字和手機)還有一個打電話(myCall())的方法，這個方法調用myPhone的call()方法。
6.定義一個測試類(TestInterface)類，定義一個主方法，創建一個叫“張三”的學生，他的手機是Nokia的，再創建一個叫“李四”的學生，它的手機是Moto的，分別調用它們的myCall()方法來展現多態。