Java知識點歸納總結

作者：Eve Cole 更新時間：2024-11-18 11:24:01

1. 基本資料類型

整形：

byte 1 個位元組

short 2 個位元組

int 4個位元組

long 8個位元組

字元：

char 2個位元組

浮點數：

float 4個位元組

double 8個位元組

布爾：

boolean 1個位元組

2.java 7 新增二進位整數

以0b或0B開頭

3.java中字元時16位元的Unicode編碼方式，格式是'/uXXXX'，其中xxxx代表一個十六進位整數

4.java中規定了正無窮大、負無窮大和零

正無窮大= 一個正數除以0

負無窮大= 一個負數除以零

0.0 除以0.0 或對一個負數開方得到一個非數

5. 在java中布林類型只能是true和false

6. 在java中沒有多維數組

看似像C語言中的多維數組不是真正的數組，例如a[3][4] , a[0] a[1] a[2] 是真實存在的，裝的是地址，和c語言中動態分配為的數組一樣

int [][] b = new int[3][4]

7. Java中帶包的編譯方法

javac -d . Hello.java 會在目前目錄下產生目錄樹

運行java 套件名字.類別名字

8. Java多態中的物件的filed 不具有多態性，如父類別物件= new 子類別（），物件.field 是呼叫的父類別的，即使子類別中覆蓋了該欄位。

9. instanceof 運算符

格式：引用變數名稱instanceof 類別名稱（或介面）他用來判斷前面的物件是否是後面物件的類，子類別、實作類別的實例，是傳回true，否者回傳false

10. Java 中基本資料型別與對應封裝類別之間的轉化

int a = 1;
Integer A = new Integer(a);
a = A.intValue();

其他的類型也是這樣的。

11.單例（singleton）類別例子

複製代碼代碼如下:

class Singleton
{
private static Singleton instance;
private Singleton(){}
public static Singleton getInstance()
{
if(instance == null)
{
instance = new Singleton();
}
return instance;
}

public static void main(String[] args)
{
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s1 == s2);
}
}

12.final修飾的成員變數初始化問題

類別Field：必須在靜態初始區塊中或宣告該FIeld時指定初始值

實例Field：必須在非靜態初始區塊中或聲明該FIeld時指定初始值或建構器中聲明

13.Final 變數必須明確初始化，系統不會對final變數進行隱式初始化

14.java會使用常數池來管理曾經用過的字串直接常數，例如：String a = "java"; ，系統把常數字串「java」存在常數池，當再次執行String b = "java"; a == b 是true

15.final 方法不可以重寫，final類別不能被繼承

如果用private 方法和final private 是一樣的

若果是用final修飾的方法在子類別中出現，那是子類別新定義的，與父類別沒有關係

16.不可變類別：創建後該類別的Field是不可改變的。 java提供了8個基本變數的包裝類別和string都是不可改變類別。

17.快取實例的不可改變類

複製代碼代碼如下:

class CacheImmutale
{
private static int MAX_SIZE = 10;
private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
private static int pos = 0;
private final String name;
private CacheImmutale(String name)
{
this. name = name;
}
public String getName()
{
return name;
}
public static CacheImmutale valueOf(String name)
{
for(int i = 0; i < MAX_SIZE; ++i)
{
if(cache[i] != null && cache[i].getName().equals(name))
return cache[i];
}
if(pos == MAX_SIZE)
{
cache[0] = new CacheImmutale(name);
pos = 1;
}
else
{
cache[pos++] = new CacheImmutale(name);
}
return cache[pos -1];
}

public boolean equals(Object obj)
{
if(this == obj)
return true;
if(obj != null && obj.getClass() == CacheImmutale.class)
{
CacheImmutale ci = (CacheImmutale)obj;
return name.equals(ci.getName());
}
return false;
}
public int hashCode()
{
return name.hashCode();
}
}

public class CacheImmuteTest
{
public static void main(String[] args)
{
CacheImmutale c1 = CacheImmutale.valueOf("Hello");
CacheImmutale c2 = CacheImmutale.valueOf("Hello");
System.out.println(c1 == c2);
}
}

用快取實例要看某個物件的使用頻率，若重複使用那就利大於弊，若不常使用那弊就大於利

還有java提供的java.lang.Integer 創建數值在-128-127之間的數採用快取機制的

Integer in2 = Integer.valueOf(6);

Integer in3= Integer.valueOf(6);

in2 == in3 is true;

18. static 和abstract 不能同時修飾一個方法，沒有類別抽象方法

19.一個類別可以另一個父類，實作多個接口，接口中Filed是public 、static、final的，方法是public abstract的

20.非靜態內部類別的方法存取某個變量，搜尋順序為：先內部類別中方法內-> 內部類別-> 外部類別中如果都找不到則出現編譯錯誤

複製代碼代碼如下:

import java.util.*;

public class DiscernVariable
{
private String prop = "外部類別的實例變數";
private class InClass
{
private String prop = "內部類別的實例變數";
public void info()
{
String prop = "局部變數";
System.out.println("外部類別的field值：" + DiscernVariable.this.prop);
System.out.println("內部類別的field值：" + this.prop);
System.out.println("局部變數的值：" + prop);
}
}
public void test()
{
InClass in = new InClass();
in.info();
}
public static void main(String[] args)
{
new DiscernVariable().test();
}
}

21.非靜態內部類別不能有靜態方法、靜態Field、靜態初始化區塊

22.在外部類別之外存取內部類別

存取非靜態內部類別：outclass.Inclass varname = new outclass().new InClass();
存取靜態內部類別： outclass.Inclass varname = new outclass.Inclass();

複製代碼代碼如下:

import java.util.*;

class Out
{
class In
{
public In()
{
System.out.println("非靜態內部類別建構器");
}
}
}

public class CreatInnerInstance
{
public static void main(String[] args)
{
Out.In in = new Out().new In();
/*
以上的程式碼可分開寫為：
Out.In in;
Out out = new Out();
in = out.new In();
*/
}
}

class SubClass extends Out.In
{
//顯示定義SubClass的建構器
public SubClass(Out out)
{
//透過轉入的Out物件顯示呼叫In的建構器
out.super();
}
}

複製代碼代碼如下:

import java.util.*;

class StaticOut
{
static class StaticIn
{
public StaticIn()
{
System.out.println("靜態內部類別建構器");
}
}
}

public class CreatStaticInnerInstance
{
public static void main(String[] args)
{
StaticOut.StaticIn in = new StaticOut.StaticIn();
/*
以上的程式碼可分開寫為：
StaticOut.StaticIn in;
in = new StaticOut.StaticIn();
*/
}
}

class SubClass extends StaticOut.StaticIn
{
//無須建立內部類別實例
}