Java-SE

1-1-什麼是Java的跨平臺原理

Java通過不同的系統，不同的版本不同的位數的Java虛擬機（JVM）來屏蔽不同的指令集，然後對外提供了統一的Java接口（API），這樣，我們的開發者只需按照接口開發即可，如果系統需要部署在不同的環境是，只需要系統上面按照片對應版本的虛擬機即可

1.2-JDK 和 JRE 有什麼區別？

JDK：java 開發工具包，提供了 java 的開發環境和運行環境。
JRE：java 運行環境，爲 java 的運行提供了所需環境。

1.3-Java基本數據類型

1.4-Java基本類型所佔字節和範圍

1.5-int(long) 和 float(double) 哪個表示的範圍大？爲什麼？

float表示的範圍更大。float 和 int 都是4個字節，而 float 還要表示小數，爲什麼 float 表示的數字範圍大？

int 底層使用的是補碼的方式表示一個數：1 位符號位 + 31 位二進制數
float 底層使用的是IEEE 754 浮點單精度數字格式，簡單來說就是用指數的形式去表示一個數：1 位符號位 + 8 位指數 + 23位尾數

1.6-Int和Integer的區別，在使用時有什麼區別？

Integer是int的包裝類，int則是java的一種基本數據類型
Integer變量必須實例化後才能使用，而int變量不需要
Integer實際是對象的引用，當new一個Integer時，實際上是生成一個指針指向此對象；而int則是直接存儲數據值
Integer的默認值是null，int的默認值是0

1.7-有了基本的數據類型，爲什麼還需要包裝類型

因爲Java是一個面向對象的語言，而基本的數據類型，不具備面向對象的特性

1.8-裝箱和拆箱，自動拆箱，自動裝箱

裝箱：把基本的數據類型轉換成對應的包裝類型
拆箱：把包裝類型轉換成對應的基本數據類型
自動裝箱：實際上編譯時會調用integer.valueOf方法來裝箱 Integer i=1；
自動拆箱：實際上編譯時會調用intValue方法來拆箱 Int j=i.intValue();

1.9-重寫，重載

重載：方法名字相同，而參數不同。返回類型可以相同也可以不同

重寫：子類定義的方法與父類中的方法具有相同的方法名字，相同的參數表和相同的返回類型

子類和父類在同一個包中，那麼子類可以重寫父類所有方法，除了聲明爲 private 和 final 的方法。
子類和父類不在同一個包中，那麼子類只能夠重寫父類的聲明爲 public 和 protected 的非 final 方法。
聲明爲 static 的方法不能被重寫，但是能夠被再次聲明。
子類如果不是抽象類，則必須重寫父類中的abstract方法。
如果不能繼承一個方法，則不能重寫這個方法。

1.10-==和equals方法的區別

==對於基本類型是比較的是值是否相同，對於引用類型比較的是地址是否相同。equals默認情況下是引用的比較，只是很多類重寫了 equals的方法，比如spring，integer等把它變成了值比較，所以一般情況下equals比較的是值是否相等

1.11- final 在 java 中有什麼作用？

final 修飾的類叫最終類，該類不能被繼承。
final 修飾的方法不能被重寫。
final 修飾的變量叫常量，常量必須初始化，初始化之後值就不能被修改。

1.12-面向對象的特徵有哪些方面

多態，繼承，封裝，（抽象）

抽象：把一個對象，抽象爲類
封裝：隱藏類的內部信息，外部類不可以直接訪問，可以通過get/set去獲取或值改變這個類
繼承：通過extends繼承父類的基本特徵和行爲，子類也可以改變這些基本特徵和行爲
多態：也就是同一個操作作用在不同對象上面的時候可以產生不同的效果

1.13-接口和抽象類（接口的抽象級別最高）

相同點：

不能被實例化。

不同點：

抽象類要被子類繼承extends，接口要被類實現implements 。
抽象類可以有構造函數；接口不能有。
接口支持多繼承，抽象類只允許單繼承。
接口只能做方法聲明，抽象類中可以作方法聲明，也可以做方法實現。
接口裏定義的變量只能是公共的靜態的常量，抽象類中的變量是普通變量。
抽象類可以有具體的方法和屬性，接口只能有抽象方法和不可變常量。
抽象類可以有 main 方法，並且我們能運行它；接口不能有 main 方法。

1.14-抽象類不是必須要有抽象方法

不需要，抽象類不一定非要有抽象方法。

public abstract class Person{
    public static void say() {
        System.out.println("HELLO");
    }
}

1.15-普通類和抽象類的區別

普通類不能包含抽象方法，抽象類可以包含抽象方法。
抽象類不能直接實例化，普通類可以直接實例化。

1.16-抽象類不能使用 final 修飾

定義抽象類就是讓其他類繼承的，如果定義爲 final 該類就不能被繼承，這樣彼此就會產生矛盾，所以 final 不能修飾抽象類

1.17-String底層實現，不可變的原因

String的底層是使用char數組的，char數組和String類都是被final修飾的，所以不可以改變

1.18-String 不屬於基礎的數據類型

String 不屬於基礎類型，String 屬於對象。

1.19-String str="str"與 String str=new String("str")的內存分配

因爲內存的分配方式是不一樣的，String str="str"的方式，java 虛擬機會將其分配到常量池中；而 String str=new String("str") 則會被分到堆內存中。

1.20- String 類的常用方法

length()字符串的長度
charAt() 截取一個字符
equals()和equalsIgnoreCase() 比較兩個字符串
compareTo()和compareToIgnoreCase() 比較字符串
concat() 連接兩個字符串
replace() 替換
toUpperCase() /toLowerCase() 轉換爲大小寫
trim() 去掉起始和結尾的空格

        String test="abcdefg";
        String test2="   ABCDEFG    ";
        System.out.println("字符串長度=" + test.length());
        System.out.println("截取一個字符 = " + test.charAt(2));
        int compareTo = test.compareTo(test2);
        System.out.println("compareTo = " + compareTo);
        int compareToIgnoreCase = test.compareToIgnoreCase(test2);
        System.out.println("compareToIgnoreCase = " + compareToIgnoreCase);
        boolean b = test.equals(test2);
        System.out.println("b = " + b);
        boolean b1 = test.equalsIgnoreCase(test2);
        System.out.println("b1 = " + b1);
        String str=test.concat(test2).concat("test");
        System.out.println("str = " + str);
        str=str.replace("test","idea");
        System.out.println("str = " + str);
        str=str.toLowerCase();
        System.out.println("str = " + str);
        str=str.toUpperCase();
        System.out.println("str = " + str);
        int test2Length=test2.length();
        test2=test2.trim();
        System.out.println("test2Length2 = " + test2Length);
        int test2Length1=test2.length();
        System.out.println("test2Length1 = " + test2Length1);
//字符串長度=7
//截取一個字符 = c
//compareTo = 65
//compareToIgnoreCase = 65
//b = false
//b1 = false
//str = abcdefg   ABCDEFG    test
//str = abcdefg   ABCDEFG    idea
//str = abcdefg   abcdefg    idea
//str = ABCDEFG   ABCDEFG    IDEA
//test2Length2 = 14
//test2Length1 = 7

1.21-String，StringBuilder，StringBuffer的區別？

String是隻讀字符，值不可以改變的
StringBuffer的值是可以改變的，線程安全
StringBuilder的值是可以改變的，線程不安全

1.22-什麼是值傳遞和引用傳遞？

值傳遞是對基本類型變量而言的,傳遞的是該變量的一個副本,改變副本不影響原來變量.
引用傳遞一般是對於對象型變量而言的,傳遞的是該對象地址的一個副本, 並不是原對象本身。

一般認爲,java內的基礎類型數據傳遞都是值傳遞. java中實例對象的傳遞是引用傳遞

1.23-SimpleDateFormat的作用和用法

SimpleDateFormat的作用是用於設置時間格式的

把日期轉換爲指定格式的字符串

SimpleDateFormat sdformat = new SimpleDateFormat("yyy y-MM-dd HH:mm:ss");
String text = sdformat .format(new Date());

//text = 2020 2020-06-14 16:00:54

把字符串轉換爲指定格式日期

public static void main(String []args) throws ParseException {
       String text = "2020年1月1日 1:11:11";
        SimpleDateFormat sdformat= new SimpleDateFormat("yyyy年M月dd日 H:mm:ss");
        Date date= sdformat.parse(text);
        System.out.println("date = " + date);
}
//date = Wed Jan 01 01:11:11 CST 2020

1.24- java 中 IO 流分類

按功能來分：輸入流（input）、輸出流（output）。
按類型來分：字節流和字符流。

1.25-Java的流

1.26- Files的常用方法

Files.exists()：檢測文件路徑是否存在。
Files.createFile()：創建文件。
Files.createDirectory()：創建文件夾。
Files.delete()：刪除一個文件或目錄。
Files.copy()：複製文件。
Files.move()：移動文件。
Files.size()：查看文件個數。
Files.read()：讀取文件。
Files.write()：寫入文件。

1.27-如何創建文件和目錄？

File file = new File("D:", "one");
//創建文件夾
file .mkdir();          
 //創建文件 
file .createNewFile();  
 //刪除文件
file .delete();

1.28-面向對象編程的六大原則

1、開閉原則（Open Close Principle）

開閉原則的意思是：對擴展開放，對修改關閉。在程序需要進行拓展的時候，不能去修改原有的代碼，實現一個熱插拔的效果。簡言之，是爲了使程序的擴展性好，易於維護和升級。想要達到這樣的效果，我們需要使用接口和抽象類。

2、里氏代換原則（Liskov Substitution Principle）

里氏代換原則是面向對象設計的基本原則之一。里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。LSP 是繼承複用的基石，只有當派生類可以替換掉基類，且軟件單位的功能不受到影響時，基類才能真正被複用，而派生類也能夠在基類的基礎上增加新的行爲。里氏代換原則是對開閉原則的補充。實現開閉原則的關鍵步驟就是抽象化，而基類與子類的繼承關係就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規範。

3、依賴倒轉原則（Dependence Inversion Principle）

這個原則是開閉原則的基礎，具體內容：針對接口編程，依賴於抽象而不依賴於具體。

4、接口隔離原則（Interface Segregation Principle）

這個原則的意思是：使用多個隔離的接口，比使用單個接口要好。它還有另外一個意思是：降低類之間的耦合度。由此可見，其實設計模式就是從大型軟件架構出發、便於升級和維護的軟件設計思想，它強調降低依賴，降低耦合。

5、迪米特法則，又稱最少知道原則（Demeter Principle）

最少知道原則是指：一個實體應當儘量少地與其他實體之間發生相互作用，使得系統功能模塊相對獨立。

6、單一職責原則（Single responsibility principle）

單一職責原則是指：一個類應該只有一個發生變化的原因，即一個類只負責一項職責。
如果一個類有多個職責，這些職責就耦合在了一起。當一個職責發生變化時，可能會影響其它的職責。另外，多個職責耦合在一起會影響複用性。
此原則的核心是解耦和增強內聚性。

1.29-設計模式

單例模式（飽漢模式，飢漢模式）

1）構造方法私有化，讓除了自己類能創建外其他地方都不可以創建
2）在自己的類中創建一個單實例（飽漢模式一出來就創建單實例，飢漢模式需要的時候才創建）
3）提供一個方法獲取該實例對象（飢漢模式創建時需要進行方法同步）

工程模式：spring的IOC就是使用工程模式

對象的創建交給一個工廠創建

代理模式：Spring的AOP就是使用的動態代理

包裝模式

1.30- 運行時異常與一般異常的區別

異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但是並不要求必須聲明拋出未被捕獲的運行時異常。

1.31-&和&&的區別

&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）

1.32-final, finally, finalize的區別。

final 用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。

1.33-error和exception的區別。

error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。

1.34-Math.round(9.5)等多少? Math.round(-9.5)等多少?

Math.round(9.5) =10
Math.round(-9.5) =-9

數軸上取值時，中間值（0.5）向右取整，所以正 9.5 是往上取整，負 9.5 是直接捨棄。

Java知識總結--SE篇