面向對象

抽象：關注屬性和行為，不關注行為的細節
繼承：讓變化中的軟件系統有了一定的延續性，同時繼承也是封裝程序中可變因素的重要手段
封裝：隱藏一切可以隱藏的東西，只向外界提供最簡單的編程接口
多態性：編譯是多態性和運行時多態性

• 方法重載(overload)編譯時的多態(前綁定) ——多個函數同時存在，具有不同的參數和不同的定義
• 方法重寫(override)運行時的多態(后綁定)

實現多態：
1.方法重寫（子類繼承父類并重寫父類中已有的或抽象的方法）
2.對象造型（用父類型引用引用子類型對象，這樣同樣的引用調用同樣的方法就會根據子類對象的不同而表現出不同的行為）

訪問修飾符

基本數據類型

Java中的基本數據類型只有8個：byte、short、int、long、float、double、char、boolean
除了基本類型和枚舉類型，剩下的都是引用類型

eg : float f=3.4;是否正確?
答:不正確。3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬于下轉型（down-casting，也稱為窄化）會造成精度損失，因此需要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;

eg : short s1 = 1; s1 = s1 + 1;有錯嗎?short s1 = 1; s1 += 1;有錯嗎？
答：對于short s1 = 1; s1 = s1 + 1;由于1是int類型，因此s1+1運算結果也是int 型，需要強制轉換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因為s1+= 1;相當于s1 = (short)(s1 + 1);其中有隱含的強制類型轉換。

原始/包裝類型

原始類型: boolean，char，byte，short，int，long，float，double
包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
eg ： int的包裝類就是Integer，從Java 5開始引入了自動裝箱/拆箱機制，使得二者可以相互轉換

class Test {

    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 將3自動裝箱成Integer類型
        int c = 3;
        System.out.println(a == b);     // false 兩個引用沒有引用同一對象
        System.out.println(a == c);     // true a自動拆箱成int類型再和c比較
    }
}

eg : 輸出結果是啥

public class Test {
 
    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
 
        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

首先需要注意的是f1、f2、f3、f4四個變量都是Integer對象引用，所以下面的==運算比較的不是值而是引用
裝箱的本質是什么呢？當我們給一個Integer對象賦一個int值的時候，會調用Integer類的靜態方法valueOf，如果看看valueOf的源代碼就知道發生了什么:

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

IntegerCache是Integer的內部類，其代碼如下所示：

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */
 
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];
 
        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
 
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }
 
        private IntegerCache() {}
    }

簡單的說，如果整型字面量的值在-128到127之間，那么不會new新的Integer對象，而是直接引用常量池中的Integer對象，所以上面的f1==f2的結果是true，而f3==f4的結果是false

&和&&

&運算符有兩種用法：(1)按位與；(2)邏輯與
&&運算符是短路與運算

• 二者都要求運算符左右兩端的布爾值都是true整個表達式的值才是true
• &&之所以稱為短路運算是因為，如果&&左邊的表達式的值是false，右邊的表達式會被直接短路掉，不會進行運算

eg : username != null &&!username.equals(“”)
二者的順序不能交換，更不能用&運算符，因為第一個條件如果不成立，根本不能進行字符串的equals比較，否則會產生NullPointerException異常
邏輯或運算符（|）和短路或運算符（||）的差別也是如此

棧(stack)、堆(heap)和靜態區(static area)

通常我們定義一個基本數據類型的變量，一個對象的引用，還有就是函數調用的現場保存都使用內存中的棧空間；而通過new關鍵字和構造器創建的對象放在堆空間；程序中的字面量如直接書寫的100、”hello”和常量都是放在靜態區中。?？臻g操作起來最快但是棧很小，通常大量的對象都是放在堆空間，理論上整個內存沒有被其他進程使用的空間甚至硬盤上的虛擬內存都可以被當成堆空間來使用。
eg ：

String str = new String("hello");

變量str放在棧上，用new創建出來的字符串對象放在堆上，而”hello”這個字面量放在靜態區

Math.round

Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11

switch

在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。從Java 5開始，Java中引入了枚舉類型，expr也可以是enum類型，從Java 7開始，expr還可以是字符串（String），但是長整型（long）在目前所有的版本中都是不可以的

計算2乘以8最有效率方法

2 << 3（左移3位相當于乘以2的3次方，右移3位相當于除以2的3次方）
eg : 31*num <==>(等價于) (num << 5) - num

length

數組沒有length()方法，有length 的屬性。String 有length()方法

在Java中，如何跳出當前的多重嵌套循環

在最外層循環前加一個標記如A，然后用break A;可以跳出多重循環

實例一：普通break跳出當前循環，跳不出多重循環：

public class LoopDemo {  
    public static void main(String[] args) {  
        for (int i = 0; i < 2; i++) {  
            System.out.println("運行第一重循環" + i);  
            for (int j = 0; j < 2; j++) {  
                System.out.println("運行第二重循環" + j);  
                for (int k = 0; k < 2; k++) {  
                    if(k==1){  
                        break;  
                    }  
                    System.out.println("運行第三重循環" + k);  
                    System.out.println("******************************");  
                      
                }  
            }  
        }  
    }  
}  

運行結果：

運行第一重循環0  
運行第二重循環0  
運行第三重循環0  
******************************  
運行第二重循環1  
運行第三重循環0  
******************************  
運行第一重循環1  
運行第二重循環0  
運行第三重循環0  
******************************  
運行第二重循環1  
運行第三重循環0  
******************************  

實例二：利用label標記跳出多重循環:

public class LoopDemo {  
    public static void main(String[] args) {  
        zengzs: for (int i = 0; i < 2; i++) {  
            System.out.println("運行第一重循環" + i);  
            for (int j = 0; j < 2; j++) {  
                // label: for (int j = 0; j <2; i++) {  
                System.out.println("運行第二重循環" + j);  
                for (int k = 0; k < 2; k++) {  
                    // break label;  
                    if (k == 1) {  
                        System.out.println("跳出多重循環");  
                        break zengzs;  
                    }  
                    System.out.println("運行第三重循環" + k);  
                    System.out.println("**************************");  
                }  
            }  
        }  
    }  
}  

運行結果：

運行第一重循環0  
運行第二重循環0  
運行第三重循環0  
**************************  
跳出多重循環  

構造器（constructor）是否可被重寫（override）

構造器不能被繼承，因此不能被重寫，但可以被重載

兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對

不對，如果兩個對象x和y滿足x.equals(y) == true，它們的哈希碼（hash code）應當相同

對于eqauls方法和hashCode方法是這樣規定的：
(1)如果兩個對象相同（equals方法返回true），那么它們的hashCode值一定要相同
(2)如果兩個對象的hashCode相同，它們并不一定相同

equals方法

首先equals方法必須滿足

• 自反性（x.equals(x)必須返回true）
• 對稱性（x.equals(y)返回true時，y.equals(x)也必須返回true）
• 傳遞性（x.equals(y)和y.equals(z)都返回true時，x.equals(z)也必須返回true）
• 一致性（當x和y引用的對象信息沒有被修改時，多次調用x.equals(y)應該得到同樣的返回值），而且對于任何非null值的引用x，x.equals(null)必須返回false

實現高質量的equals方法的訣竅

1. 使用==操作符檢查”參數是否為這個對象的引用”；
2. 使用instanceof操作符檢查”參數是否為正確的類型”；
3. 對于類中的關鍵屬性，檢查參數傳入對象的屬性是否與之相匹配；
4. 編寫完equals方法后，問自己它是否滿足對稱性、傳遞性、一致性；
5. 重寫equals時總是要重寫hashCode；
6. 不要將equals方法參數中的Object對象替換為其他的類型，在重寫時不要忘掉@Override注解

是否可以繼承String類

String 類是final類，不可以被繼承

繼承String本身就是一個錯誤的行為，對String類型最好的重用方式是關聯關系（Has-A）和依賴關系（Use-A）而不是繼承關系（Is-A）

final關鍵字

java中的final關鍵字非常重要，它可以應用于類、方法以及變量
(1)修飾類：表示該類不能被繼承；
(2)修飾方法：表示方法不能被重寫；
(3)修飾變量：表示變量只能一次賦值以后值不能被修改（常量）只讀的

final關鍵字的好處：
1.final關鍵字提高了性能。JVM和Java應用都會緩存final變量。
2.final變量可以安全的在多線程環境下進行共享，而不需要額外的同步開銷。
3.使用final關鍵字，JVM會對方法、變量及類進行優化。

關于final的重要知識點
1.final關鍵字可以用于成員變量、本地變量、方法以及類。
2.final成員變量必須在聲明的時候初始化或者在構造器中初始化，否則就會報編譯錯誤。
3.你不能夠對final變量再次賦值。
4.本地變量必須在聲明時賦值。
5.在匿名類中所有變量都必須是final變量。
6.final方法不能被重寫。
7.final類不能被繼承。
8.final關鍵字不同于finally關鍵字，后者用于異常處理。

9.final關鍵字容易與finalize()方法搞混，后者是在Object類中定義的方法，是在垃圾回收之前被JVM調用的方法。
10.接口中聲明的所有變量本身是final的。
11.final和abstract這兩個關鍵字是反相關的，final類就不可能是abstract的。
12.final方法在編譯階段綁定，稱為靜態綁定(static binding)。
13.沒有在聲明時初始化final變量的稱為空白final變量(blank final variable)，它們必須在構造器中初始化，或者調用this()初始化。不這么做的話，編譯器會報錯“final變量(變量名)需要進行初始化”。
14.將類、方法、變量聲明為final能夠提高性能，這樣JVM就有機會進行估計，然后優化。
15.按照Java代碼慣例，final變量就是常量，而且通常常量名要大寫。

值傳遞

當一個對象被當作參數傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞？
是值傳遞、Java語言的方法調用只支持參數的值傳遞

String和StringBuilder、StringBuffer的區別

Java平臺提供了兩種類型的字符串：String和StringBuffer/StringBuilder，它們可以儲存和操作字符串

• String是只讀字符串，也就意味著String引用的字符串內容是不能被改變的
• StringBuffer/StringBuilder類表示的字符串對象可以直接進行修改
• StringBuilder是Java 5中引入的，它和StringBuffer的方法完全相同，區別在于它是在單線程環境下使用的，因為它的所有方面都沒有被synchronized修飾，因此它的效率也比StringBuffer要高。

JAVA中String (+),StringBuffer,SrtingBuilder三個對象連接字符串的效率：

image.png

如果你對字符串中的內容經常進行操作，特別是內容要修改時，那么使用StringBuffer，如果最后
需要String，那么使用StringBuffer的toString()方法好了。但是 StringBuilder 的實例用于多個線程是不安全的。如果需要這樣的同步，則建議使用 StringBuffer，因為StringBuffer是線程安全的。在大多數非多線程的開發中，為了提高效率，可以采用StringBuilder代替StringBuffer，速度更快
eg : 請說出下面程序的輸出:

class Test {
 
    public static void main(String[] args) {
        String s1 = "Programming";
        String s2 = new String("Programming");
        String s3 = "Program" + "ming";
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1 == s1.intern());
    }
}

image.png

String對象的intern方法會得到字符串對象在常量池中對應的版本的引用（如果常量池中有一個字符串與String對象的equals結果是true），如果常量池中沒有對應的字符串，則該字符串將被添加到常量池中，然后返回常量池中字符串的引用

重載（Overload）和重寫（Override）的區別

方法的重載和重寫都是實現多態的方式，區別在于前者實現的是編譯時的多態性，而后者實現的是運行時的多態性

• 重載發生在一個類中，同名的方法如果有不同的參數列表（參數類型不同、參數個數不同或者二者都不同）則視為重載；
• 重寫發生在子類與父類之間，重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型，比父類被重寫方法更好訪問，不能比父類被重寫方法聲明更多的異常（里氏代換原則）。
• 重載對返回類型沒有特殊的要求。

JVM加載class文件的原理機制

JVM中類的裝載是由類加載器（ClassLoader）和它的子類來實現的，Java中的類加載器是一個重要的Java運行時系統組件，它負責在運行時查找和裝入類文件中的類。
由于Java的跨平臺性，經過編譯的Java源程序并不是一個可執行程序，而是一個或多個類文件。當Java程序需要使用某個類時，JVM會確保這個類已經被加載、連接（驗證、準備和解析）和初始化。類的加載是指把類的.class文件中的數據讀入到內存中，通常是創建一個字節數組讀入.class文件，然后產生與所加載類對應的Class對象。加載完成后，Class對象還不完整，所以此時的類還不可用。當類被加載后就進入連接階段，這一階段包括驗證、準備（為靜態變量分配內存并設置默認的初始值）和解析（將符號引用替換為直接引用）三個步驟。最后JVM對類進行初始化，包括：1)如果類存在直接的父類并且這個類還沒有被初始化，那么就先初始化父類；2)如果類中存在初始化語句，就依次執行這些初始化語句。
類的加載是由類加載器完成的，類加載器包括：根加載器（BootStrap）、擴展加載器（Extension）、系統加載器（System）和用戶自定義類加載器（java.lang.ClassLoader的子類）。從Java 2（JDK 1.2）開始，類加載過程采取了父親委托機制（PDM）。PDM更好的保證了Java平臺的安全性，在該機制中，JVM自帶的Bootstrap是根加載器，其他的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載，父類加載器無能為力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關于幾個類加載器的說明：

• Bootstrap：一般用本地代碼實現，負責加載JVM基礎核心類庫（rt.jar）；
• Extension：從java.ext.dirs系統屬性所指定的目錄中加載類庫，它的父加載器是Bootstrap；
• System：又叫應用類加載器，其父類是Extension。它是應用最廣泛的類加載器。它從環境變量classpath或者系統屬性java.class.path所指定的目錄中記載類，是用戶自定義加載器的默認父加載器。

類從被加載到虛擬機類存中開始，到被卸載出內存為止，它的整個生命周期包括：
加載 → 驗證 → 準備 → 解析 → 初始化 → 使用 → 卸載

char 型變量中能不能存貯一個中文漢字

char類型可以存儲一個中文漢字，因為Java中使用的編碼是Unicode（不選擇任何特定的編碼，直接使用字符在字符集中的編號，這是統一的唯一方法），一個char類型占2個字節（16比特），所以放一個中文是沒問題的

使用Unicode意味著字符在JVM內部和外部有不同的表現形式，在JVM內部都是Unicode，當這個字符被從JVM內部轉移到外部時（例如存入文件系統中），需要進行編碼轉換。所以Java中有字節流和字符流，以及在字符流和字節流之間進行轉換的轉換流，如InputStreamReader和OutputStreamReader，這兩個類是字節流和字符流之間的適配器類，承擔了編碼轉換的任務

抽象類（abstract class）和接口（interface）有什么異同

抽象類和接口都不能夠實例化，但可以定義抽象類和接口類型的引用。
一個類如果繼承了某個抽象類或者實現了某個接口都需要對其中的抽象方法全部進行實現，否則該類仍然需要被聲明為抽象類。
接口比抽象類更加抽象，因為抽象類中可以定義構造器，可以有抽象方法和具體方法，而接口中不能定義構造器而且其中的方法全部都是抽象方法。
抽象類中的成員可以是private、默認、protected、public的，而接口中的成員全都是public的。
抽象類中可以定義成員變量，而接口中定義的成員變量實際上都是常量。
有抽象方法的類必須被聲明為抽象類，而抽象類未必要有抽象方法。

抽象的（abstract）方法是否可同時是靜態的（static）,是否可同時是本地方法（native），是否可同時被synchronized修飾

都不能。抽象方法需要子類重寫，而靜態的方法是無法被重寫的，因此二者是矛盾的。本地方法是由本地代碼（如C代碼）實現的方法，而抽象方法是沒有實現的，也是矛盾的。synchronized和方法的實現細節有關，抽象方法不涉及實現細節，因此也是相互矛盾的

靜態變量和實例變量的區別

• 靜態變量是被static修飾符修飾的變量，也稱為類變量，它屬于類，不屬于類的任何一個對象，一個類不管創建多少個對象，靜態變量在內存中有且僅有一個拷貝；
• 實例變量必須依存于某一實例，需要先創建對象然后通過對象才能訪問到它。靜態變量可以實現讓多個對象共享內存。

是否可以從一個靜態（static）方法內部發出對非靜態（non-static）方法的調用

不可以，靜態方法只能訪問靜態成員，因為非靜態方法的調用要先創建對象，在調用靜態方法時可能對象并沒有被初始化。

如何實現對象克隆

有兩種方式：
1). 實現Cloneable接口并重寫Object類中的clone()方法；
2). 實現Serializable接口，通過對象的序列化和反序列化實現克隆，可以實現真正的深度克隆，代碼如下。

GC是什么？為什么要有GC

GC是垃圾收集的意思，內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。Java程序員不用擔心內存管理，因為垃圾收集器會自動進行管理。要請求垃圾收集，可以調用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但JVM可以屏蔽掉顯示的垃圾回收調用。
垃圾回收可以有效的防止內存泄露，有效的使用可以使用的內存。垃圾回收器通常是作為一個單獨的低優先級的線程運行，不可預知的情況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清除和回收，程序員不能實時的調用垃圾回收器對某個對象或所有對象進行垃圾回收。在Java誕生初期，垃圾回收是Java最大的亮點之一，因為服務器端的編程需要有效的防止內存泄露問題，然而時過境遷，如今Java的垃圾回收機制已經成為被詬病的東西。移動智能終端用戶通常覺得iOS的系統比Android系統有更好的用戶體驗，其中一個深層次的原因就在于Android系統中垃圾回收的不可預知性。

補充：垃圾回收機制有很多種，包括：分代復制垃圾回收、標記垃圾回收、增量垃圾回收等方式。標準的Java進程既有棧又有堆。棧保存了原始型局部變量，堆保存了要創建的對象。Java平臺對堆內存回收和再利用的基本算法被稱為標記和清除，但是Java對其進行了改進，采用“分代式垃圾收集”。這種方法會跟Java對象的生命周期將堆內存劃分為不同的區域，在垃圾收集過程中，可能會將對象移動到不同區域：

• 伊甸園（Eden）：這是對象最初誕生的區域，并且對大多數對象來說，這里是它們唯一存在過的區域。
• 幸存者樂園（Survivor）：從伊甸園幸存下來的對象會被挪到這里。
• 終身頤養園（Tenured）：這是足夠老的幸存對象的歸宿。年輕代收集（Minor-GC）過程是不會觸及這個地方的。當年輕代收集不能把對象放進終身頤養園時，就會觸發一次完全收集（Major-GC），這里可能還會牽扯到壓縮，以便為大對象騰出足夠的空間。

與垃圾回收相關的JVM參數：

• -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
• -Xmn — 堆中年輕代的大小
• -XX:-DisableExplicitGC — 讓System.gc()不產生任何作用
• -XX:+PrintGCDetails — 打印GC的細節
• -XX:+PrintGCDateStamps — 打印GC操作的時間戳
• -XX:NewSize / XX:MaxNewSize — 設置新生代大小/新生代最大大小
• -XX:NewRatio — 可以設置老生代和新生代的比例
• -XX:PrintTenuringDistribution — 設置每次新生代GC后輸出幸存者樂園中對象年齡的分布
• -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：設置老年代閥值的初始值和最大值
• -XX:TargetSurvivorRatio：設置幸存區的目標使用率

String s = new String(“xyz”);創建了幾個字符串對象

兩個對象，一個是靜態區的”xyz”，一個是用new創建在堆上的對象

接口是否可繼承（extends）接口？抽象類是否可實現（implements）接口？抽象類是否可繼承具體類（concrete class）

接口可以繼承接口，而且支持多重繼承。抽象類可以實現(implements)接口，抽象類可繼承具體類也可以繼承抽象類

一個”.java”源文件中是否可以包含多個類（不是內部類）？有什么限制 ?

可以，但一個源文件中最多只能有一個公開類（public class）而且文件名必須和公開類的類名完全保持一致

Anonymous Inner Class(匿名內部類)是否可以繼承其它類？是否可以實現接口？

可以繼承其他類或實現其他接口，在Swing編程和Android開發中常用此方式來實現事件監聽和回調。

內部類可以引用它的包含類（外部類）的成員嗎？有沒有什么限制？

一個內部類對象可以訪問創建它的外部類對象的成員，包括私有成員

指出下面程序的運行結果:

class A {
 
    static {
        System.out.print("1");
    }
 
    public A() {
        System.out.print("2");
    }
}
 
class B extends A{
 
    static {
        System.out.print("a");
    }
 
    public B() {
        System.out.print("b");
    }
}
 
public class Hello {
 
    public static void main(String[] args) {
        A ab = new B();
        ab = new B();
    }
 
}

執行結果：1a2b2b。創建對象時構造器的調用順序是：先初始化靜態成員，然后調用父類構造器，再初始化非靜態成員，最后調用自身構造器。

數據類型之間的轉換

• 如何將字符串轉換為基本數據類型？
• 如何將基本數據類型轉換為字符串？

調用基本數據類型對應的包裝類中的方法parseXXX(String)或valueOf(String)即可返回相應基本類型
一種方法是將基本數據類型與空字符串（”"）連接（+）即可獲得其所對應的字符串；另一種方法是調用String 類中的valueOf()方法返回相應字符串

如何實現字符串的反轉及替換

用遞歸實現字符串反轉，代碼如下所示：

public static String reverse(String originStr) {
      if(originStr == null || originStr.length() <= 1) 
          return originStr;
      return reverse(originStr.substring(1)) + originStr.charAt(0);
}

怎樣將GB2312編碼的字符串轉換為ISO-8859-1編碼的字符串

String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");