Java中類與對象的相關知識點總結
一、面向過程與面向對象的理解
C語言是面向過程的，關注的是過程，分析出求解問題的步驟，通過函數(shù)調用逐步解決問題。
JAVA是基于面向對象的，關注的是對象，將一件事情拆分成不同的對象，靠對象之間的交互完成。
面向過程注重的是過程，指的是在整個過程中所涉及的行為。
面向對象注重的是對象，也就是參與過程所涉及到的主體。是通過邏輯將一個個功能實現(xiàn)連接起來。
面向過程： 1.把冰箱打開 2. 把東西放入 3. 冰箱關起來 面向對象： 打開冰箱，儲存，關閉都是對冰箱的操作，是冰箱被動的行為。冰箱就是一個對象，所以只要操作冰箱所具備的功能，都要定義在冰箱中（即類）。
二、類與對象的理解與認識
類就是一類對象的統(tǒng)稱。對象就是這一類具體化的一個實例。類可以比喻為一個一個的模板，里面可能會含有許多屬性或者功能。而按照模板實例化產生的叫對象。一個模板能夠實例化多個對象。
聲明一個類就是創(chuàng)建一個新的數(shù)據(jù)類型，而類在 Java 中屬于引用類型， Java 使用關鍵字 class 來聲明類。下面是聲明類的定義：
// 創(chuàng)建類
class <class_name>{
field;//成員屬性
method;//成員方法
}
// 實例化對象
<class_name> <對象名> = new <class_name>();
class為定義類的關鍵字，ClassName為類的名字，{}中為類的主體。
類中的元素稱為：成員屬性。類中的函數(shù)稱為：成員方法。
示例：這里就聲明了一個類
class Person {
public int age;//成員屬性 實例變量
public String name;
public String sex;
public void eat() {//成員方法
System.out.println("吃飯!");
}
public void sleep() {
System.out.println("睡覺!");
}
}
class Person {
public int age;//成員屬性 實例變量
public String name;
public String sex;
public void eat() {//成員方法
System.out.println("吃飯!");
}
public void sleep() {
System.out.println("睡覺!");
}
}
public class Main{
public static void main(String[] args) {
Person person = new Person();//通過new實例化對象
person.eat();//成員方法調用需要通過對象的引用調用
person.sleep();
//產生對象 實例化對象
Person person2 = new Person();
Person person3 = new Person();
}
}
輸出結果為：
吃飯!
睡覺!
注意事項：
- new 關鍵字用于創(chuàng)建一個對象的實例。
- 使用 . 來訪問對象中的屬性和方法。
- 同一個類可以創(chuàng)建多個實例。
三、類的成員
類的成員可以包含以下：字段、方法、代碼塊、內部類和接口等。此處重點介紹前面三個。
1.字段/屬性/成員變量
在類中、而方法外部定義的變量稱為 “字段” 或 “屬性” 或 “成員變量”(三種稱呼都可以, 一般不會嚴格區(qū)分)
class Person {
public String name; // 字段
public int age; }
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
System.out.println(person.age);
}
}
// 執(zhí)行結果
null
0
注意事項：
- 使用 . 訪問對象的字段。
- “訪問” 既包含讀, 也包含寫.
- 對于一個對象的字段如果沒有顯式設置初始值, 那么會被設置一個默認的初值。
默認值規(guī)則
對于各種數(shù)字類型, 默認值為 0.
對于 boolean 類型, 默認值為 false.
對于引用類型(String, Array, 以及自定制類), 默認值為 null
2.對null的基本認識
null 在 Java 中為 “空引用”, 表示不引用任何對象. 類似于 C 語言中的空指針. 如果對 null 進行 . 操作就會引發(fā)異常。
class Person {
public String name;
public int age; }
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name.length()); // 獲取字符串長度
}
}
// 執(zhí)行結果
Exception in thread "main" java.lang.NullPointerException //空指針異常
at Test.main(Test.java:9)
字段就地初始化：
雖然此時我們都不想屬性都為默認值而需要就地初始化，但是后面我們會講到盡量不要用字段的就地初始化，否則程序會顯得非常死板。
class Person {
public String name = "張三";
public int age = 18;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
System.out.println(person.age);
}
}
// 執(zhí)行結果
張三
18
引用中需要注意的地方：
1.下面這段代碼指的是person2這個引用指向person引用指向的對象。
public static void main(String[] args) {
Person person = new Person();
Person person2 = person;
}
2.一個引用無法指向多個對象，即使多次指向對象后，最后指向的只能是最后一次指向的對象。
3.我們知道了局部變量是在棧上開辟內存的，而它存儲的是地址，也稱為引用。那么引用一定是在棧上嗎？？ 答案是否定的，看下面的代碼：
class Person {
public String name ;
public int age ;
}
public class TestDemo {
Person person = new Person();
public static void main(String[] args) {
TestDemo testDemo = new TestDemo();
}
}
內存布局：
3.方法 (method)
用于描述一個對象的具體行為叫做方法。
class Person {
public int age = 18;
public String name = "張三";
public void show() { //show方法
System.out.println("我叫" + name + ", 今年" + age + "歲");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
// 執(zhí)行結果
我叫張三, 今年18歲
這樣的 show 方法是和 person 實例相關聯(lián)的，如果創(chuàng)建了其他實例，并且講類當中的屬性重新賦值，那么 show 的行為就會發(fā)生變化。
Person person2 = new Person(); person2.name = "李四"; person2.age = 20; person2.show(); // 執(zhí)行結果 我叫李四, 今年20歲
4.static 關鍵字
static關鍵字的作用：
- 修飾屬性 （內存開辟在方法區(qū)中）
- 修飾方法 （只有調用方法時才在棧中開辟內存）
- 代碼塊(本課件中會介紹)
- 修飾類(后面講內部類會講到)
1)修飾屬性：Java靜態(tài)屬性和類相關, 和具體的實例無關。換句話說, 同一個類的不同實例共用同一個靜態(tài)屬性。
class TestDemo{
public int a;
public static int count; }
public class Main{
public static void main(String[] args) {
TestDemo t1 = new TestDemo();
t1.a++;
TestDemo.count++;
System.out.println(t1.a);
System.out.println(TestDemo.count);
System.out.println("============");
TestDemo t2 = new TestDemo();
t2.a++;
TestDemo.count++;
System.out.println(t2.a);
System.out.println(TestDemo.count);
}
}
輸出結果：
1
1
============
1
2
若需要調用類當中的有static的屬性，則只需要類名.屬性 即可調用，而不能對象名.屬性 來調用，否則編譯器會報警告。
被static修飾的成員變量的內存在方法區(qū)中開辟，因為它不屬于對象因此不在堆上開辟內存；而在方法區(qū)中開辟內存開辟且僅開辟一次。
下圖體現(xiàn)出對象、類、屬性（實例成員變量、靜態(tài)成員變量）之間的關系。
2) 修飾方法
如果在任何方法上應用 static 關鍵字，此方法稱為靜態(tài)方法。
- 靜態(tài)方法屬于類，而不屬于類的對象。
- 可以直接調用靜態(tài)方法，而無需創(chuàng)建類的實例。
- 靜態(tài)方法可以訪問靜態(tài)數(shù)據(jù)成員，并可以更改靜態(tài)數(shù)據(jù)成員的值。
class TestDemo{
public int a;
public static int count;
public static void change() {
count = 100;
//a = 10; error 不可以訪問非靜態(tài)數(shù)據(jù)成員
}
}
public class Main{
public static void main(String[] args) {
TestDemo.change()；//無需創(chuàng)建實例對象 就可以調用
System.out.println(TestDemo.count);
}
}
輸出結果：
100
注意事項：靜態(tài)方法和實例無關, 而是和類相關. 因此這導致了兩個情況:
- 靜態(tài)方法不能直接使用非靜態(tài)數(shù)據(jù)成員或調用非靜態(tài)方法(非靜態(tài)數(shù)據(jù)成員和方法都是和實例相關的).
- this和super兩個關鍵字不能在靜態(tài)上下文中使用(this 是當前實例的引用, super是當前實例父類實例的引用, 也是和當前實例相關)
- 因為main方法為static方法，因此只能實例化其他類后才能調用其他類中的實例成員變量或實例成員方法，當然main方法也可以直接用類名去調用其他類中的靜態(tài)成員變量或靜態(tài)方法。
- 靜態(tài)變量是屬于類的，因此在方法中不能定義被static修飾的靜態(tài)方法（包括普通方法和靜態(tài)方法），但是可以初始化或者使用。
- 普通方法中可以調用靜態(tài)方法，而靜態(tài)方法中不能調用普通方法，卻又可以調用其它的靜態(tài)方法。
觀察以下代碼及理解其內存布局：
class Person {
public int age;//實例變量 存放在對象內
public String name;//實例變量
public String sex;//實例變量
public static int count;//類變量也叫靜態(tài)變量，編譯時已經產生，屬于類本身，且只有一份。存放在方法區(qū)
public final int SIZE = 10;//被final修飾的叫常量，也屬于對象。 被final修飾，后續(xù)不可更改
public static final int COUNT = 99;//靜態(tài)的常量，屬于類本身，只有一份 被final修飾，后續(xù)不可更
改
//實例成員函數(shù)
public void eat() {
int a = 10;//局部變量
System.out.println("eat()!");
}
//實例成員函數(shù)
public void sleep() {
System.out.println("sleep()!");
}
//靜態(tài)成員函數(shù)
public static void staticTest(){
//不能訪問非靜態(tài)成員
//sex = "man"; error
System.out.println("StaticTest()");
}
}
public class Main{
public static void main(String[] args) {
//產生對象 實例化對象
Person person = new Person();//person為對象的引用
System.out.println(person.age);//默認值為0
System.out.println(person.name);//默認值為null
//System.out.println(person.count);//會有警告!
//正確訪問方式：
System.out.println(Person.count);
System.out.println(Person.COUNT);
Person.staticTest();
//總結：所有被static所修飾的方法或者屬性，全部不依賴于對象。
person.eat();
person.sleep();
}
}
輸出結果為：
0
null
0
99
StaticTest()
eat()!
sleep()!
數(shù)據(jù)屬性的內存布局：
四、封裝
什么是封裝？？簡單地來說，在我們寫代碼的時候經常會涉及兩種角色: 類的實現(xiàn)者和類的調用者，而封裝能夠使得類的調用者不必關系類的實現(xiàn)者是如何實現(xiàn)類的，只要知道類中有什么方法直接調用即可。降低了類使用者的學習和使用成本, 從而降低了復雜程度。
1. private實現(xiàn)封裝
private/ public 這兩個關鍵字是訪問修飾限定符。
被 public 修飾的成員變量或者成員方法, 可以直接被類的調用者使用被 private 修飾的成員變量或者成員方法, 不能被類的調用者使用
直接使用public：
class Person {
public String name = "張三";
public int age = 18; }
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println("我叫" + person.name + ", 今年" + person.age + "歲");
}
}
// 執(zhí)行結果
我叫張三, 今年18歲
這樣的代碼導致類的使用者(main方法的代碼)必須要了解 Person 類內部的實現(xiàn), 才能夠使用這個類，學習成本較高。
一旦類的實現(xiàn)者修改了代碼(例如把 name 改成 myName), 那么類的使用者就需要大規(guī)模的修改自己的代碼, 維護成本較高。
使用private：
class Person {
private String name = "張三";
private int age = 18;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "歲");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
// 執(zhí)行結果
我叫張三, 今年18歲
此時字段已經使用 private 來修飾，類的調用者(main方法中)不能直接使用. 而需要借助 show 方法. 此時類的使用者就不必了解 Person 類的實現(xiàn)細節(jié)。
同時如果類的實現(xiàn)者修改了字段的名字, 類的調用者不需要做出任何修改(類的調用者根本訪問不到 name, age這樣的字段)
private 不光能修飾字段, 也能修飾方法
通常情況下我們會把字段設為 private 屬性, 但是方法是否需要設為 public, 就需要視具體情形而定. 一般我們希望一個類只提供 “必要的” public 方法, 而不應該是把所有的方法都設為 public。
2.getter和setter方法
被private修飾的字段不等于無法在類外使用該字段。那么如何在類外中獲取被private修飾的字段呢？此處jdk為我們提供了getter和setter方法 。
代碼示例：
class Person {
private String name;//實例成員變量
private int age;
public void setName(String name){
//name = name;//不能這樣寫，否則name仍為0，局部變量優(yōu)先
this.name = name;//this引用，表示調用該方法的對象的name
}
public String getName(){
return name;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
person.show();
}
// 運行結果
caocao
name: caocao age: 0
注意事項：
- getName 即為 getter 方法, 表示獲取這個成員的值
- setName 即為 setter 方法, 表示設置這個成員的值
- 當set方法的形參名字和類中的成員屬性的名字一樣的時候，如果不使用this, 相當于自賦值. this 表示當前實例的引用
- 不是所有的字段都一定要提供 setter / getter 方法, 而是要根據(jù)實際情況決定提供哪種方法
- 在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法. 在 VSCode 中可以使用鼠標右鍵菜單 -> 源代碼操作 中自動生成 setter / getter 方法
五、構造方法
1.構造方法的基本語法及使用
構造方法是一種特殊方法, 使用關鍵字new實例化新對象時會被自動調用, 用于完成初始化操作。
new 執(zhí)行過程：
- 為對象分配內存空間
- 調用對象的構造方法
語法規(guī)則：
- 方法名稱必須與類名稱相同。
- 構造方法沒有返回值類型聲明。
- 每一個類中一定至少存在一個構造方法（如果沒有明確定義，則系統(tǒng)自動生成一個無參構造方法）
注意事項：
- 如果類中沒有提供任何的構造函數(shù)，那么編譯器會默認生成一個不帶有參數(shù)的構造函數(shù)
- 若類中定義了構造方法，則默認的無參構造將不再生成，如果再需要調用無參的構造方法則需要手動寫一個。
- 構造方法支持重載，規(guī)則和普通方法的重載一致。（對返回值不作要求，方法名相同，參數(shù)不同可包括參數(shù)個數(shù)不同或參數(shù)類型不同）
代碼示例：
class Person {
private String name;//實例成員變量
private int age;
private String sex;
//默認構造函數(shù) 構造對象
public Person() {
this.name = "caocao";
this.age = 10;
this.sex = "男";
}
//帶有3個參數(shù)的構造函數(shù)
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();//調用不帶參數(shù)的構造函數(shù) 如果程序沒有提供會調用不帶參數(shù)的構造函數(shù)
p1.show();
Person p2 = new Person("zhangfei",80,"男");//調用帶有3個參數(shù)的構造函數(shù)
p2.show();
}
}
// 執(zhí)行結果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男
2.this關鍵字
this表示當前對象引用(注意不是當前對象)，可以借助 this 來訪問對象的字段和方法。this表示當前對象引用是因為在創(chuàng)建對象的過程中會調用合適的構造方法，而構造方法內部能夠用this關鍵字，而對象在創(chuàng)建的過程當中（對象還未被創(chuàng)建出來）就使用了this關鍵字，證明this指向的是當前對象的引用。
class Person {
private String name;//實例成員變量
private int age;
private String sex;
//默認構造函數(shù) 構造對象
public Person() {
//this調用構造函數(shù)
this("bit", 12, "man");//必須放在第一行進行顯示
}
//這兩個構造函數(shù)之間的關系為重載。
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void show() {
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main{
public static void main(String[] args) {
Person person = new Person();//調用不帶參數(shù)的構造函數(shù)
person.show();
}
}
// 執(zhí)行結果
name: bit age: 12 sex: man
this既可以指的是當前對象的引用中的屬性，也可以在構造方法內部使用（若是調用其它構造方法則只能在構造方法內部使用）。
代碼示例：
class Person {
private String name ;
private int age ;
public Person() {
this("zjr",18);
}
public Person(String name ,int age) {
System.out.println("name:"+name+" age:"+age);
}
}
public class TestDemo {
public static void main(String[] args) {
Person person =new Person();
}
}
運行結果：
結論：
如果用this關鍵字調用其它構造方法的放在第二行則會報錯；并且調用構造方法只能調用一次。要習慣于使用this關鍵字，this關鍵字能夠有效地避免在對象的屬性賦值時兩邊變量名相同會出錯。
六、Java中的代碼塊
字段的初始化方式有：
- 就地初始化
- 使用構造方法初始化
- 使用代碼塊初始化
前兩種初始化方式都已介紹過，那么如何單純用代碼塊來初始化屬性？？
1.認識代碼塊
使用 {} 定義的一段代碼.
根據(jù)代碼塊定義的位置以及關鍵字，又可分為以下四種：
- 普通代碼塊（只做了解）
- 構造塊
- 靜態(tài)塊
- 同步代碼塊（后續(xù)講解多線程部分再談）
2.普通代碼塊
普通代碼塊：定義在方法中的代碼塊。
public class Main{
public static void main(String[] args) {
{ //直接使用{}定義，普通方法塊
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 執(zhí)行結果
x1 = 10
x2 = 100
3.構造代碼塊
構造塊：定義在類中的代碼塊(不加修飾符)。也叫：實例代碼塊。構造代碼塊一般用于初始化實例成員變量。
代碼示例：
class Person{
private String name;//實例成員變量
private int age;
private String sex;
public Person() {
System.out.println("I am Person init()!");
}
//實例代碼塊
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
// 運行結果
I am instance init()!
I am Person init()!
name: bit age: 12 sex: man
注意事項: 實例代碼塊優(yōu)先于構造函數(shù)執(zhí)行。
4.靜態(tài)代碼塊
使用static定義的代碼塊。一般用于初始化靜態(tài)成員屬性。
class Person{
private String name;//實例成員變量
private int age;
private String sex;
private static int count = 0;//靜態(tài)成員變量 由類共享數(shù)據(jù) 方法區(qū)
public Person(){
System.out.println("I am Person init()!");
}
//實例代碼塊
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
//靜態(tài)代碼塊
static {
count = 10;//只能訪問靜態(tài)數(shù)據(jù)成員
System.out.println("I am static init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();//靜態(tài)代碼塊是否還會被執(zhí)行？
}
}
注意：
- 靜態(tài)代碼塊不管生成多少個對象，其只會執(zhí)行一次，且是最先執(zhí)行的。
- 靜態(tài)代碼塊執(zhí)行完畢后, 實例代碼塊（構造塊）執(zhí)行，再然后是構造函數(shù)執(zhí)行。
- 只有靜態(tài)代碼塊不需要實例化對象就能夠執(zhí)行。只要調用了類中的某個變量或方法（靜態(tài)）就能夠被執(zhí)行。靜態(tài)代碼塊的執(zhí)行是在類的加載過程執(zhí)行的，因此只執(zhí)行一次。
- 靜態(tài)代碼塊的使用基變量本上跟static方法差不多，也不能出現(xiàn)this與定義被static修飾的變量，不依賴于對象。
- 靜態(tài)代碼塊中可以使用靜態(tài)變量，但是對于被靜態(tài)修飾的代碼塊與變量執(zhí)行的先后順序又不一樣，它是根據(jù)代碼的執(zhí)行先后順序決定的（前提是在初始化時已經賦予初值，否則仍然遵循靜態(tài)代碼塊先執(zhí)行的順序）。例如：
class Person {
public String name ;
public int age ;
public static int count = 10 ;
static {
count=99;
System.out.println("靜態(tài)");
}
{
System.out.println("實例");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person = new Person();
System.out.println(Person.count);
}
}
運行結果：
交換執(zhí)行先后順序：
class Person {
public String name ;
public int age ;
static {
count=99;
System.out.println("靜態(tài)");
}
public static int count = 10 ;
{
System.out.println("實例");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person = new Person();
System.out.println(Person.count);
}
}
因此如果靜態(tài)變量沒賦初值，則結果是靜態(tài)代碼塊內賦的值；如果靜態(tài)變量賦了初值，則按照執(zhí)行順序決定改變量最后的值，除了變量賦值語句執(zhí)行順序不同以外，靜態(tài)代碼塊內的語句都是先執(zhí)行的。
代碼塊中的重點是主要了解實例代碼塊、靜態(tài)代碼塊、構造方法的運行順序?？偨Y：先運行的是靜態(tài)代碼塊，再運行實例代碼塊（構造代碼塊），最后運行構造方法。靜態(tài)代碼塊內的只運行一次。
七、toString方法
1.重寫println的toString方法
我們剛剛注意到，我們在把對象的屬性進行打印的時候，我們是自己實現(xiàn)了show函數(shù)。但在Java中它提供了一個給我們打印屬性的方法。叫toString方法。
代碼示例：
class Person {
private String name;
private int age;
public Person(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
//重寫Object的toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person("caocao",19);
person.show();
System.out.println(person);
}
}
// 執(zhí)行結果
name：caocao age：19
Person{name='caocao', age=19}
注意事項:
- toString 方法會在 println 的時候被自動調用
- 將對象轉成字符串這樣的操作我們稱為序列化
- toString 是 Object 類提供的方法, 我們自己創(chuàng)建的 Person 類默認繼承自 Object 類, 可以重寫 toString 方法實現(xiàn)我們自己版本的轉換字符串方法. (關于繼承和重寫這樣的概念, 我們后面會重點介紹).
- @Override 在 Java 中稱為 “注解”, 此處的 @Override 表示下面實現(xiàn)的 toString 方法是重寫了父類的方法，關于注解后面的課程會詳細介紹.
- IDEA快速生成Object的toString方法快捷鍵：alt+f12(insert)
若我們要觀察println中的toString方法，則我們可以按住ctrl鍵，將鼠標點到println中的位置。點入println中會看到如圖所示：
再按ctrl鍵將鼠標放在紅框處點入，看到的如圖所示：
最后將進入紅框內的方法當中，如圖所示：
因此我們能夠證實println中的toString方法是按照哈希值來進行處理后打印的。因此如果我們重寫了它的toString方法來打印我們類中的屬性，則直接System.out.println(person);即可（代碼如上所示），若沒有重寫println中的toString方法，則再用System.out.println(person);時打印的結果為：類名+@+經過哈希值處理的地址。
2.匿名對象
匿名只是表示沒有名字的對象
- 沒有引用的對象稱為匿名對象
- 匿名對象只能在創(chuàng)建對象時使用
- 如果一個對象只是用一次, 后面不需要用了, 可以考慮使用匿名對象
class Person {
private String name;
private int age;
public Person(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
}
public class Main {
public static void main(String[] args) {
new Person("caocao",19).show();//通過匿名對象調用方法
}
}
// 執(zhí)行結果
name：caocao age：19
重點：注意匿名對象是如何調用類中的方法的。
八、交換兩個數(shù)的值（實參交換）
代碼：
class Test {
private int num ;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class TestDemo2 {
public static void Swap(Test test1,Test test2) {
int tmp = test1.getNum();
test1.setNum(test2.getNum()) ;
test2.setNum(tmp);
}
public static void main(String[] args) {
Test test1 = new Test();
Test test2 = new Test();
test1.setNum(10);
test2.setNum(20);
System.out.println(test1.getNum());
System.out.println(test2.getNum());
Swap(test1,test2);
System.out.println(test1.getNum());
System.out.println(test2.getNum());
}
}
運行結果：
總結
到此這篇關于Java中類與對象知識點的文章就介紹到這了,更多相關Java類與對象內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Java設計模式之裝飾者模式詳解和代碼實例,Decorator模式(別名Wrapper):動態(tài)將職責附加到對象上,若要擴展功能,裝飾者提供了比繼承更具彈性的代替方案,需要的朋友可以參考下2021-07-07
這篇文章主要介紹了Java抽象類的構造模板模式用法,結合實例形式分析了java使用抽象類構造模板模式相關操作技巧,需要的朋友可以參考下2019-09-09
這篇文章主要介紹了Java實現(xiàn)的快速查找算法,結合具體實例形式分析了快速查找算法的原理與相關實現(xiàn)技巧,需要的朋友可以參考下2017-09-09
Apache RocketMQ是企業(yè)級的消息中間件,以其高性能和高可靠性而廣泛應用,但是,消息丟失的問題在實踐中仍然存在,本文將探討此問題并提供解決方案,需要的朋友可以參考下2023-11-11
這篇文章主要給大家介紹了關于Centos7安裝JDK1.8的相關資料,文中通過圖文以及實例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2022-09-09
這篇文章主要介紹了Java遍歷Json的簡單實例，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
Spring?Boot?集成并開發(fā)?Sa-token示例詳解
Sa-token是一款高可用的權限認證框架，他帶我們用最簡化的配置完成用?spring?security?需要進行大量配置的才能完成的工作，這篇文章主要介紹了Spring?Boot?集成并開發(fā)?Sa-token,需要的朋友可以參考下2023-06-06
實體類使用@Builder,導致@ConfigurationProperties注入屬性失敗問題
這篇文章主要介紹了實體類使用@Builder,導致@ConfigurationProperties注入屬性失敗問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-12-12
Spring boot 集成 Druid 數(shù)據(jù)源過程詳解
這篇文章主要介紹了Spring boot 集成 Druid 數(shù)據(jù)源過程詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-08-08
這篇文章介紹了Java連接數(shù)據(jù)庫的步驟，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-04-04