Java 類與對象重難點詳解
什么是類、對象?
因為計算機并不能像我們?nèi)诉@樣去理解世界上的東西,所以為了更好的編輯,就抽象出了類和對象。類就是把功能放在一起,然后由一個人去調用這個功能,然后再編輯對應的功能。調用者就是對象的實現(xiàn)者
類和類的實例化
類是一類對象的統(tǒng)稱,對象就是這一類具體化的實例
創(chuàng)建類的關鍵字:class
舉例:我們坐年糕的模子就是一個類,而通過這個模子可以做出月餅。在這個例子當中,類就是模具,年糕就是實例化的對象。一個類可以實例化很多對象。舉例:
class Person { public String name; public int age; } public static void main1(String[] args) { Person person1 = new Person(); Person person2 = new Person(); Person person3 = null; }
Person 就是一個類,里面的 name 和 int 就是類的成員(字段)。這里的 person1 就是引用,指向的是后面 new 的對象,因為是引用,所以也可以指向 null 。person3 就是指向空(null)引用。person1 person2 person3 就是實例化的對象。
字段的初始化
字段就是類里面的成員。在創(chuàng)建這些成員的時候就可以初始化。例如:
class Person { public String name = "Lockey"; public int age = 10; }
這里就是創(chuàng)建的時候對其進行初始化。其實并不建議直接初始化,建議在類的調用者使用的時候再初始化。如下:
class Person { public String name; public int age; } public static void main(String[] args) { Person person1 = new Person(); person1.name = "Lockey"; person1.age = 10; System.out.println(person1.name); System.out.println(person1.age); }
這里就是在類的調用者里面對類的字段進行賦值,在 main 方法當中通過引用調用。
類當中實現(xiàn)方法
就像上面的例子,如果類的調用者需要名字和年齡的時候,輸出兩行比較麻煩,類的實現(xiàn)者就可以在類內(nèi)寫一個方法,直接返回名字和年齡。示例:
class Person { public String name; public int age; public void print() { System.out.println("姓名:"+name+" 年齡:"+age); } } public static void main(String[] args) { Person person1 = new Person(); person1.name = "Lockey"; person1.age = 10; person1.print(); }
static 靜態(tài)關鍵字
static 可以修飾方法,屬性。要注意的是:static 修飾的變量通過類名訪問。直接舉例說明:
class Person { public int a; public static int count; } public static void main(String[] args) { Person person1 = new Person(); person1.a++; person1.count++; System.out.println(person1.a); System.out.println(Person.count); Person person2 = new Person(); person2.a++; person2.count++; System.out.println(person2.a); System.out.println(person2.count); }
如圖,count 第二次輸出為 2 。這是因為 conut 是被 static 修飾的變量,被 static 修飾之后就變成了常量,就在靜態(tài)區(qū)了。所以每個引用當中調用的 count 沒變。所以第二次改變 count 的值的時候,就變成 2 了。當 static 修飾方法的時候,無需再創(chuàng)建對象,直接拿類名調用就行了。舉例:
class Person { public static int count; public static void change() { count = 100; } } public static void main(String[] args) { Person.change(); System.out.println(Person.count); }
通過類名的調用直接訪問 static 修飾的變量。
封裝
因為代碼實現(xiàn)的軟件很復雜,所以就出現(xiàn)了類,但是為了閱讀性更高,就出現(xiàn)了封裝。就是把一個類的內(nèi)容實現(xiàn)為只剩一個或幾個接口,方便類的調用者訪問,這樣就降低了代碼的復雜程度。
private 實現(xiàn)封裝
private 就是修飾成員變量或方法的關鍵字,被 private 修飾之后,就不能被類外的調用者訪問了。所以就可以配合 public 來實現(xiàn)對外的接口。例如:
class Person { private String name = "Lockey"; private int age = 10; public void print() { System.out.println("名字是:"+name+" 年齡:"+age); } } public static void main(String[] args) { Person person = new Person(); person.print(); }
這里就是利用 private 封裝屬性,使其只能在類內(nèi)被訪問到。而提供的 public 接口,就讓類的調用者在類外就可以訪問到了。所以在類外直接調用 print 方法就好了。
setter 和 getter 方法
當我們把字段(name age)設置為 private 屬性時,就無法在類外進行初始化了,所以就又出現(xiàn)了新的方法:
setter :在類外直接調用此方法,然后設置一個值。
有了 setter 就又有了 getter 方法。getter 就是獲取字段數(shù)的值。通過類外調用,將字段設置為此值。代碼示例:
class Person { private String name; private int age; public String getName() { return name; } public void setName(String name1) { name = name1; } public int getAge() { return age; } public void setAge(int age1) { age = age1; } public void print() { System.out.println("名字是:"+name+" 年齡:"+age); } } public static void main(String[] args) { Person person = new Person(); person.setName("Lockey"); person.getName(); person.setAge(10); person.getAge(); person.print(); }
這里就是調用 getter 和 setter 方法,在類外進行訪問,因為 private 對 name 和 age 做了封裝。
構造方法
方法名和類名是相同的,且構造方法沒有返回值。調用完構造方法之后,對象才會產(chǎn)生。
一個對象的產(chǎn)生:
1 為對象分配內(nèi)存。
2 調用合適的構造方法。
class Person { public Person() { System.out.println("Person 不帶參數(shù)的構造方法"); } } public static void main(String[] args) { Person person = new Person(); }
這里就是實例化類的對象的時候調用的構造方法,因為我們自己寫了構造方法,所以這里就調用我i們寫過的。就輸出了如圖所示的內(nèi)容。需要注意的是:如果沒有實現(xiàn)如何的構造方法,編譯器會幫我們默認生成有個不帶參數(shù)的構造方法。也就是說,一個類,至少會有一個構造方法。
除了上面這種構造方法,我們還能寫帶有參數(shù)的構造方法。例如:
class Person { private String name; public Person(String name1) { name = name1; System.out.println("Person(String) 帶一個參數(shù)的構造方法"); } } public static void main(String[] args) { Person person = new Person("Lockey"); }
如圖:在類初始化的時候,傳入?yún)?shù) “Lockey” 在類實例化的時候就是調用有參數(shù)的構造方法。既然能傳參數(shù),那是否可以傳多個參數(shù)呢?答案是可以的。例如:
class Person { private String name; private int age; public Person(String name1, int age1) { name = name1; age = age1; System.out.println("Person(String, int) 帶兩個參數(shù)的構造方法"); } } public static void main(String[] args) { Person person = new Person("Lockey",10); }
如圖,調用的就是傳了兩個參數(shù)的構造方法。通過觀察上面的例子,我們可以發(fā)現(xiàn):構造方法也是支持重載的。
this 關鍵字
在類當中,this 表示當前對象的引用(不是當前對象),可以通過 this 來訪問類當中的字段和方法。用 this 的話,會降低出現(xiàn) bug 的概率,并且增加代碼的可讀性。例如使用 getter 和 setter 的時候,就可以用 this ,能多用 this 就多用 this 。
class Person { private String name; private int 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; } }
匿名對象
匿名對象就是沒有名字的對象。
沒有引用的對象稱為匿名對象.
匿名對象只能在創(chuàng)建對象時使用.
如果一個對象只是用一次, 后面不需要用了, 可以考慮使用匿名對象.
代碼示例:
class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void print() { System.out.println("名字是:"+name+" 年齡:"+age); } } public static void main(String[] args) { new Person("Lockey",10).print(); }
匿名對象的缺點就是只能調用一次。
到此這篇關于Java 類與對象重難點詳解的文章就介紹到這了,更多相關Java 類與對象內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家!
相關文章
Spring Cloud Config配置文件使用對稱加密的方法
Spring Cloud Config提供了兩種加密解密方式,一種是對稱加密,一種是非對稱加密。這篇文章將先展示如何使用對稱加密。感興趣的朋友跟隨腳步之家小編一起學習吧2018-05-05