Core Java 的知識點總結

1.jdk ,jre,jvm的區別:

jdk:Java 開發工具包（JRE+編譯工具）

jre:Java 執行時環境（JVM+類庫）

jvm:Java 虛擬機器

2.環境變數的解釋:

目的：在任意路徑下能夠直接執行相關命令。

原理：在命令列中執行某個命令時，首先在當前路徑下查詢，如果找不到則到PATH 配置的各個路徑下查詢。

3.宣告陣列的三種方式

int[] nums = new int[5]; //初始化為預設值

int[] nums = {1,2,3,4,5}; //初始化為{}中指定的值，靜態初始化

int[] nums = new int[] {1,2,3,4,5};//初始化為{}中指定的值，靜態初始化

4.java識別符號的命名規則

（1）以字母、數字、_或$組成

（2）不能以數字開頭

（3）不能使用 java 的關鍵字和保留字

  (4)  識別符號的長度沒有限制

  (5)  Java 是大小寫敏感的，所有識別符號區分大小寫

5.java的註釋有幾種

單行註釋、多行註釋、文件註釋

6. java註釋的應用場景

一般類、方法、非私有變數 用/** */，這樣他人開發用到jar中的該類時，呼叫它的人看到，生產doc文件時也能被生產出來，內部私有變數、方法裡的語句註釋用// 自己知道就行

註釋格式：
1、單行(single-line)註釋：“//……”
2、塊(block)註釋：“/*……*/”
3、文件註釋：“/**……*/”
4、javadoc 註釋標籤語法
@author  對類的說明標明開發該類模組的作者
@version  對類的說明標明該類模組的版本
@see    對類、屬性、方法的說明參考轉向，也就是相關主題
@param   對方法的說明對方法中某引數的說明
@return  對方法的說明對方法返回值的說明
@exception 對方法的說明對方法可能丟擲的異常進行說明

Java SE5內建了三種標準註解：

@Override，表示當前的方法定義將覆蓋超類中的方法。

@Deprecated，使用了註解為它的元素編譯器將發出警告，因為註解@Deprecated是不贊成使用的程式碼，被棄用的程式碼。

@SuppressWarnings，關閉不當編譯器警告資訊。

7.java的關鍵字有多少種 ?    50種

8.java的保留字有哪些?      Java 保留了 const 和 goto 關鍵字

9.java的資料型別分為哪些?   

基本資料型別     { 數值型{ 整數型別(byte,short,int,long)  浮點型別(float,double) }  字元型(char)  布林型(boolean)}

引用資料型別{類(class) 介面(interface) 陣列 }

10.說出5個String的常用方法?

(1)替換字串  replace();

(2)分割字串 split("regex");

(3)equals 字串比較

(4)length()  獲取長度、

(5) getBytes() 將一個字串轉換成位元組陣列

(6)toCharArray()將一個字串轉換成字元陣列

(7)equalsIgnoreCase(String) 忽略大小寫的比較兩個字串的內容是否一模一樣

(8)contains(String)判斷一個字串裡面是否包含指定的內容

(9)startsWith(String)判斷一個字串是否以指定的內容開頭

(10)endsWith(String)判斷一個字串是否以指定的內容結尾

(11)toUpperCase()將一個字串全部轉換成大寫

(12)toLowerCase() 將一個字串全部轉換成小寫

11.java的double型別佔用多少位?  64/8

12.常量的命名規則

(1)常量是使用 final 修飾的儲存單元

(2)全部為大寫字母表示

12.100%3的結果?  1

13.關係運算有什麼?

==  != >< >= <=

14.關係運算子的結果為什麼? true  false

15.邏輯短路與和邏輯短路或的解釋

對於|| ,只要有一個運算元為true,則結果為true

對於&& ,只要有一個運算元為false,則結果為false

16.說明for迴圈的迴圈流程

四個部分：初始化部分 A、迴圈條件 B、迴圈體 D、迭代部分 C

for(int i=0;i<20;i++)

{

    迴圈體

}

執行步驟是:

1、i=0  初始化初值；

2、 進行條件判斷i是否<20，如果條件為真，則繼續執行；

3、執行迴圈體的程式碼；

4、i++ 變數i自增一次；

5、回到第2步,一直迴圈，直到第2步條件為假時, 退出迴圈，結束。

17.break和continue的作用

break：終止直接包含的迴圈體，結束（本層）迴圈

continue：終止本次迴圈，直接執行迴圈的下一次

18.“==”和equals的區別

      ==如果比較的是數值，那麼比較的就是數值的大小，如果比較的類，那麼比較的就是記憶體地址

        equals方法，如果比較的是一個自定義的類，如果不重寫equals方法，那麼他將使用Object的equals方法

       而 Object的equals方法使用==做比較的，所以比較的是記憶體地址。如果想讓他比較內容的話，那麼就要重寫equals方法

19.說出五個jdk1.5的新特性

jdk5.0中出現的新特性 泛型（Generics） 增強的“for”迴圈（Enhanced For loop） 自動裝箱/ 自動拆箱（Autoboxing/unboxing） 型別安全的列舉（Type safe enums） 靜態匯入（Static import） 可變引數(Var args)

20.重寫

重寫：在不同類中(子父類中)。

方法宣告相同(返回型別，方法名，引數列表均相同)。

重寫需要注意：

**子類方法的訪問許可權要大於等於父類方法的訪問許可權。

**靜態只能重寫靜態。但是這種情況一般不會出現。

21.什麼是過載?

過載：在同一類中。方法名相同，引數列表不同。過載可以改變返回型別

22.Integer的取值範圍

Integer的取值範圍（-2^31~2^31-1）

最小值為 -2^31，最大值為 2^31-1

23.Integer a=128; Integer b=128;輸出a==b的結果是什麼?  false

24.byte的取值範圍  -128 至 127

25.說出十進位制和二進位制的轉換技巧?

任意進位制轉 10（係數*基數的權次冪） 10 進行轉任意進位制 （除奇倒取餘）

快速轉換法：8421 碼 (128 64 32 16 8 4 2 1) 100000

26.static可修飾什麼?

 屬性,方法,程式碼塊

27.final可以修飾什麼?

final 可以修飾： 類 變數 方法

    final修飾的類不能被繼承。

    final修飾的方法不能被重寫。

    final修飾的變數是一個常量。只能被賦值一次。

28.說說為什麼自定義一個類，使用toString輸出的不是，這個類的賦值資訊?

因為沒有重寫object的tostring()方法

29.java的訪問修飾符有哪些?

public >  protected  >default>  private

30. 為什麼靜態方法，不能輸出普通變數?

因為靜態方法是類級別的,隨著類的載入而載入,而普通變數要和例項化的那個物件繫結在一起才能夠使用，所以就產生了矛盾

31.switch的表示式裡面可以放什麼資料型別?

java 1.6(包括)以前,只是支援等價成int 基本型別的資料:byte ,short,char,int(其他的都不可以)。 1.7加入的新特性可以支援String型別的資料。

32. int a =i++和 int b =++i有什麼區別?

  int a =i++ 先賦值給a,i再自增

      int b =++i i先自增,再賦值給

字首形式：

int i = 10;

int a = ++ i; //等同於 i++; int a = i; 所以 a=11， i= 11

字尾形式：

int j = 10;

int b = j++; //等同於 int b = j; j++; 所以 b=10，j = 11

33. 為什麼String有length()?

因為string是用char型別的陣列實現的,char裡邊有length()屬性,所以string可以呼叫length();

34.類，方法，常量，包名的命名規則?

    1、類名：首字母最好大寫。

    2、類名：如果有多個單詞可以使用_區分，或者：AirBace;第二個單詞大寫。

    3、類名、方法、變數、常量名：只能是字母、下劃線、美元$符號開頭。

    4、方法名首字母小寫，如果有多個單詞可以使用_區分，或者：airBace;第二個單詞大寫。

    5、變數名跟第4項一樣。

    6、常量名：全部大寫，必須賦值、最好static、final，也就是說定義為靜態的、最終的

35.1-100的偶數和?  2550

int sum = 0;

     for (int i = 1; i <= 100; i++) {

  if (i%2==0) {

sum+=i;

}

}

     System.out.println(sum);  //2550

36.  定義一個map，新增內容（“1”，“2”）（“1”，“3”）（“2”，“4”），迴圈輸出鍵值對?

 Map<String,String> map = new HashMap<String,String>();

      map.put("1","2");

      map.put("1","3");

      map.put("2","4");

      Set<Entry<String,String>> entrySet = map.entrySet();

      for (Entry<String, String> entry : entrySet) {

System.out.println("鍵"+entry.getKey()+"=值"+entry.getValue());

 }

37.建立5個學生裡面有姓名和年齡，使用Arrays.sort()方法對年齡進行排序，然後輸出，並分析程式執行效果?

public static void main(String[] args) {

  List<student> list1 = new ArrayList<student>();

  list1.add(new student("張三",20));

  list1.add(new student("李四",15));

  list1.add(new student("張三",18));

  list1.add(new student("王五",23));

    Set<student> set = new HashSet<student>();

    set.addAll(list1);

  Collections.sort(list1);

    System.out.println(set);

}

39.編寫程式碼比較兩個自定義的類是否相等?

1、如果說兩個物件的判斷可以使用 equals，或者 ==。

2、如果判斷物件是否某個類 可以使用 instanceof ，isInstance

3、如果兩個類的比較 可以使用 isAssignableFrom，但只能得到是否是自身或者子類的結果，不能完全確定是否相同。

public static void main(String[] args) {

        String s1 = new String("javaisland");//測試兩個物件是否相同

        System.out.println(s1 instanceof String); // true

        String s2 = new String("javaisland");//測試是否物件屬於某個類

        System.out.println(String.class.isInstance(s2)); // true

        System.out.println(ArrayList.class.isAssignableFrom(Object.class)); // false

        System.out.println(Object.class.isAssignableFrom(ArrayList.class)); // true

    }

40.封裝一個靜態方法（功能自定義）

   private static void ceShi(){

System.out.println("標題");}

41.寫一個switch語句，根據相應的數字輸出星期

public static void main(String[] args) {

int i=0;

switch (i) {

case 0:

System.out.println("星期一");

break;

case 1:

System.out.println("星期二");

break;

case 2:

System.out.println("星期三");

break;

case 3:

System.out.println("星期四");

break;

case 4:

System.out.println("星期五");

break;

case 5:

System.out.println("星期六");

break;

case 6:

System.out.println("星期日");

break;

default:

}

}

42. 對String a="1,5,1,3,2,7",排序並且去重複?

 String a="1,5,1,3,2,7";

     String[] split = a.split(",");

     List<String> list = Arrays.asList(split);

     //TreeSet以升序儲存物件，所以TreeSet中儲存的物件比較能夠比較大小

     TreeSet<String> treeSet = new TreeSet<String>();

     treeSet.addAll(list);

    System.out.println(list);

    System.out.println(treeSet);

43.自定義物件如何去重

public static void main(String[] args) {

  List<student> list1 = new ArrayList<student>();

  list1.add(new student("張三",20));

  list1.add(new student("李四",15));

  list1.add(new student("張三",18));

  list1.add(new student("王五",23));

    Set<student> set = new HashSet<student>();

    set.addAll(list1);

    System.out.println(set);

}

44.自定義物件如何排序

//student類，並實現Comparable介面

class Student implements Comparable<Student>{

    //姓名，成績，年齡三個變數

    private String name;

    private int score;

    private int age;

    //構造方法

    public Student() {}

    public Student(String name, int score,int age) {

        this.name = name;

        this.score = score;

        this.age = age;

    }

    //get set 方法

    public String getName() {

        return this.name;

    }

    public int getScore() {

        return this.score;

    }

    public int getAge(){

        return this.age;

    }

    public void setName(String name) {

        this.name = name;

    }

    public void setScore(int score) {

        this.score = score;

    }

    public void setAge(int age){

        this.age = age;

    }

    //重寫toString方法

    public String toString(){

        return "姓名："+this.getName()+"\t成績："+this.getScore()+"\t年齡："+this.getAge();

    }

    @Override

    //實現Comparable的compareTo方法

    public int compareTo(Student stu) {

        // TODO Auto-generated method stub

        return this.getScore()-stu.getScore();

    }

}

public class SortList {

    public static void main(String [] args){

        //集合的定義

        List<Student> list = new ArrayList<Student>();

        //學生物件的加入

        list.add(new Student("張三",89,20));

        list.add(new Student("李四",60,21));

        list.add(new Student("路人",99,15));

        //排序

        Collections.sort(list);

        //遍歷輸出

        for(Student stu : list){

            System.out.println(stu.toString());

        }

    }

}

45.定義一個List集合，集合裡面放多個自定義的物件，如何完成去重?

public static void main(String[] args) {

  List<student> list1 = new ArrayList<student>();

  list1.add(new student("張三",20));

  list1.add(new student("李四",15));

  list1.add(new student("張三",18));

  list1.add(new student("王五",23));

    Set<student> set = new HashSet<student>();

    set.addAll(list1);

    System.out.println(set);

}

46.如何建立執行緒?

第一種方法：繼承Thread類

   第二種方法：實現Runnable介面

   第三種方法：實現callable介面

public class MyThread implements Runnable{

public static void main(String[] args) {

MyThread t = new MyThread();

Thread thread = new Thread(t);

thread.start();

}

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("執行");

}

}

47.反射建立物件,反射獲取，屬性，方法，泛型

/*

 * 反射:可以在類的執行期間,獲取到類的資訊(屬性 , 方法, 註解, 泛型等等)

 * 反射提高了程式的擴充套件性()

 *

 *   //反射的第一步,都是要獲取到Class物件---->>類的資訊

 *

 * */

public class StudentFanShe {

public void lean(){

System.out.println("在學習");

}

public void add(String a){

System.out.println("在學習");

}

public int status;

private String name;

private int age;

public StudentFanShe(String name, int age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "StudentFanShe [name=" + name + ", age=" + age + "]";

}

public StudentFanShe(){

super();

}

/*

 * 三種方式獲取到Class

 *

 */

@Test

public void getClassTest(){

//1.類名.class  student.class

//2.物件名的getClass

StudentFanShe studentFanShe = new StudentFanShe();

Class<? extends StudentFanShe> class1 = studentFanShe.getClass();

//3.Class.forName();

String name = studentFanShe.getClass().getName();

try {

Class<?> forName = Class.forName(name);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

/*

 * JunitTest這個測試工具,要求

 * 1.寫的測試方法,訪問修飾符必須是public的,返回值必須是void

 * 2.Test寫反射的時候,只能有預設的構造方法,如果有多個構造方法就會報,

 *  java.lang.IllegalArgumentException: Test class can only have one constructor

  */

@Test

public void getClassInfo(){

//1.

// Class<? extends Class> class1 = Student.class.getClass();

StudentFanShe studentFanShe = new StudentFanShe();

Class<? extends StudentFanShe> class1 = studentFanShe.getClass();

}

//獲取構造方法

public static void main(String[] args) {

//1.

// Class<? extends Class> class1 = Student.class.getClass();

StudentFanShe studentFanShe = new StudentFanShe();

Class<? extends StudentFanShe> class1 = studentFanShe.getClass();

//獲取構造方法

Constructor<?>[] constructors = class1.getConstructors();

for (Constructor<?> constructor : constructors) {

  Class<?>[] parameterTypes = constructor.getParameterTypes();

  for (Class<?> class2 : parameterTypes) {

System.out.println("constructor parameter ="+parameterTypes);

}

}

//普通方法,呼叫一個方法

Method[] methods = class1.getMethods();//利用得到的Class物件的自審，返回方法物件集合  

for (Method method : methods) {

if ("lean".equals(method.getName())) {

StudentFanShe newInstance;

try {

newInstance = StudentFanShe.class.newInstance();

System.out.println("呼叫lean方法  "+method.invoke(newInstance,null));

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

//獲取公共的屬性  用public修飾的屬性

Field[] fields = class1.getFields();//利用得到的Class物件的自審，返回屬性物件集合

for (Field field : fields) {

System.out.println("field  for");

try {

StudentFanShe newInstance = StudentFanShe.class.newInstance();

Class<?> type = field.getType();

System.out.println("字元的型別  "+type);

field.set(newInstance, 1);

System.out.println("newInstance.status="+newInstance.status);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("public修飾的屬性"+field.getName());

}

//獲取私有的屬性[獲取到全部的屬性包括私有的屬性]Field

Field[] fields1 = class1.getDeclaredFields();

//獲取註解Annotation

Annotation[] annotations = class1.getAnnotations();

//獲取泛型Generic, 獲取父類泛型是,子類必須要new

 Teacher teacher = new Teacher();

      Class<? extends Teacher> class2 = teacher.getClass();

      Class<?> superclass = class2.getSuperclass();

       Type genericSuperclass = class2.getGenericSuperclass();

     System.out.println("父類泛型"+genericSuperclass);

      System.out.println("父類"+superclass.getName());

}

}

class Teacher extends A1<String>{  

}

class A1<T>{  

}

48.什麼是泛型，泛型的作用?

java 泛型是java SE 1.5的新特性，泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。

49.什麼是樹，為什麼有紅黑樹?

樹狀圖是一種資料結構，它是由n（n>=1）個有限節點組成一個具有層次關係的集合

紅黑樹是一種比較寬泛化的平衡樹，沒AVL的平衡要求高，同時他的插入刪除都能在O（lgN）的時間內完成，而且對於其性質的維護，插入至多隻需要進行2次旋轉就可以完成，對於刪除，至多隻需要三次就可以完成，所以其統計效能要比AVL樹好

50.陣列結構的特點是什麼?

  概念：同一種資料型別的集合。

好處：可以自動給陣列中的元素從0開始編號，方便操作這些元素。

51.list集合的特點

List 中的元素可以重複,有序,List 有索引（下標）的概念,可以有null元素

52.set集合的特點

Set 中的元素不能重複,無序,Set 沒有索引的概念,可以有null元素

對於 Set 表示的集合，通常是遍歷操作，沒有 get()和 set()方法

53. 什麼是封裝，用程式碼舉例子?

封裝就是將屬性私有化，提供公有的方法訪問私有屬性。

做法就是：修改屬性的可見性來限制對屬性的訪問，併為每個屬性建立一對取值（getter）方法和賦值（setter）方法，用於對這些屬性的訪問。

如：private String name;

public String getName(){

                    return;

           }

        public void setName(String name){

                    this.name=name;

           }

54. 什麼是多型，用程式碼舉例子?

多型性是指允許不同類的物件對同一訊息作出響應。多型性包括引數化多型性和包含多型性。多型性語言

具有靈活、抽象、行為共享、程式碼共享的優勢，很好的解決了應用程式函式同名問題。
多型有兩種表現形式：過載和覆蓋

class A{
 public String f(D obj){return ("A and D");}
 public String f(A obj){return ("A and A");}
}
class B extends A{
 public String f(B obj){return ("B and B");}
 public String f(A obj){return ("B and A");}
}
class C extends B{}
class D extends B{}
public class testJava{
 public static void main(String[] args){
  A a1 = new A();
  A a2 = new B();
  B b = new B();
  C c = new C();
  D d = new D();
  System.out.println(a1.f(a1));
  System.out.println(a1.f(b));
  System.out.println(a1.f(c));
  System.out.println(a1.f(d));
  System.out.println(a2.f(a1));
  System.out.println(a2.f(b));
  System.out.println(a2.f(c));
  System.out.println(a2.f(d));
  System.out.println(b.f(a1));
  System.out.println(b.f(b));
  System.out.println(b.f(c));
  System.out.println(b.f(d));
 }
}

55.java異常的體系結構?

Throwable：

|--Error:重大的問題，我們處理不了。也不需要編寫程式碼處理。比如說記憶體溢位。

|--Exception:一般性的錯誤，是需要我們編寫程式碼進行處理的。

|--RuntimeException:執行時異常，這個我們也不需要處理。

                    其實就是為了讓他在執行時出問題，然後我們回來修改程式碼。

56.程式碼遇到異常，沒有進行處理，後面的程式碼還能執行嗎?  不能

57.程式碼遇到異常要想讓後面的程式碼，繼續執行，應該怎麼辦?  try...catch...finally

58.  如何丟擲一個編譯異常

public class exception{

@Test

public void test() throws LoginException{

A a = new A();

a.setAge(20);

System.out.println(a);

try {

a.ji(0);

} catch (java.lang.Exception e) {

e.printStackTrace();

throw new LoginException();

}

System.out.println("我執行了");

}

}

class A{

privateint age;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "A [age=" + age + "]";

}

public void ji(int b){

System.out.println(age/b);

}

}

59.如何拋異常

throw Exception用於丟擲異常

boolean testEx2() throws Exception{

        boolean ret = true;

        int b=12;

        int c;

        for (int i=2;i>=-2;i--){

            c=b/i;

            System.out.println("i="+i);

        }

        return true;    

}

60.使用io流，建立一個檔案，讀取一個檔案

public static void main(String[] args){

String fileDir="D:"+File.separator+"hepuwen";

String fileString = "www.txt";

File file = new File(fileDir);

System.out.println(fileDir);

OutputStream  outputStream =null;

try{

if (!file.isDirectory()) {

file.mkdirs();

}

String filepathString = fileDir+File.separator+fileString;

File file2  = new File(filepathString);

boolean  createNewFile = file2.createNewFile();

//進去讀出來寫

outputStream = new FileOutputStream(file2);

String string = "學習是你快樂!";

outputStream.write(string.getBytes());

}catch (Exception e) {

e.printStackTrace();

}finally{

try {

  outputStream.close();

} catch (IOException e) {

// TODO: handle exception

e.printStackTrace();

}

}

}

61.之前寫的HelloA和HelloB的程式碼執行流程必須搞明白

HelloB是HelloA的子類

靜態程式碼塊>程式碼塊>構造方法>靜態方法>普通方法

static a

static b

a的程式碼塊

a的有參構造方法

b的程式碼塊

b的有參構造方法zhangsan