作者主頁：paper jie的博客
本文作者：大家好，我是paper jie，感謝你閱讀本文，歡迎一建三連哦。
本文錄入于《JAVASE語法系列》專欄，本專欄是針對于大學生，編程小白精心打造的。筆者用重金(時間和精力)打造，將javaSE基礎(chǔ)知識一網(wǎng)打盡，希望可以幫到讀者們哦。
其他專欄：《算法詳解》《C語言》等
內(nèi)容分享：本期將會對JAVA中的類和對象用大量的篇幅來講解！
目錄
類和對象的概念
什么是類和對象
面向?qū)ο笈c面向過程
類的定義和使用
認識類
類的定義格式
練習定義一個 “人”?類
類的實例化
什么是實例化?
類和對象的說明
this的引用
什么是this引用?
this引用的特點?
對象的構(gòu)造及初始化?
構(gòu)造方法?
什么是構(gòu)造方法
特點
默認初始化
new關(guān)鍵字后面發(fā)生了什么？
就地初始化
封裝
什么是封裝?
訪問限定符
封裝 — 包
什么是包
導包的類?
自定義包
?包的訪問權(quán)限控制舉例
常見的包?
static成員?
static修飾的成員變量
static修飾成員方法?
static成員變量初始化
代碼塊
代碼塊的分類?
?普通代碼塊?
構(gòu)造代碼塊?
靜態(tài)代碼塊??
對象的打印?
類和對象的概念
什么是類和對象
Java是一門純面向?qū)ο蟮恼Z言(Object Oriented Program，簡稱OOP)，在面向?qū)ο蟮氖澜缋?，一切皆為對象?strong>面向?qū)ο笫墙鉀Q問題的一種思想，主要依靠對象之間的交互完成一件事情。對象：對象是類的一個實例（對象不是找個女朋友），有狀態(tài)和行為。例如，一條狗是一個對象，它的狀態(tài)有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。類：類是一個模板，它描述一類對象的行為和狀態(tài)
面向?qū)ο笈c面向過程
面向?qū)ο缶褪悄阒恍枰榔渲械膶ο螅獔?zhí)行的過程不用關(guān)心。
面向過程就是你要知道實現(xiàn)你要做的事件的每一步過程，你都要參與進去。
舉個栗子：
以前找地方：你需要通過自己到一段路問一個人怎么走，到一段路怎么走，需要自己親歷親為。（面向過程）
現(xiàn)在到地方：你只需要知道幾個對象：起點，終點，高德地圖。其他的跟著導航走就行（面向?qū)ο螅?/p>
注意：其實面向?qū)ο蠛兔嫦蜻^程它并不是針對一門語言來說，而是解決問題的方法。沒有好壞區(qū)分，各有各的應(yīng)用場景。
類的定義和使用
認識類
類是用來對一個實體(對象)來進行描述的，主要描述該實體(對象)具有哪些屬性，有哪些功能。
栗子:
電腦：java認為它就是類
屬性：產(chǎn)品品牌，型號，產(chǎn)品重量，外觀尺寸，顏色
功能：顯示，查詢，播放視頻，辦公……
類的定義格式
在java中定義類時需要用到class關(guān)鍵字 ：
// 創(chuàng)建類
class ClassName{
field; // 字段(屬性) 或者 成員變量
method; // 行為 或者 成員方法
}class為定義類的關(guān)鍵字，ClassName為類的名字，{}中為類的主體。類中包含的內(nèi)容稱為類的成員。屬性主要是用來描述類的，稱之為類的成員屬性或者類成員變量。方法主要說明類具有哪些功能，稱為類的成員方法。?
class Computer {
String brand;//型號
String cpu;//cpu
int age;//生產(chǎn)日期
String color;//顏色
int height; //高
int length;//長
int width;//寬
public void show() {
System.out.println("顯示");
}
public void sreach() {
System.out.println("搜索");
}
}Java語言將電腦類在計算機中定義完成，經(jīng)過javac編譯之后形成.class文件，在JVM的基礎(chǔ)上計算機就可以識別?
注意：
類名注意采用大駝峰
這里的寫法沒有帶static關(guān)鍵字，下面會講到
練習定義一個 “人”?類
class person {
String nume;
String sex;
String nationality;
int age;
int id;
public void speak() {
System.out.println("說話");
}
public void study() {
System.out.println("學習");
}
public void sleep() {
System.out.println("睡覺");
}
public void motion() {
System.out.println("運動");
}
}?注意：
一般一個文件里只定義一個類
main方法所在的類一般要使用public修飾(注意：Eclipse默認會在public修飾的類中找main方法)?
public修飾的類必須要和文件名相同?
不要輕易去修改public修飾的類的名稱，如果要修改，通過開發(fā)工具修改。??
類的實例化
什么是實例化?
定義了一個類，就相當于在計算機中定義了一種新的類型，與int，double類似，只不過int和double是java語言自帶的內(nèi)置類型，而類是用戶自定義了一個新的類型，比如上述的：PetDog類和Student類。它們都是類(一種新定義的類型)有了這些自定義的類型之后，就可以使用這些類來定義實例(或者稱為對象)。??
用類類型創(chuàng)建對象的過程，稱為類的實例化，在java中采用new關(guān)鍵字，配合類名來實例化對象。
舉個栗子：
class Person {
String name;
String sex;
String nationality;
int age;
int id;
public void speak() {
System.out.println("說話");
}
public void study() {
System.out.println("學習");
}
public void sleep() {
System.out.println("睡覺");
}
public void motion() {
System.out.println("運動");
}
}
public class Test {
public static void main(String[] args) {
Person people1 = new Person();
people1.name = "張三";
people1.sex = "男";
people1.id = 1234;
people1.age = 20;
people1.sleep();
people1.study();
Person people2 = new Person();
people2.name = "李四";
people2.sex = "男";
people2.id = 12334;
people2.age = 25;
people2.sleep();
people2.study();
}注意：
new 關(guān)鍵字用于創(chuàng)建一個對象的實例.
使用 . 來訪問對象中的屬性和方法.
同一個類可以創(chuàng)建多個實例.
類和對象的說明
類只是一個模型一樣的東西，用來對一個實體進行描述，限定了類有哪些成員.
類是一種自定義的類型，可以用來定義變量.
一個類可以實例化出多個對象，實例化出的對象 占用實際的物理空間，存儲類成員變量
類實例化出對象就像現(xiàn)實中使用建筑設(shè)計圖建造出房子，類就像是設(shè)計圖，只設(shè)計出需要什么東 西，但是并沒有實體的建筑存在，同樣類也只是一個設(shè)計，實例化出的對象才能實際存儲數(shù)據(jù)，占用物理空間
this的引用
什么是this引用?
this引用指向當前對象,即成員方法運行時調(diào)用該成員方法的對象，在成員方法中所有成員變量的操作，都是通過該引用去訪問。只不過所有的操作對用戶是透明的，即用戶不需要來傳遞，編譯器自動完成。
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
}
注：shis引用的是調(diào)用成員方法的對象
public static void main(String[] args) {
Date d = new Date();
d.setDay(2020,9,15);
d.printDate();
}this引用的特點?
this的類型：對應(yīng)類類型引用，即哪個對象調(diào)用就是哪個對象的引用類型
this只能在成員方法中使用
在成員方法中，this只能引用當前對象，不能引用其他的對象
this是成員方法的第一個，且隱藏的參數(shù)，編譯器會自動傳遞，在成員方法執(zhí)行的時候，編譯器會負責將調(diào)用成員方法對象的引用傳遞給該成員的方法，this來接受
對象的構(gòu)造及初始化?
初始化對象我們知道，在方法內(nèi)部定義一個局部變量的時候，需要初始化，不然會報錯，編譯失敗，但是我們發(fā)現(xiàn)下面的代碼：
public static void main(String[] args) {
Date d = new Date();
d.printDate();
d.setDate(2021,6,9);
d.printDate();
}它需要調(diào)用之前的SetDate方法才可以將具體的日期設(shè)置到對象中。這里就有連個問題了：
1. 每次對象創(chuàng)建好后調(diào)用SetDate方法設(shè)置具體日期，比較麻煩，那對象該如何初始化？
2. 局部變量必須要初始化才能使用，為什么字段聲明之后沒有給值依然可以使用？
構(gòu)造方法?
什么是構(gòu)造方法
構(gòu)造方法是一個特殊的成員方法，名字必須與類名相同，在創(chuàng)建對象時，由編譯器自動調(diào)用，并且在整個對象的生命周期內(nèi)只調(diào)用一次。?
?注意：構(gòu)造方法的作用就是對對象的成員進行初始化，并不負責給對象開辟空間
public class Date {
public int year;
public int month;
public int day;
// 構(gòu)造方法：
// 名字與類名相同，沒有返回值類型，設(shè)置為void也不行
// 一般情況下使用public修飾
// 在創(chuàng)建對象時由編譯器自動調(diào)用，并且在對象的生命周期內(nèi)只調(diào)用一次
public Date(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被調(diào)用了");
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
// 此處創(chuàng)建了一個Date類型的對象，并沒有顯式調(diào)用構(gòu)造方法
Date d = new Date(2021,6,9); // 輸出Date(int,int,int)方法被調(diào)用了
d.printDate(); // 2021-6-9
}
}特點
名字得和類型相同
沒有返回值類型，void也不行
創(chuàng)建對象時，由編譯器自動調(diào)用，并且在對象的生命周期內(nèi)只會調(diào)用一次
構(gòu)造方法可以重載（根據(jù)不同的需求提供不同的構(gòu)造方法）
public class Date {
public int year;
public int month;
public int day;
// 無參構(gòu)造方法
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 帶有三個參數(shù)的構(gòu)造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}代碼中的兩個構(gòu)造方法名字相同，參數(shù)列表不同，因此構(gòu)成了方法重載
如果用戶自己沒有定義，那編譯器會自己生成一份默認的構(gòu)造方法，生成的默認構(gòu)造方法是無參的
public class Date {
public int year;
public int month;
public int day;
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}上述Date類中，沒有定義任何構(gòu)造方法，編譯器就? 會默認生成一個不帶參數(shù)的構(gòu)造方法。?
構(gòu)造方法中，可以通過this調(diào)用方法來簡化代碼
public class Date {
public int year;
public int month;
public int day;
// 無參構(gòu)造方法--內(nèi)部給各個成員賦值初始值，該部分功能與三個參數(shù)的構(gòu)造方法重復(fù)
// 此處可以在無參構(gòu)造方法中通過this調(diào)用帶有三個參數(shù)的構(gòu)造方法
// 但是this(1900,1,1);必須是構(gòu)造方法中第一條語句
public Date(){
//System.out.println(year); 注釋取消掉，編譯會失敗
this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
} /
/ 帶有三個參數(shù)的構(gòu)造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}這里要注意：
this（）必須是構(gòu)造方法的第一個語句
public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
} /
* 無
參構(gòu)造器調(diào)用三個參數(shù)的構(gòu)造器，而三個參數(shù)構(gòu)造器有調(diào)用無參的構(gòu)造器，形成構(gòu)造器的遞歸調(diào)用
編譯報錯：Error:(19, 12) java: 遞歸構(gòu)造器調(diào)用
*/不可以形成環(huán)，不然就無限套娃了??
絕大多數(shù)情況下使用public來修飾，特殊場景下會被private修飾
默認初始化
我們發(fā)現(xiàn)一個現(xiàn)象，局部變量在使用的時候需要初始化，而成員變量卻可以不用，這是為什么呢？??
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
// 成員變量在定義時，并沒有給初始值, 為什么就可以使用呢？
System.out.println(this.year);
System.out.println(this.month);
System.out.println(this.day);
}
public static void main(String[] args) {
// 此處a沒有初始化，編譯時報錯：
// Error:(24, 28) java: 可能尚未初始化變量a
// int a;
// System.out.println(a);
Date d = new Date(2021,6,9);
}
}new關(guān)鍵字后面發(fā)生了什么？
Date d = new Date(2023,8,1);在JVM層面這句話需要做好多事情：
檢查對象對應(yīng)的類有沒有加載，沒有加載就要加載
為對象分配內(nèi)存空間
處理并發(fā)安全問題，例如多線程同時申請對象，jvm要保證對象分配的空間不沖突
初始化所分配的空間（對象空間申請好后，對象中的成員已經(jīng)設(shè)置好了默認初始值）
數(shù)據(jù)類型的默認值：
?設(shè)置對象頭信息
調(diào)用構(gòu)造方法，給對象的各個成員賦值
就地初始化
public class Date {
public int year = 1900;
public int month = 1;
public int day = 1;
public Date(){
}
public Date(int year, int month, int day) {
}
public static void main(String[] args) {
Date d1 = new Date(2021,6,9);
Date d2 = new Date();
}
}代碼編譯完成后，編譯器會將所有給成員初始化的這些語句添加到各個構(gòu)造函數(shù)中?
封裝
什么是封裝?
面向?qū)ο蟪绦蛉筇匦裕悍庋b、繼承、多態(tài)。而類和對象階段，主要研究的就是封裝特性。何為封裝呢？簡單來說就是套殼屏蔽細節(jié)，只需要知道使用方法就可以。
封裝：將數(shù)據(jù)和操作數(shù)據(jù)的方法進行有機結(jié)合，隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外公開接口來和對象進行 交互?
訪問限定符
Java中主要通過類和訪問權(quán)限來實現(xiàn)封裝：類可以將數(shù)據(jù)以及封裝數(shù)據(jù)的方法結(jié)合在一起，更符合人類對事物的認知，而訪問權(quán)限用來控制方法或者字段能否直接在類外使用。Java中提供了四種訪問限定符：
?默認就是default權(quán)限
權(quán)限除了可以限定類中的成員的可見性，也可以控制類的可見性
class Computer {
private String cpu; // cpu
private String memory; // 內(nèi)存
public String screen; // 屏幕
String brand; // 品牌---->default屬性
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("開機~~~");
}
public void PowerOff(){
System.out.println("關(guān)機~~~");
}
public void SurfInternet(){
System.out.println("上網(wǎng)~~~");
}
}
public class Test {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.brand); // default屬性：只能被本包中類訪問
System.out.println(p.screen); // public屬性： 可以任何其他類訪問
//System.out.println(p.cpu); // private屬性：只能在Computer類中訪問，不能被其他類訪問
}
}
一般情況下，成員變量設(shè)置為private，成員方法設(shè)置為public
封裝 — 包
什么是包
在面向?qū)ο篌w系中，提出了一個軟件包的概念，即：為了更好的管理類，把多個類收集在一起成為一組，稱為軟件包，有點類似于目錄。在Java中也引入了包，包是對類、接口等的封裝機制的體現(xiàn)，是一種對類或者接口等的很好的組織方式，比如：一個包中的類不想被其他包中的類使用。包還有一個重要的作用：在同一個工程中允許存在相同名稱的類，只要處在不同的包中即可。
導包的類?
Java 中已經(jīng)提供了很多現(xiàn)成的類供我們使用. 例如Date類：可以使用 java.util.Date 導入 java.util 這個包中的 Date類.
Java中我們有幾種導包的方式：?
直接寫：
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
//這里得到一個時間戳
System.out.println(date.getTime());
}
}使用import語句導入包：
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getTime());
}
}
如果想使用util全部的類，可以使用import java.util.*
import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getTime());
}
}這里更建議使用指定的要導入的類名，不然容易沖突
注意：mport 和 C++ 的 #include 差別很大. C++ 必須 #include 來引入其他文件內(nèi)容, 但是 Java 不需要.import 只是為了寫代碼的時候更方便. import 更類似于 C++ 的 namespace 和 using?
自定義包
規(guī)則：
在文件的最上方加一個package語句 指定該代碼在哪個包里
包名需要盡量指定成唯一的名字，通常會用公司的域名的顛倒形式
包名要和代碼路徑相匹配. 例如創(chuàng)建 com.demo1 的包, 那么會存在一個對應(yīng)的路徑 com/demo1 來存儲代碼.
如果一個類沒有 package 語句, 則該類被放到一個默認包中.
操作步驟：?
先在IDEA上新建一個包：src - 新建 - 包
在彈出的對話框中輸入包名：com.demo
?
在包中新建類，包名 - 類，輸入類名
?這時我們就可以在本地文件中的目錄上看到它被創(chuàng)建出來了
我們也可以看到新建的Test.java文件上有一個package
?包的訪問權(quán)限控制舉例
package com.bit.demo1;
public class Computer {
private String cpu; // cpu
private String memory; // 內(nèi)存
public String screen; // 屏幕
String brand; // 品牌
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}
public void Boot(){
System.out.println("開機~~~");
}
public void PowerOff(){
System.out.println("關(guān)機~~~");
}
public void SurfInternet(){
System.out.println("上網(wǎng)~~~");
}
} /
//
package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.screen);
// System.out.println(p.cpu); // 報錯：cup是私有的，不允許被其他類訪問
// System.out.println(p.brand); // 報錯：brand是default，不允許被其他包中的類訪問
}
} /
/ 注意：如果去掉Computer類之前的public修飾符，代碼也會編譯失敗常見的包?
1. java.lang:系統(tǒng)常用基礎(chǔ)類(String、Object),此包從JDK1.1后自動導入。
2. java.lang.reflect:java 反射編程包;
3. java.net:進行網(wǎng)絡(luò)編程開發(fā)包。
4. java.sql:進行數(shù)據(jù)庫開發(fā)的支持包。
5. java.util:是java提供的工具程序包。(集合類等) 非常重要
6. java.io:I/O編程開發(fā)包。?
static成員?
在Java中，被static修飾的成員，稱之為靜態(tài)成員，也可以稱為類成員，其不屬于某個具體的對
象，是所有對象所共享的?
static修飾的成員變量
static修飾的成員變量，稱為靜態(tài)成員變量，靜態(tài)成員變量最大的特點：不屬于個具體的對
象，是所有對象所共享的?
靜態(tài)成員變量特性：
不屬于某個具體的對象，是類的屬性，所有對象共享的，不存儲在某個對象的空間中
既可以通過對象訪問，也可以通過類名訪問，推薦使用類名訪問
類變量存儲在方法區(qū)當中
生命周期一直到類的結(jié)束，隨著類的加載而創(chuàng)建，類的卸載而銷毀
public class Test {
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306";
public Test(String name,String gender, int age, double score) {
this.name = name;
this.gender = gender;
this.age = age;
this.score = score;
}
// ...
public static void main(String[] args) {
// 靜態(tài)成員變量可以直接通過類名訪問
System.out.println(Test.classRoom);
Test s1 = new Test("Li leilei", "男", 18, 3.8);
Test s2 = new Test("Han MeiMei", "女", 19, 4.0);
Test s3 = new Test("Jim", "男", 18, 2.6);
// 也可以通過對象訪問：但是classRoom是三個對象共享的
System.out.println(Test.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}通過調(diào)試，我們可以發(fā)現(xiàn)，靜態(tài)變量并沒有存儲到某個具體的對象中
static修飾成員方法?
一般類中的數(shù)據(jù)成員都設(shè)置為private，而成員方法設(shè)置為public，那設(shè)置之后，Student類中classRoom屬性如何在類外訪問呢？?
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";
// ...
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.classRoom);
}
} 編
譯失敗：
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 訪問控制我們會發(fā)現(xiàn)代碼會編譯失敗，訪問不到classRoom。
這里，我們有一種被static修飾的成員方法稱為靜態(tài)成員方法，是類的方法，不是某個對象所特有的。靜態(tài)成員一般都是通過靜態(tài)方法來訪問的。
public class Test{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";
public static String classRoom() {
return classRoom;
}
// ...
}
class TestStudent {
public static void main(String[] args) {
System.out.println(Test.classRoom());
}
} 
?靜態(tài)方法特性：?
不屬于某個具體的對象，是類方法
可以通過對象調(diào)用，也可以通過類名.靜態(tài)方法名()調(diào)用
不可以在靜態(tài)方法中訪問非靜態(tài)成員變量
public static String getClassRoom(){
System.out.println(this);
return classRoom;
} // 編譯失?。篍rror:(35, 28) java: 無法從靜態(tài)上下文中引用非靜態(tài) 變量 this
public static String getClassRoom(){
age += 1;
return classRoom;
} // 編譯失?。篍rror:(35, 9) java: 無法從靜態(tài)上下文中引用非靜態(tài) 變量 age靜態(tài)方法中不可以調(diào)用任何非靜態(tài)方法，因為非靜態(tài)方法有this參數(shù)，在靜態(tài)方法中調(diào)用時候無法傳遞this引用
public static String getClassRoom(){
doClass();
return classRoom;
} // 編譯報錯：Error:(35, 9) java: 無法從靜態(tài)上下文中引用非靜態(tài) 方法 doClass()static成員變量初始化
靜態(tài)變量一般不會放在構(gòu)造方法中來初始化，構(gòu)造方法中初始化的是與對象相關(guān)的實例屬性。
靜態(tài)成員變量初始化分為兩種：就地初始化，靜態(tài)代碼塊初始化
就地初始化：?
定義時給出初始化
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bjjjjjj";
靜態(tài)初始化：
嘿嘿，往下看！
代碼塊
代碼塊的分類?
使用{}定義的一段代碼就是代碼塊。代碼塊可以分為4種：?
普通代碼塊
構(gòu)造代碼塊
靜態(tài)代碼塊
同步代碼塊
?普通代碼塊?
定義在方法種的代碼塊：
class TestStudent {
public static void main(String[] args) {
System.out.println(Test.classRoom());
}
}
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í)行結(jié)果
x1 = 10
x2 = 100構(gòu)造代碼塊?
構(gòu)造塊：定義在類中的代碼塊(不加修飾符)。也叫：實例代碼塊。構(gòu)造代碼塊一般用于初始化實例成員變量??
class Student{
//實例成員變量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//實例代碼塊
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+gender);
}
}
public class Test {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
靜態(tài)代碼塊??
使用static的代碼塊稱為靜態(tài)代碼塊。一般用于初始化靜態(tài)成員變量
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//實例代碼塊
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
} // 靜態(tài)代碼塊
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}注意：
靜態(tài)代碼塊不管生成多少個對像，它只會執(zhí)行一次
靜態(tài)成員變量是類的屬性，因此是在JVM加載類的時候開辟空間并初始化的
如果一個類中包含多個靜態(tài)代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次執(zhí)行(合并)
實例代碼塊只有在創(chuàng)建對象時才會執(zhí)行??
對象的打印?
重寫toString方法：文章來源：http://www.zghlxwxcb.cn/news/detail-627863.html
public class Test {
int a;
int b;
int c;
public Test(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public String toString() {
return a + "," + b + "," + c;
}
public static void main(String[] args) {
Test test = new Test(1,2,4);
System.out.println(test);
}
}
文章來源地址http://www.zghlxwxcb.cn/news/detail-627863.html
到了這里，關(guān)于【JAVA】類和對象的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
