1. 程式人生 > >JAVA知識點(類、方法、構造器、許可權、修飾符、資料型別等知識點)

JAVA知識點(類、方法、構造器、許可權、修飾符、資料型別等知識點)

注意事項:

同一個包中不能有一樣的類名的類,不然編譯會出現錯誤。

(二)單例類(Singleton)

1、把構造器用private隱藏。

2、用static建立一個自定義只允許建立一個物件例項的靜態方法(這樣即使還沒建立物件,就可以由類呼叫進行檢查是否已經存在例項了並進行判斷)。

例如:

public class Singleton {
    private static Singleton instance;//使用類變數來快取曾經建立的例項;
    //對構造器用private進行修飾;
private Singleton(){}
    //提供一個靜態方法,用於返回Singleton例項,所以它的返回物件型別就是Singleton;
//該方法加入自定義控制,保證只產生一個物件; public static Singleton getInstabce(){ if(instance==null) { instance = new Singleton(); } return instance; } public static void main(String[] args) { //建立物件不同構造器; //只通過自定義方法建立物件例項; /*Singleton s1=new Singleton(); Singleton s2=new Singleton();
System.out.println("s1==s2:"+(s1==s2));*/ //這樣創建出來輸出false; //getInstance()被定義為靜態方法,在程式載入位元組碼時不用建立例項,可以由類呼叫 Singleton s1= Singleton.getInstabce(); Singleton s2=Singleton.getInstabce(); System.out.println("s1==s2:"+(s1==s2));//輸出true;

(三)匿名內部類及Lambda表示式

1、匿名內部類(實現介面/繼承父類):

看似直接定義一個介面的物件(實際介面是沒有例項物件的),實際可以認為是在定義另一個實現該介面(父類)的一個類的例項,並對介面中的抽象方法等進行實現。

(1)不能是抽象類(裡面的方法等必須是已實現的)

(2)不能定義構造器,因為沒有匿名內部類的類名。

(3)可以定義初始化塊。可以在初始化塊完成構造器裡面需要完成的任務。

2、Lambda表示式(參考:http://www.cnblogs.com/CarpenterLee/p/6507161.html):

Lambda表示式中形參列表是對應的介面中抽象方法的形參。

其中一個main函式中可以存在對應多個函式介面的Lambda表示式:

//存在一個或者多個函式介面時的在main()函式的Lambda表示式示例
interface Converter{
    Integer converter(String from);
}
////////////////////////////////
interface Mytest1{
    String test(String a,int b,int c);
}
public class Myinterface {
    public static void main(String []args){

        //Converter converter1=(from)->Integer.valueOf(from);
        //Converter converter1=Integer::valueOf;
        //Converter converter1=from->"you".indexOf(from);
Converter converter1="you"::indexOf;
Integer val=converter1.converter("u");
System.out.println(val);
///////////////////////////////////
      //對應的引數可以要麼全部加上引數型別,要麼全部不加;
        Mytest mt=(String a,int b,int c)->a.substring(b,c);
Mytest1 mt=( a, b, c)->a.substring(b,c);//Mytest mt=String::substring;String str=mt.test("jana i love you",2,9);System.out.println(str);}}

其中匿名內部類及Lambda表示式的區別:

1、匿名內部類可為任意介面建立例項——不管介面含有多少個抽象方法。

Lambda表示式只能為函式式介面建立例項(裡面只含有唯一一個抽象方法,但是可以有多個預設方法).

2、匿名內部類可以為普通類、抽象類建立例項,但是,Lambda·表示式只能為函式式介面建立。

3、匿名內部類實現的抽象方法允許呼叫介面中定義的預設方法,但是Lambda表示式不允許這樣呼叫。

二、許可權與修飾符(public、protect、private、final)

1、一般被定義為私有的屬性(private)需要設定其setter(),getter()方法,方便封裝之後被使用。

2、"構造器沒有返回值為什麼不可以用void宣告?"  

答:實際類的構造器是有返回值的,當使用new關鍵字呼叫構造器時,構造器返回該類的例項,可把該例項當做返回值。必須注意,不要在構造器中顯示使用return來返回當前類的物件,因為構造器的返回值是隱式的。

3、final修飾的成員變數必須由程式設計師顯式的指定初始值(系統不會對final成員進行隱式初始化),當該變數被賦予初始值時,就不能再被重新賦值。普通方法不能為final修飾的變數賦值。

(1)final修飾基本型別變數

①final修飾類變數(final static ):該類變數可以在宣告的時候指定類初始化時分配預設值(不推薦,最好顯示初始化)靜態語句塊中初始化(不能在普通初始化塊初始化,因為類變數在類初始階段就已經被初始化了,之後普通初始化塊就不能再對其賦值)。只在這二者之一初始化。

②final修飾的成員變數(例項變數)可以在定義時初始化,普通(必須為非靜態)初始化塊初始化(例項變數不能在靜態初始化塊制定初始值,因為靜態初始化塊是靜態成員,不可訪問例項變數),構造器中初始化,只在這三者之一。普通方法不能為final修飾的成員變數賦值。

例如:

public class FinalVariableTest {
    //定義成員變數指定預設值,合法;
final int a=6;
    final String str;//可在構造器、普通初始化塊初始化;
final int c;//可在構造器、普通初始化塊初始化;
final static double d;//靜態初始化塊;
    // final char ch; 若哪兒都沒有初始化是不合法的;
    //普通初始化塊
{
        str="Hello";
//不能重新為a賦值;
        //a=9;
}
//靜態初始化塊
static {
    d=5.6;//為類變數初始賦值;
}
public  FinalVariableTest(){
    c=5;
}
public void changeFinal(){
    //普通方法不能為final修飾的變數賦值;
    //d=2;
    //ch='a';
}
public static void main(String[] args){
    FinalVariableTest ft=new FinalVariableTest();
System.out.println(ft.a);
System.out.println(ft.c);
System.out.println(ft.d);
}
}//輸出為 6 5 5.6

(2)final修飾引用型別變數:只保證引用型別變數所引用的地址不改變,即一直引用同一個物件,但這個物件內部內容可以改變。

三、繼承

1、

四、資料型別

1、Java中有5種成員:初始化塊,成員變數,方法,構造器,內部類(包括介面、列舉)。其中,建立Java物件時,系統總是隱式先呼叫該類的定義的初始化塊,根據初始化塊所在位置從上到下執行,在構造器之前執行。因為它沒有名字,表示,所以無法通過類、物件來呼叫初始化塊,初始化塊只能用static修飾。

2、基本型別與引用型別的區別:

(1)基本型別:它的值就是一個數字,一個字元或一個布林值。

(2)引用型別:是一個物件型別,值是什麼呢?它的值是指向記憶體空間的引用,就是地址,所指向的記憶體中儲存著變數所表示的一個值或一組值除了在函式傳值的時候是"引用傳遞",在任何用"="向物件變數賦值的時候都是"引用傳遞"。

例如:

int  a;  
 a=250; //宣告變數a的同時,系統給a分配了空間。

引用型別就不是了,只給變數分配了引用空間,資料空間沒有分配,因為誰都不知道資料是什麼,整數,字元?我們看一個錯誤的例子:

MyDate today;

today.day = 4; //發生錯誤,因為today物件的資料空間未分配。

那我們怎麼給它賦值?引用型別變數在聲明後必須通過例項化開闢資料空間,才能對變數所指向的物件進行訪問。舉個例子:

MyDate today;            //將變數分配一個儲存引用的空間

today = new MyDate();     //這句話是2步,首先執行new MyDate(),給today變數開闢資料空間,然後再執行賦值操作

//引用變數賦值

MyDate a,b;                    //在記憶體開闢兩個引用空間

a  =  new MyDate();     //開闢MyDate物件的資料空間,並把該空間的首地址賦給a

b  =  a;                               //將a儲存空間中的地址寫到b的儲存空間中

如下圖示


3、包裝類

基本型別:byte、short、int、long、char、float、double、boolean

包裝類:Byte、Short、Integer、Long、Character、Float、Double、Boolean

注意:雖然包裝型別的變數是引用資料型別,但包裝類的例項可以與數值型別進行比較,直接去除包裝示例所包裝的數值進行比較,例如:

Integer a=new Integer(6);
//輸出true ;
System.out.println("6的包裝類例項是否大於5.0"+(a>5.0));

但是和下例相對比:

原因:這與Java的Integer的設計有關,系統把一個-128~127之間的整數自動裝箱成Integer例項,並放入一個名為cache的陣列中快取起來。所以只要是例項-128~127之間的整數就會在同一個空間中,地址相等,超出範圍就重新建立shil

//輸出true
Integer a=2;//通過自動裝箱,允許把基本型別賦值給包裝類例項;
Integer c=2;
System.out.println("比較2個包裝類例項是否相等"+(a==c));
//輸出false
Integer d=128;
Integer e=128;
System.out.println("比較2個包裝類例項是否相等"+(d==e));

但是,因為包裝類的例項實際上是引用型別,只有兩個包裝類引用同一個物件時才會返回ture。例如:

//輸出false
System.out.println("比較2個包裝類例項是否相等"+(new Integer(2)==new Integer(2)));

同下例,因為利用了關鍵字new建立了不同的記憶體空間:

//輸出false
Integer a=new Integer (2);
Integer c=new Integer (2);
System.out.println("比較2個包裝類例項是否相等"+(a==c));
4、String(final)

Example:

String s1 = "abc";

String s2 = "abc";

System.out.print(s1==s2);

執行結果是:true

因為,String s = "abc"這種形式可以看做我們聲明瞭一個值為”abc”的字串物件引用變數,由於String類是final的,所以事實上,可以看做是聲明瞭一個字串引用常量, 存放在常量池中(棧中)。如果是使用關鍵字new這種形式宣告出的,則是在程式執行期被動態建立,存放在中。

String s = “abc”的工作過程可以分為以下幾個步驟:

 (1)定義了一個名為"s"的String型別的引用。

 (2)檢查在常量池中是否存在值為"abc"的字串物件;

 (3)如果不存在,則在常量池(字串池)建立儲存進一個值為"abc"的字串物件。如果已經存在,則跳過這一步工作。

 (4)將物件引用s指向字串池當中的”abc“物件。

String s = new String(”abc“)的步驟則為:

 (1)定義了一個名為"s"的String型別的引用。

 (2)檢查在常量池中是否存在值為"abc"的字串物件;

 (3)如果不存在,則在常量池(字串池)儲存進一個值為"abc"的字串物件。如果已經存在,則跳過這一步工作。

 (4)在堆中建立儲存一個”abc“字串物件。

 (5)將物件引用指向堆中的物件。

這也就是為什麼有道面試題:String s = new String(“xyz”);產生幾個物件?的答案是:一個或兩個的原因。因為如果常量池中原來沒有”xyz”,就是兩個。

如果需要把基本型別變數→字串

(1)可將基本型別變數與“”進行連線。例如:

//intstr的值為"5";
String intstr=5+""

(2)利用valueOf()方法把基本型別轉換成字串,例如:

//把float變數轉換成String變數;
String ftstr =String.valueOf(2.34764);
System.out.println(ftstr);
而字串轉成基本型別則可使用包裝類提供的靜態方法parseXxx(String s)。

eg: parseInt(),parseFloat().....

5、很多語言都不允許通過獨享訪問類變數,物件只能訪問例項變數,類變數必須通過類來訪問。(其實主要是例項變數和類變數兩大類

(1)類變數:

①也叫靜態變數,在類中以static關鍵字宣告,但必須在方法構造方法和語句塊之外。

靜態變數除了被宣告為常量外很少使用。常量是指宣告為public/private,final和static型別的變數,很少單獨使用static宣告變數。

③預設值和例項變數相似。數值型變數預設值是0,布林型預設值是false,引用型別預設值是null。

④可通過例項物件訪問,也可通過類來訪問,即使某個例項是null,null也可以訪問它所屬的類成員.

(2)例項變量:

①“例項變數”,在實體類或資料類中被稱為“屬性”或“欄位”,宣告在一個類中,但在方法、構造方法和語句塊之外。例項變數在物件建立的時候建立,在物件被銷燬的時候銷燬。

②例項變數的值應該至少被一個方法、構造方法或者語句塊引用,使得外部能夠通過這些方式獲取例項變數資訊

③例項變數對於類中的方法、構造方法或者語句塊是可見的。一般情況下應該把例項變數設為私有。通過使用訪問修飾符可以使例項變數對子類可見。

④例項變數具有預設值。數值型變數的預設值是0,布林型變數的預設值是false,引用型別變數的預設值是null。變數的值可以在宣告時指定,也可以在構造方法中指定。

(3)成員變數:

①類中的屬性,獨立於方法之外,與例項變數重疊,有些類變數也是成員變數。

(4)區域性變數:

類的方法、構造器中的變數,是被區域性使用的。

例1:

public class Variable{

    static int allClicks=0;//類變數
String str="hello world";//例項變數、成員變數
public void method(){

        int i =0;//區域性變數
int a;//區域性變數
}

}
例2:
public class StaticTest {

    private static int staticInt = 2;
    private int random = 2;
    public StaticTest() {
        staticInt++;
random++;
System.out.println("staticInt = "+staticInt+"  random = "+random);
}

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
StaticTest test2 = new StaticTest();
}
}
//執行結果:
//staticInt = 3  random = 3
//staticInt = 4  random = 3//每次建立物件重新呼叫全新的構造器,重新加1
例3:
public class Temp {
    static int t; //類變數  
public static void main(String args[]){
        System.out.println(t; //列印類變數  
int t = 1; //區域性變數  
System.out.println(t); //列印區域性變數  
Temp a = new Temp(); //建立例項  
System.out.println(a.t; //通過例項訪問例項變數  
}
}      //結果為:0 1 0

四、集合

1、Stream

參考連結:

http://www.cnblogs.com/CarpenterLee/p/6545321.html

http://www.cnblogs.com/CarpenterLee/p/6550212.html

五、IO

1、問題:這個物件不是檔案嗎?為什麼還要呼叫其他方法再次建立檔案。

答:File類例項化,比如 File f=new File("E:/file_ceshi/02.rmvb");只是指向了這個02.rmvb檔案,如果不建立02.rmvb,此檔案是不存在的。因為程式碼只是宣告不是執行,否則會出錯。

相關推薦

JAVA知識點方法構造許可權修飾資料型別知識點

注意事項: 同一個包中不能有一樣的類名的類,不然編譯會出現錯誤。 (二)單例類(Singleton) 1、把構造器用private隱藏。 2、用static建立一個自定義只允許建立一個物件例項的靜態方法(這樣即使還沒建立物件,就可以由類呼叫進行檢查是否已經存在例項了並進行

Effective Java-考慮用靜態工廠方法代替構造

public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE; } //使用構造器 Boolean b1 = new Boolean(true); //使用靜態工廠方

effective Java 1 使用靜態工廠方法代替構造

jdk Boolean類的原始碼:public final class Boolean implements java.io.Serializable, Comparable<Boolean> { public static final

[Effective Java]考慮用靜態工廠方法代替構造

本文主要介紹如何使用靜態工廠方法已經在那種場合來使用這種方式代替構造方法。        眾所周知,對於類而言,我們為了獲得一個類的例項物件,通常情況下會提供一個公有的(public) 的構造器。當然

day4繼承修飾方法的重寫super關鍵詞繼承中的構造方法object對象轉型

編程 權限 數列 als str list 兩個 instance 變量 1.類的繼承(extends)通過繼承,子類自動擁有父類的所有成員(成員變量和成員發方法)一個子類只能有一個父類,一個父類可以派生多個子類 2.訪問修飾符(private 默認 protected

java入門型轉換串操作

過程 boolean ava 字符串 符號 兩個 uppercase rim 算術 java基礎數據類型:不能=null;  四類八種:     整數型:       byte 2的8次方       short 2的16次方      int 2的32次方  

java中String常用方法屬性

col clas equal ack length ++ ava eal rgs package Head18; public class java09 { public static void main(String[] args) { St

java面向對象學習之——java中的修飾成員變量修飾方法修飾

16px 實例化 同時 pan 相同 nbsp 激活 fin ati 類修飾符: public(訪問控制符)——>將一個類聲明為公共類,他可以被任何對象訪問,一個程序的主類必須是公共類。abstract——>將一個類聲明為抽象類,沒有實現的方法,需要子類提供方法

Java學習日常多型包裝final修飾抽象

學習內容 多型中的instanceof運算子 public class Client1 { public static void main(String[] args) { Animal tom = new Dog(); Anim

Java 知識點整理-4.面向物件許可權修飾內部類1~38+ 面向物件一點補充

1、包package的概述:Ⅰ.將位元組碼(.class)進行分類存放。 Ⅱ.包其實就是資料夾。 2、包的命名:域名倒著寫。 3、定義包的格式:package 包名; 多級包用.分開即可。 4、定義包的注意事項:ⅰ.package語句必須是程式的第一條可執行的程式碼。ⅱ.pac

java synchronized靜態同步方法非靜態同步方法及同步塊

同步方法   同步方法所擁有的鎖就是該方法所屬的類的物件鎖,換句話說,也就是this物件,而且鎖的作用域也是整個方法,這可能導致其鎖的作用域可能太大,也有可能引起死鎖,同時因為可能包含了不需要進行同步的程式碼塊在內,也會降低程式的執行效率。 同步方法的鎖   同

JAVA】基礎:面向物件:抽象封裝繼承多型方法重寫訪問修飾關鍵字(this,super,static,final)抽象介面

面向物件概念: 面向過程:完成一件事情任何過程自己親力親為。 面向物件:找能完成這件事的物件。在java中就是找物件,調方法。 面向物件特徵:抽象,封裝,繼承,多型 類和物件的關係: 類:生活中事物的統稱,如動物,車,服裝,食品… 物件:就是類下面實實在在存在的個體,如動物類的物件就是:

Java基礎學習 三 (和物件和成員修飾this關鍵字成員的初始化構造初始化)

面向物件的基本概念 類和物件   1.類的宣告 [修飾符關鍵字] class 類名 [extends 父類名] [implements 介面1,介面2]{ //類的主體內容 } public class tt extends Test implements Te

java基本數據修飾運算

char 異或 引用數據類型 false 修飾 位運算 java amp 取值 數據類型: 基本數據類型 整數類型 byte,8位 short,16位 int,32位i long,64位 浮點類型 float,單精度,32位 double,雙精度,64位 布爾類

Java面向對象staticfinal匿名對象內部類修飾代碼塊

固定 介紹 常量 屬於 權限 功能 復雜 art 代碼區 面向對象 今日內容介紹 u final u static u 匿名對象 u 內部類 u 包的聲明與訪問 u 四種訪問修飾符 u 代碼塊 第1章 final關鍵字 1.1 final的概念 繼承的出現提高了代碼的復用性

用靜態工廠方法代替構造遇到多個構造參數時要考慮用構建

泛型 不用 推斷 frame public 多參數 eof ram api 一、用靜態工廠方法代替構造器 類通過共有的構造方法可以提供很大的優點:1、構造方法可一有不同的名字,我們可以通過名字區分構造什麽樣子的對象,而構造器名字相同,當參數列表的數目相同 順序不同時 很大的

【Effective Java讀書筆記】創建和銷毀對象:考慮使用靜態工廠方法代替構造

返回對象 boolean 簡化 將不 其他 種類型 bigint color pre 類可以提供一個靜態方法,返回類的一個靜態實例,如Boolean包裝類的一個獲取實例的靜態方法 1 public static Boolean valueOf(boolean b) { 2

Java物件學習之建立物件——使用靜態工廠方法代替構造優點

最近學習Android知識,發現Java好多的基礎知識運用的真的很一般,所以決定在重新梳理一下,現在Kotlin也來了,在Android之路上,留給我看Java的時間不多了。       靜態我們就來簡單介紹一下,使用靜態工廠方法建立物件相較於構造器建立的物件的優缺

Java物件學習之建立物件——使用靜態工廠方法代替構造優點

最近學習Android知識,發現Java好多的基礎知識運用的真的很一般,所以決定在重新梳理一下,現在Kotlin也來了,在Android之路上,留給我看Java的時間不多了。       靜態我們就來簡單介紹一下,使用靜態工廠方法建立物件相較於構造器建立的物件的優缺

Java物件學習之建立物件——使用靜態工廠方法代替構造優點

      最近學習Android知識,發現Java好多的基礎知識運用的真的很一般,所以決定在重新梳理一下,現在Kotlin也來了,在Android之路上,留給我看Java的時間不多了。       靜態我們就來簡單介紹一下,使用靜態工