Java常識點歸結總結

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
{
 //不必創立外部類實例
}