新手初學(xué)Java面向?qū)ο?/h1>
更新時間：2021年07月07日 11:53:30 作者：群臨天下
這篇文章主要介紹了Java語言面向?qū)ο缶幊趟枷胫惻c對象實(shí)例詳解，還是十分不錯的，這里給大家分享下，需要的朋友可以參考，希望能幫到你
java面向?qū)ο?/h2>
面向?qū)ο蟆綣ava語言的核心機(jī)制，最重要的內(nèi)容，Java語言的特色】
* 面向過程和面向?qū)ο蟮膮^(qū)別
- 面向過程：主要關(guān)注點(diǎn)是：實(shí)現(xiàn)的具體過程，因果關(guān)系【集成顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：對于業(yè)務(wù)邏輯比較簡單的程序，可以達(dá)到快速開發(fā)，前期投入成本較低。
* 缺點(diǎn)：采用面向過程的方式開發(fā)很難解決非常復(fù)雜的業(yè)務(wù)邏輯，另外面向過程的
方式導(dǎo)致軟件元素之間的“耦合度”非常高，只要其中一環(huán)出問題，整個系統(tǒng)受到影響，
導(dǎo)致最終的軟件“擴(kuò)展力”差。另外，由于沒有獨(dú)立體的概念，所以無法達(dá)到組件復(fù)用。
- 面向?qū)ο螅褐饕P(guān)注點(diǎn)是：主要關(guān)注對象【獨(dú)立體】能完成哪些功能。【獨(dú)立顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：耦合度低，擴(kuò)展力強(qiáng)。更容易解決現(xiàn)實(shí)世界當(dāng)中更復(fù)雜的業(yè)務(wù)邏輯。組件復(fù)用性強(qiáng)。
* 缺點(diǎn)：前期投入成本較高，需要進(jìn)行獨(dú)立體的抽取，大量的系統(tǒng)分析與設(shè)計。
- C語言是純面向過程的、C++半面向?qū)ο?、Java純面向?qū)ο?
- 現(xiàn)在出現(xiàn)的一些新的編程語言多數(shù)都是面向?qū)ο蟮?。人在認(rèn)識現(xiàn)實(shí)世界的時候以面向?qū)ο蟮姆绞健?
- 面向?qū)ο蟾先说乃季S方式。
* 面向?qū)ο蟮娜筇卣鳌鞠缺硶?
- 封裝
- 繼承
- 多態(tài)
所有面向?qū)ο蟮木幊陶Z言都有這三大特征。
采用面向?qū)ο蟮姆绞介_發(fā)一個軟件，生命周期當(dāng)中：【整個生命周期中貫穿使用OO面向?qū)ο蠓绞健?
* 面向?qū)ο蟮姆治觯篛OA
* 面向?qū)ο蟮脑O(shè)計：OOD
* 面向?qū)ο蟮木幊蹋篛OP
* 類和對象的概念
* 什么是類？
- 類在現(xiàn)實(shí)世界當(dāng)中是不存在的，是一個模板，是一個概念。是人類大腦思考抽象的結(jié)果。
- 類代表了一類事物。
- 在現(xiàn)實(shí)世界當(dāng)中，對象A與對象B之間具有共同特征，進(jìn)行抽象總結(jié)出一個模板，這個模板被稱為類。
* 什么是對象？
- 對象是實(shí)際存在的個體?，F(xiàn)實(shí)世界當(dāng)中實(shí)際存在。
* 描述一下整個軟件開發(fā)的過程：
* 程序員先觀察現(xiàn)實(shí)世界，從現(xiàn)實(shí)世界當(dāng)中尋找對象
* 尋找了N多個對象之后，發(fā)現(xiàn)所有的對象都有共同特征
* 程序員在大腦中形成了一個模板【類】
* Java程序員可以通過java代碼來表述一個類
* Java程序中有了類的定義
* 然后通過類就可以創(chuàng)建對象
* 有了對象之后，可以讓對象直接協(xié)作起來形成一個系統(tǒng)。
* 類--【實(shí)例化】->對象
* 對象又被稱為實(shí)例/instance
* 對象--【抽象】-->類
* 重點(diǎn)：
類描述的是對象的共同特征。
共同特征例如：身高特征
這個身高特征在訪問的時候，必須先創(chuàng)建對象，通過對象去訪問這個特征。
因?yàn)檫@個特征具體的某個對象上之后，值不同。有的對象身高1.80，有的
對象身高2.80。
* 一個類主要描述什么信息呢？
一個類主要描述的是 狀態(tài) + 動作。
狀態(tài)信息：名字、身高、性別、年齡
動作信息：吃、唱歌、跳舞、學(xué)習(xí)
狀態(tài)--> 一個類的屬性
動作--> 一個類的方法
*
類{
屬性; //描述對象的狀態(tài)信息
方法; //描述對象的動作信息
}
注意：
狀態(tài)和動作當(dāng)具體到某個對象上之后，發(fā)現(xiàn)最終的結(jié)果可能不一樣。
對象和對象之間有共同特征，但是具體到對象之后有數(shù)據(jù)的差異。
* 類的定義【從這里開始編寫代碼】
語法結(jié)構(gòu)：
[修飾符列表] class 類名{
屬性;
方法;
}
學(xué)生類，描述所有學(xué)生對象的共同特征：
學(xué)生對象有哪些狀態(tài)信息：
* 學(xué)號【int】
* 名字【String】
* 性別【boolean】
* 年齡【int】【年齡是一個屬性，年齡是一個數(shù)據(jù)，是數(shù)據(jù)就應(yīng)該有數(shù)據(jù)類型】
* 住址【String】
.....
學(xué)生對象有哪些動作信息：
* 吃飯
* 睡覺
* 學(xué)習(xí)
* 玩
* 唱歌
* 跳舞
....
重點(diǎn)：屬性通常是采用一個變量的形式來完成定義的。
int no;
int age;
String name;
String address;
boolean sex;
* java語言中包括兩種數(shù)據(jù)類型：
- 基本數(shù)據(jù)類型
byte
short
int
long
float
double
boolean
char
- 引用數(shù)據(jù)類型
String.class SUN提供的
System.class SUN提供的
Student.class 程序員自定義的
User.class 程序員自定義的
Product.class 程序員自定義的
Customer.class 程序員自定義的
......
- java語言中所有的class都屬于引用數(shù)據(jù)類型。
// 定義一個類，類名Student
// Student是一個類，代表了所有的學(xué)生對象，是一個學(xué)生的模板。
public class Student{ // 定義一個公開的類，起名Student
// 屬性【描述的是對象的狀態(tài)信息】
// 熟悉通常采用變量的方式來定義
// 在類體當(dāng)中，方法體之外定義的變量被稱為“成員變量”
// 成員變量沒有賦值，系統(tǒng)賦默認(rèn)值：一切箱0看齊。
// 學(xué)號
int no;
// 姓名
String name;
// 性別
boolean sex;
// 年齡
int age;
// 住址
String address;
// 方法
// 方法描述的是對象的動作信息
// 當(dāng)前例子就只描述屬性了
}
// 學(xué)生類
// 學(xué)生類是一個模板
// 描述了所有學(xué)生的共同特征【狀態(tài)+行為】
// 當(dāng)前類只描述學(xué)生的狀態(tài)信息【屬性】
// Student是類，屬于引用數(shù)據(jù)類型，這個類型名就是：Student
public class Student{
// 類體-屬性+方法
// 屬性【存儲數(shù)據(jù)采用變量的形式】
// 由于變量定義在類體當(dāng)中，方法體之外，這種變量稱為成員變量
// 所有學(xué)生都有學(xué)好信息
// 但是每一個學(xué)生的學(xué)號都是不同的
// 所以要訪問這個學(xué)號必須先創(chuàng)建對象，通過對象去訪問學(xué)號信息
// 學(xué)號信息不能直接通過“類”去訪問，所以這種成員變量又被叫做：實(shí)例變量
// 對象又被稱為實(shí)例，實(shí)例變量又成為對象變量?！緦ο蠹墑e的變量】
// 不創(chuàng)建對象，這個no變量的內(nèi)存空間是不存在的，只有創(chuàng)建了對象，這個no變量內(nèi)存空間才會創(chuàng)建
int no;
// 姓名
String name;
// 年齡
int age;
// 性別
boolean sex;
// 住址
String addr;
}
// 成員變量沒有手動賦值的話，系統(tǒng)賦默認(rèn)值
// 默認(rèn)值
/*
數(shù)據(jù)類型 默認(rèn)值
---------------------------------
byte，short，int，long 0
float，double 0.0
boolean false
char \u0000
引用數(shù)據(jù)類型 null 空值
*/
// -----------------------------------------------------------------------------------------------------
/*
對象的創(chuàng)建和使用
*/
public class OOTest01
{
public static void main(String[] args){
// int 是基本數(shù)據(jù)類型
// i 是一個變量名
// 10是一個int類型的字面值
int i = 10;
// 通過一個類可以實(shí)例化N個對象
// 實(shí)例化對象的語法：new 類名();
// new是java語言當(dāng)中的一個運(yùn)算符
// new運(yùn)算符的作用是創(chuàng)建對象，在JVM堆內(nèi)存當(dāng)中開辟新的內(nèi)存空間
// 方法區(qū)內(nèi)存：在類加載的時候，class字節(jié)碼片段被加載到該內(nèi)存空間當(dāng)中
// 棧內(nèi)存（局部變量）：方法代碼片段執(zhí)行的時候，會給該方法分配內(nèi)存空間，在棧內(nèi)存中壓棧
// 堆內(nèi)存：new的對象在堆內(nèi)存中存儲
// Student是一個應(yīng)用數(shù)據(jù)類型
// s 是一個變量名
// new Student()是一個學(xué)生對象
// s是一個局部變量【在棧內(nèi)存中存儲】
// 什么是對象？new運(yùn)算符在堆內(nèi)存中開辟的內(nèi)存空間稱為對象
// 什么是引用？引用是一個變量，只不過這個變量保存了另一個java對象的內(nèi)存地址
// java語言當(dāng)中，程序員不能直接操作堆內(nèi)存，java中沒有指針，不像c語言
// java語言當(dāng)中，程序員只能通過“引用”去訪問堆內(nèi)存當(dāng)中對象內(nèi)部的示例變量
Student s = new Student();
// 訪問實(shí)例變量的語法格式：
// 讀取數(shù)據(jù)：引用.變量名
// 修改數(shù)據(jù)：引用.變量名 = 值
/*
int stuNo = s.no;
String stuName = s.name;
int stuAge = s.age;
boolean stuSex = s.sex;
String stuAddr = s.addr;
System.out.println("學(xué)號 = " + stuNo);
System.out.println("姓名 = " + stuName);
System.out.println("年齡 = " + stuAge);
System.out.println("性別 = " + stuSex);
System.out.println("地址 = " + stuAddr);
*/
s.no = 10;
s.name = "jack";
s.age = 20;
s.sex = true;
s.addr = "深圳";
System.out.println("學(xué)號 = " + s.no); // 10
System.out.println("姓名 = " + s.name); // jack
System.out.println("年齡 = " + s.age); // 20
System.out.println("性別 = " + s.sex); // true
System.out.println("地址 = " + s.addr); // 深圳
// 編譯報錯，no這個實(shí)例變量不能直接采用”類名“的方式訪問
// 因?yàn)閚o是實(shí)例變量，對象級別的變量，變量存儲在java對象的內(nèi)部，必須先有對象
// 通過對象才能訪問no這個實(shí)例變量，不能直接通過"類名"訪問
// System.out.println(Student.no);
// 在通過類實(shí)例化一個全新的對象
// stu是一個引用類型
// stu同時也是一個局部變量
// Student是變量的數(shù)據(jù)類型
Student stu = new Student();
System.out.println("學(xué)號 = " + stu.no); // 0
System.out.println("姓名 = " + stu.name); // null
System.out.println("年齡 = " + stu.age); // false
System.out.println("性別 = " + stu.sex); // 0
System.out.println("地址 = " + stu.addr); // null
}
}
/*
局部變量在棧內(nèi)存中存儲
成員變量中的實(shí)例變量在堆內(nèi)存的java對象內(nèi)存存儲
實(shí)例變量是一個對象一份，100個對象有100份。
*/
// 用戶類
public class User{
// 屬性【以下都是成員變量之實(shí)例變量】
// 用戶編號
// int 是一種基本數(shù)據(jù)類型：整數(shù)型
// no是一個實(shí)例變量
int no;
// 用戶名
// String 是一種引用數(shù)據(jù)類型：代表字符串
// name是一個實(shí)例變量
// name是一個引用
String name;
// 家庭住址
// Adddress是一種引用數(shù)據(jù)類型：代表家庭住址
// addr是一個實(shí)例變量
// addr是一個引用
Address addr;
}
// ----------------------------------------------------------------------
// 家庭住址類
public class Address{
// 屬性成員變量之實(shí)例變量】
// 城市
// String是一種引用數(shù)據(jù)類型，city是一個變量名，屬于實(shí)例變量
// oity是一個引用：保存內(nèi)存地址的一個變量，該變量保存內(nèi)存地址指向了堆內(nèi)存當(dāng)中的對象
String city;
// 街道
String street;
// 郵編
String zipcode;
}
// ----------------------------------------------------------------------
// 測試類
public class OOTest02{
public static void main(String[] args){
// 創(chuàng)建User對象
// u是局部變量
// u是一個應(yīng)用
// u保存內(nèi)存地址指向堆內(nèi)存的User對象
User u = new User();
// 輸出User對象內(nèi)部實(shí)例變量的值
System.out.println(u.no); // 0
System.out.println(u.name); // null
System.out.println(u.addr); // null
// 修改User對象內(nèi)部實(shí)例變量的值
u.no = 110;
u.name = "jack"; // "jack" 是一個java對象，屬于String對象
u.addr = new Address();
// 在main方法當(dāng)中目前只能看到一個引用“u”
// 一切都是只能通過u來進(jìn)行訪問
System.out.println(u.name + "居住在那個城市:" + u.addr.oity);
System.out.println(u.name + "居住在那個街道:" + u.addr.street);
System.out.println(u.name + "居住在那個郵編:" + u.addr.zipcode);
u.addr.oity = "深圳";
u.addr.street = "福田";
u.addr.zipcode = "516600";
System.out.println(u.name + "居住在那個城市:" + u.addr.oity);
System.out.println(u.name + "居住在那個街道:" + u.addr.street);
System.out.println(u.name + "居住在那個郵編:" + u.addr.zipcode);
}
}
public class OOTest03{
public static void main(String[] args){
// u是引用
// u是局部變量
User u = new User();
// 上一個版本中編寫的
// u.addr = new Address();
// a是引用
// a是局部變量
Address a = new Address();
u.addr = a;
System.out.println(u.addr.city); // null
a.city = "天津";
System.out.println(u.addr.city); // 天津
u.addr.city = "深圳";
System.out.println(u.addr.city); // 深圳
}
}
// 丈夫類
public class Husband{
// 姓名
String name;
// 丈夫?qū)ο螽?dāng)中含有妻子引用
Wife w;
}
// -----------------------------------------------------------------
// 妻子類
public class Wife{
// 姓名
String name;
// 妻子對象當(dāng)中含有丈夫引用
Husband h;
}
// -------------------------------------------------------------------
public class OOTest04{
public static void main(String[] args){
// 創(chuàng)建一個丈夫?qū)ο?
Husband huangXiaoMing = new Husband();
huangXiaoMing.name = "黃曉明";
// 創(chuàng)建一個妻子對象
Wife baby = new Wife();
baby.name = "baby";
// 結(jié)婚【能通過丈夫找到妻子，通過妻子也可以找到丈夫】
huangXiaoMing.w = baby;
baby.h = huangXiaoMing;
// 得到以上“黃曉明”的妻子的名字
System.out.println(huangXiaoMing.name + "的妻子名字叫：" + baby.name);
System.out.println(huangXiaoMing.name + "的妻子名字叫：" + huangXiaoMing.w.name);
}
}
知識點(diǎn)
// 顧客類
public class Customer
{
// id
int id;
}
// ------------------------------------------------------------------------
// 測試程序
public class OOTest05
{
public static void main(String[] args){
Customer c = new Customer();
System.out.println(c.id); // 0
c = null;
// 以下程序編譯可以通過，因?yàn)榉险Z法
// 運(yùn)行出現(xiàn)空指針異常
// 空應(yīng)用訪問“實(shí)例”相關(guān)的數(shù)據(jù)一定會出現(xiàn)空指針異常
// java.lang.NullPointerException
System.out.println(c.id);
}
}
// “實(shí)例”相關(guān)的數(shù)據(jù)表示：這個數(shù)據(jù)訪問的時候必須有對象的參與，這種數(shù)據(jù)就是實(shí)例相關(guān)的數(shù)據(jù)
/*
Java語言是面向?qū)ο?
要想創(chuàng)建對象必須先定義類
定義類的語法：
[修飾符列表] class 類名{
屬性：
方法：
}
屬性通常采用變量來表示，既然是變量那么變量肯定有數(shù)據(jù)類型?！緮?shù)據(jù)類型包括：基本數(shù)據(jù)類型 + 引用數(shù)據(jù)類型】
屬性對應(yīng)的是狀態(tài)信息。
觀察現(xiàn)實(shí)世界當(dāng)中超市中的商品，發(fā)現(xiàn)這所有的商品都有一些共同的特征，例如，每一個商品都有編號，每一個商品都有單價，所以定義以下的類，來代表所有的商品
*/
public class Product{
// 編號 【通常是一個數(shù)字，而且該數(shù)字通常是整數(shù)型的】
// productNo 是基本數(shù)據(jù)類型
// 實(shí)例變量
int productNo;
// 單價 【通常是一個數(shù)字，但是數(shù)字可能帶有小數(shù)，所以采用浮點(diǎn)型數(shù)據(jù)double表示】
// price 是基本數(shù)據(jù)類型
// 實(shí)例變量
double price;
// ----------------------------------------------------------------------
/*
每一個類中都可以編寫主方法，但是一般情況下
一個系統(tǒng)只有一個入口，所以主方法一般寫一個
*/
public class ProductTest{ // 商品測試類
// 程序入口
public static void main(String[] args){
// 創(chuàng)建對象，商品對象
// iphone7 局部變量
// iphone7 應(yīng)用
// iphone7 變量中保存內(nèi)存地址的指向堆內(nèi)存當(dāng)中的商品對象
Product iphone7 = new Product();
// 訪問實(shí)例變量的語法：引用.變量
// 讀?。阂?變量名
System.out.println("商品的編號：" + iphone7.productNo);
System.out.println("商品的單價：" + iphone7.price);
// 修改：引用.變量名 = 值;
iphone7.productNo = 111;
iphone7.price = 68000;
System.out.println("商品的編號：" + iphone7.productNo);
System.out.println("商品的單價：" + iphone7.price);
}
}
// 人類
public class Ren{
// 身份證號
String id;
// 名字
String name;
// 性別
boolean sex;
// 年齡
int age;
}
// -------------------------------------------------------------------------
/*
別墅類
* 面積
* 主人
*/
public class BieShu{
// 面積
double mianJi;
// 主人【人類】
// 變量/應(yīng)引用
// 變量怎么聲明：數(shù)據(jù)類型 變量名;
// 關(guān)聯(lián)關(guān)系： A has a B 關(guān)系【A對象中含有B對象的引用】
// BieShu對象含有Ren對象的引用
Ren zhuRen;
}
// ----------------------------------------------------------------------
public class Test{
public static void main(String[] args){
// 思路：先創(chuàng)造人物對象，再創(chuàng)造別墅對象，讓別墅有主人
Ren zhangsan = new Ren(); // 初始化
// 不采用系統(tǒng)默認(rèn)值
// 手動賦值
zhangsan.id = "45682110";
zhangsan.name = "張三";
zhangsan.sex = true;
zhangsan.age = 100;
// 創(chuàng)建別墅對象
BieShu fangzi = new BieShu();
fangzi.mianJi = 150.0;
fangzi.zhuRen = zhangsan;
// 想知道房子主人的名字是什么？
System.out.println(fangzi.zhuRen.name);
// 房子換主人
// 創(chuàng)建一個新的主人對象
Ren lisi = new Ren();
lisi.name = "李四";
// 換主人
fangzi.zhuRen = lisi;
System.out.println(fangzi.zhuRen.name);
}
}
// 學(xué)生類
class Student{
String name;
int no;
// 筆記本
Notebook book;
}
// ----------------------------------------------------------------------
// 筆記本類
class Notebook{
// 品牌
String brand;
// 型號
String model;
// 顏色
String color;
}
// ----------------------------------------------------------------------
/*
需求：
定義一個計算機(jī)類【電腦/筆記本】，計算機(jī)類有那些屬性
* 品牌 * 型號 * 顏色
定義一個學(xué)生類，學(xué)生類有那些屬性：
* 姓名 * 學(xué)號 * 學(xué)生有一臺筆記本電腦
請編寫程序來表示以上的類，然后分別將類創(chuàng)建為對象，對象數(shù)量不限，然后讓其中的一個學(xué)生去使用其中的一臺筆記本電腦
然后編譯并運(yùn)行，并且將整個執(zhí)行過程采用圖形的方式描述出來。
*/
// 測試類
public class OOTest06{
public static void main(String[] args){
// 創(chuàng)建筆記本對象
Notebook BiJiBen = new Notebook();
// 手動賦值
BiJiBen.brand = "華為";
BiJiBen.model = "KX100";
BiJiBen.color = "黑色";
// 創(chuàng)建學(xué)生對象
Student s = new Student();
// 手動賦值
s.no = 111;
s.name = "jack";
s.book = BiJiBen;
System.out.println(s.name);
System.out.println(s.no);
System.out.println(s.book.brand);
// 讓這個學(xué)生和筆記本對象產(chǎn)生關(guān)系【通過學(xué)生能找到他的筆記本】
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.brand);
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.model);
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.color);
// 修改品牌
s.book.brand = "蘋果";
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.brand);
}
}
總結(jié)
本篇文章就到這里了，希望能給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！
相關(guān)文章
-
Druid連接池的自定義過濾功能實(shí)現(xiàn)方法
在數(shù)據(jù)密集型應(yīng)用中,監(jiān)控和分析數(shù)據(jù)庫操作對于確保性能和穩(wěn)定性至關(guān)重要,本文將探討如何實(shí)現(xiàn)一個自定義的Druid過濾器來捕獲數(shù)據(jù)庫請求并進(jìn)行日志記錄,以輔助開發(fā)和維護(hù)工作,需要的朋友可以參考下 2023-11-11
-
Java編程使用UDP建立群聊系統(tǒng)代碼實(shí)例
這篇文章主要介紹了Java編程使用UDP建立群聊系統(tǒng)代碼實(shí)例，具有一定借鑒價值,需要的朋友可以參考下。 2018-01-01
-
一般來講SpringBoot項目是不需要指定版本，而SSM項目是需要指定版本，SpringBoot的核心依賴就是spring-boot-starter-parent和spring-boot-starter-web兩個依賴，關(guān)于這兩個依賴的相關(guān)介紹具體今天小編給大家介紹下 2022-06-06
-
Java Code Cache滿導(dǎo)致應(yīng)用性能降低問題解決
這篇文章主要介紹了Java Code Cache滿導(dǎo)致應(yīng)用性能降低問題解決,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下 2021-08-08
-
這篇文章主要介紹了SpringBoot?JPA常用注解的使用方法,spring?boot作為當(dāng)前主流的技術(shù),來看看常用的注解怎么用,如果有錯誤的地方還請指正,需要的朋友可以參考下 2023-03-03
-
java?freemarker實(shí)現(xiàn)動態(tài)生成excel文件
這篇文章主要為大家詳細(xì)介紹了java如何通過freemarker實(shí)現(xiàn)動態(tài)生成excel文件,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下 2023-12-12
-
在spring?boot3中使用native?image的最新方法
這篇文章主要介紹了在spring?boot3中使用native?image?,今天我們用具體的例子來給大家演示一下如何正確的將spring boot3的應(yīng)用編譯成為native image，需要的朋友可以參考下 2023-01-01
-
這篇文章主要為大家介紹了Java之冒泡排序與選擇排序，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助 2021-12-12
-
這篇文章主要為大家詳細(xì)介紹了maven搭建java ee項目圖文教程，感興趣的小伙伴們可以參考一下 2016-04-04
-
這篇文章主要介紹了Java異常處理方法匯總，我們在軟件開發(fā)的過程中，任何語言的開發(fā)過程中都離不開異常處理。下面下小編加來給大家分享各種異常處理，希望對大家有所幫助,需要的朋友可以參考一下 2021-12-12
最新評論
java面向?qū)ο?/h2>
面向?qū)ο蟆綣ava語言的核心機(jī)制，最重要的內(nèi)容，Java語言的特色】
* 面向過程和面向?qū)ο蟮膮^(qū)別
- 面向過程：主要關(guān)注點(diǎn)是：實(shí)現(xiàn)的具體過程，因果關(guān)系【集成顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：對于業(yè)務(wù)邏輯比較簡單的程序，可以達(dá)到快速開發(fā)，前期投入成本較低。
* 缺點(diǎn)：采用面向過程的方式開發(fā)很難解決非常復(fù)雜的業(yè)務(wù)邏輯，另外面向過程的
方式導(dǎo)致軟件元素之間的“耦合度”非常高，只要其中一環(huán)出問題，整個系統(tǒng)受到影響，
導(dǎo)致最終的軟件“擴(kuò)展力”差。另外，由于沒有獨(dú)立體的概念，所以無法達(dá)到組件復(fù)用。
- 面向?qū)ο螅褐饕P(guān)注點(diǎn)是：主要關(guān)注對象【獨(dú)立體】能完成哪些功能。【獨(dú)立顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：耦合度低，擴(kuò)展力強(qiáng)。更容易解決現(xiàn)實(shí)世界當(dāng)中更復(fù)雜的業(yè)務(wù)邏輯。組件復(fù)用性強(qiáng)。
* 缺點(diǎn)：前期投入成本較高，需要進(jìn)行獨(dú)立體的抽取，大量的系統(tǒng)分析與設(shè)計。
- C語言是純面向過程的、C++半面向?qū)ο?、Java純面向?qū)ο?
- 現(xiàn)在出現(xiàn)的一些新的編程語言多數(shù)都是面向?qū)ο蟮?。人在認(rèn)識現(xiàn)實(shí)世界的時候以面向?qū)ο蟮姆绞健?
- 面向?qū)ο蟾先说乃季S方式。
* 面向?qū)ο蟮娜筇卣鳌鞠缺硶?
- 封裝
- 繼承
- 多態(tài)
所有面向?qū)ο蟮木幊陶Z言都有這三大特征。
采用面向?qū)ο蟮姆绞介_發(fā)一個軟件，生命周期當(dāng)中：【整個生命周期中貫穿使用OO面向?qū)ο蠓绞健?
* 面向?qū)ο蟮姆治觯篛OA
* 面向?qū)ο蟮脑O(shè)計：OOD
* 面向?qū)ο蟮木幊蹋篛OP
* 類和對象的概念
* 什么是類？
- 類在現(xiàn)實(shí)世界當(dāng)中是不存在的，是一個模板，是一個概念。是人類大腦思考抽象的結(jié)果。
- 類代表了一類事物。
- 在現(xiàn)實(shí)世界當(dāng)中，對象A與對象B之間具有共同特征，進(jìn)行抽象總結(jié)出一個模板，這個模板被稱為類。
* 什么是對象？
- 對象是實(shí)際存在的個體?，F(xiàn)實(shí)世界當(dāng)中實(shí)際存在。
* 描述一下整個軟件開發(fā)的過程：
* 程序員先觀察現(xiàn)實(shí)世界，從現(xiàn)實(shí)世界當(dāng)中尋找對象
* 尋找了N多個對象之后，發(fā)現(xiàn)所有的對象都有共同特征
* 程序員在大腦中形成了一個模板【類】
* Java程序員可以通過java代碼來表述一個類
* Java程序中有了類的定義
* 然后通過類就可以創(chuàng)建對象
* 有了對象之后，可以讓對象直接協(xié)作起來形成一個系統(tǒng)。
* 類--【實(shí)例化】->對象
* 對象又被稱為實(shí)例/instance
* 對象--【抽象】-->類
* 重點(diǎn)：
類描述的是對象的共同特征。
共同特征例如：身高特征
這個身高特征在訪問的時候，必須先創(chuàng)建對象，通過對象去訪問這個特征。
因?yàn)檫@個特征具體的某個對象上之后，值不同。有的對象身高1.80，有的
對象身高2.80。
* 一個類主要描述什么信息呢？
一個類主要描述的是 狀態(tài) + 動作。
狀態(tài)信息：名字、身高、性別、年齡
動作信息：吃、唱歌、跳舞、學(xué)習(xí)
狀態(tài)--> 一個類的屬性
動作--> 一個類的方法
*
類{
屬性; //描述對象的狀態(tài)信息
方法; //描述對象的動作信息
}
注意：
狀態(tài)和動作當(dāng)具體到某個對象上之后，發(fā)現(xiàn)最終的結(jié)果可能不一樣。
對象和對象之間有共同特征，但是具體到對象之后有數(shù)據(jù)的差異。
* 類的定義【從這里開始編寫代碼】
語法結(jié)構(gòu)：
[修飾符列表] class 類名{
屬性;
方法;
}
學(xué)生類，描述所有學(xué)生對象的共同特征：
學(xué)生對象有哪些狀態(tài)信息：
* 學(xué)號【int】
* 名字【String】
* 性別【boolean】
* 年齡【int】【年齡是一個屬性，年齡是一個數(shù)據(jù)，是數(shù)據(jù)就應(yīng)該有數(shù)據(jù)類型】
* 住址【String】
.....
學(xué)生對象有哪些動作信息：
* 吃飯
* 睡覺
* 學(xué)習(xí)
* 玩
* 唱歌
* 跳舞
....
重點(diǎn)：屬性通常是采用一個變量的形式來完成定義的。
int no;
int age;
String name;
String address;
boolean sex;
* java語言中包括兩種數(shù)據(jù)類型：
- 基本數(shù)據(jù)類型
byte
short
int
long
float
double
boolean
char
- 引用數(shù)據(jù)類型
String.class SUN提供的
System.class SUN提供的
Student.class 程序員自定義的
User.class 程序員自定義的
Product.class 程序員自定義的
Customer.class 程序員自定義的
......
- java語言中所有的class都屬于引用數(shù)據(jù)類型。
// 定義一個類，類名Student
// Student是一個類，代表了所有的學(xué)生對象，是一個學(xué)生的模板。
public class Student{ // 定義一個公開的類，起名Student
// 屬性【描述的是對象的狀態(tài)信息】
// 熟悉通常采用變量的方式來定義
// 在類體當(dāng)中，方法體之外定義的變量被稱為“成員變量”
// 成員變量沒有賦值，系統(tǒng)賦默認(rèn)值：一切箱0看齊。
// 學(xué)號
int no;
// 姓名
String name;
// 性別
boolean sex;
// 年齡
int age;
// 住址
String address;
// 方法
// 方法描述的是對象的動作信息
// 當(dāng)前例子就只描述屬性了
}
// 學(xué)生類
// 學(xué)生類是一個模板
// 描述了所有學(xué)生的共同特征【狀態(tài)+行為】
// 當(dāng)前類只描述學(xué)生的狀態(tài)信息【屬性】
// Student是類，屬于引用數(shù)據(jù)類型，這個類型名就是：Student
public class Student{
// 類體-屬性+方法
// 屬性【存儲數(shù)據(jù)采用變量的形式】
// 由于變量定義在類體當(dāng)中，方法體之外，這種變量稱為成員變量
// 所有學(xué)生都有學(xué)好信息
// 但是每一個學(xué)生的學(xué)號都是不同的
// 所以要訪問這個學(xué)號必須先創(chuàng)建對象，通過對象去訪問學(xué)號信息
// 學(xué)號信息不能直接通過“類”去訪問，所以這種成員變量又被叫做：實(shí)例變量
// 對象又被稱為實(shí)例，實(shí)例變量又成為對象變量?！緦ο蠹墑e的變量】
// 不創(chuàng)建對象，這個no變量的內(nèi)存空間是不存在的，只有創(chuàng)建了對象，這個no變量內(nèi)存空間才會創(chuàng)建
int no;
// 姓名
String name;
// 年齡
int age;
// 性別
boolean sex;
// 住址
String addr;
}
// 成員變量沒有手動賦值的話，系統(tǒng)賦默認(rèn)值
// 默認(rèn)值
/*
數(shù)據(jù)類型 默認(rèn)值
---------------------------------
byte，short，int，long 0
float，double 0.0
boolean false
char \u0000
引用數(shù)據(jù)類型 null 空值
*/
// -----------------------------------------------------------------------------------------------------
/*
對象的創(chuàng)建和使用
*/
public class OOTest01
{
public static void main(String[] args){
// int 是基本數(shù)據(jù)類型
// i 是一個變量名
// 10是一個int類型的字面值
int i = 10;
// 通過一個類可以實(shí)例化N個對象
// 實(shí)例化對象的語法：new 類名();
// new是java語言當(dāng)中的一個運(yùn)算符
// new運(yùn)算符的作用是創(chuàng)建對象，在JVM堆內(nèi)存當(dāng)中開辟新的內(nèi)存空間
// 方法區(qū)內(nèi)存：在類加載的時候，class字節(jié)碼片段被加載到該內(nèi)存空間當(dāng)中
// 棧內(nèi)存（局部變量）：方法代碼片段執(zhí)行的時候，會給該方法分配內(nèi)存空間，在棧內(nèi)存中壓棧
// 堆內(nèi)存：new的對象在堆內(nèi)存中存儲
// Student是一個應(yīng)用數(shù)據(jù)類型
// s 是一個變量名
// new Student()是一個學(xué)生對象
// s是一個局部變量【在棧內(nèi)存中存儲】
// 什么是對象？new運(yùn)算符在堆內(nèi)存中開辟的內(nèi)存空間稱為對象
// 什么是引用？引用是一個變量，只不過這個變量保存了另一個java對象的內(nèi)存地址
// java語言當(dāng)中，程序員不能直接操作堆內(nèi)存，java中沒有指針，不像c語言
// java語言當(dāng)中，程序員只能通過“引用”去訪問堆內(nèi)存當(dāng)中對象內(nèi)部的示例變量
Student s = new Student();
// 訪問實(shí)例變量的語法格式：
// 讀取數(shù)據(jù)：引用.變量名
// 修改數(shù)據(jù)：引用.變量名 = 值
/*
int stuNo = s.no;
String stuName = s.name;
int stuAge = s.age;
boolean stuSex = s.sex;
String stuAddr = s.addr;
System.out.println("學(xué)號 = " + stuNo);
System.out.println("姓名 = " + stuName);
System.out.println("年齡 = " + stuAge);
System.out.println("性別 = " + stuSex);
System.out.println("地址 = " + stuAddr);
*/
s.no = 10;
s.name = "jack";
s.age = 20;
s.sex = true;
s.addr = "深圳";
System.out.println("學(xué)號 = " + s.no); // 10
System.out.println("姓名 = " + s.name); // jack
System.out.println("年齡 = " + s.age); // 20
System.out.println("性別 = " + s.sex); // true
System.out.println("地址 = " + s.addr); // 深圳
// 編譯報錯，no這個實(shí)例變量不能直接采用”類名“的方式訪問
// 因?yàn)閚o是實(shí)例變量，對象級別的變量，變量存儲在java對象的內(nèi)部，必須先有對象
// 通過對象才能訪問no這個實(shí)例變量，不能直接通過"類名"訪問
// System.out.println(Student.no);
// 在通過類實(shí)例化一個全新的對象
// stu是一個引用類型
// stu同時也是一個局部變量
// Student是變量的數(shù)據(jù)類型
Student stu = new Student();
System.out.println("學(xué)號 = " + stu.no); // 0
System.out.println("姓名 = " + stu.name); // null
System.out.println("年齡 = " + stu.age); // false
System.out.println("性別 = " + stu.sex); // 0
System.out.println("地址 = " + stu.addr); // null
}
}
/*
局部變量在棧內(nèi)存中存儲
成員變量中的實(shí)例變量在堆內(nèi)存的java對象內(nèi)存存儲
實(shí)例變量是一個對象一份，100個對象有100份。
*/
面向?qū)ο蟆綣ava語言的核心機(jī)制，最重要的內(nèi)容，Java語言的特色】
* 面向過程和面向?qū)ο蟮膮^(qū)別
- 面向過程：主要關(guān)注點(diǎn)是：實(shí)現(xiàn)的具體過程，因果關(guān)系【集成顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：對于業(yè)務(wù)邏輯比較簡單的程序，可以達(dá)到快速開發(fā)，前期投入成本較低。
* 缺點(diǎn)：采用面向過程的方式開發(fā)很難解決非常復(fù)雜的業(yè)務(wù)邏輯，另外面向過程的
方式導(dǎo)致軟件元素之間的“耦合度”非常高，只要其中一環(huán)出問題，整個系統(tǒng)受到影響，
導(dǎo)致最終的軟件“擴(kuò)展力”差。另外，由于沒有獨(dú)立體的概念，所以無法達(dá)到組件復(fù)用。
- 面向?qū)ο螅褐饕P(guān)注點(diǎn)是：主要關(guān)注對象【獨(dú)立體】能完成哪些功能。【獨(dú)立顯卡的開發(fā)思路】
* 優(yōu)點(diǎn)：耦合度低，擴(kuò)展力強(qiáng)。更容易解決現(xiàn)實(shí)世界當(dāng)中更復(fù)雜的業(yè)務(wù)邏輯。組件復(fù)用性強(qiáng)。
* 缺點(diǎn)：前期投入成本較高，需要進(jìn)行獨(dú)立體的抽取，大量的系統(tǒng)分析與設(shè)計。
- C語言是純面向過程的、C++半面向?qū)ο?、Java純面向?qū)ο?
- 現(xiàn)在出現(xiàn)的一些新的編程語言多數(shù)都是面向?qū)ο蟮?。人在認(rèn)識現(xiàn)實(shí)世界的時候以面向?qū)ο蟮姆绞健?
- 面向?qū)ο蟾先说乃季S方式。
* 面向?qū)ο蟮娜筇卣鳌鞠缺硶?
- 封裝
- 繼承
- 多態(tài)
所有面向?qū)ο蟮木幊陶Z言都有這三大特征。
采用面向?qū)ο蟮姆绞介_發(fā)一個軟件，生命周期當(dāng)中：【整個生命周期中貫穿使用OO面向?qū)ο蠓绞健?
* 面向?qū)ο蟮姆治觯篛OA
* 面向?qū)ο蟮脑O(shè)計：OOD
* 面向?qū)ο蟮木幊蹋篛OP
* 類和對象的概念
* 什么是類？
- 類在現(xiàn)實(shí)世界當(dāng)中是不存在的，是一個模板，是一個概念。是人類大腦思考抽象的結(jié)果。
- 類代表了一類事物。
- 在現(xiàn)實(shí)世界當(dāng)中，對象A與對象B之間具有共同特征，進(jìn)行抽象總結(jié)出一個模板，這個模板被稱為類。
* 什么是對象？
- 對象是實(shí)際存在的個體?，F(xiàn)實(shí)世界當(dāng)中實(shí)際存在。
* 描述一下整個軟件開發(fā)的過程：
* 程序員先觀察現(xiàn)實(shí)世界，從現(xiàn)實(shí)世界當(dāng)中尋找對象
* 尋找了N多個對象之后，發(fā)現(xiàn)所有的對象都有共同特征
* 程序員在大腦中形成了一個模板【類】
* Java程序員可以通過java代碼來表述一個類
* Java程序中有了類的定義
* 然后通過類就可以創(chuàng)建對象
* 有了對象之后，可以讓對象直接協(xié)作起來形成一個系統(tǒng)。
* 類--【實(shí)例化】->對象
* 對象又被稱為實(shí)例/instance
* 對象--【抽象】-->類
* 重點(diǎn)：
類描述的是對象的共同特征。
共同特征例如：身高特征
這個身高特征在訪問的時候，必須先創(chuàng)建對象，通過對象去訪問這個特征。
因?yàn)檫@個特征具體的某個對象上之后，值不同。有的對象身高1.80，有的
對象身高2.80。
* 一個類主要描述什么信息呢？
一個類主要描述的是 狀態(tài) + 動作。
狀態(tài)信息：名字、身高、性別、年齡
動作信息：吃、唱歌、跳舞、學(xué)習(xí)
狀態(tài)--> 一個類的屬性
動作--> 一個類的方法
*
類{
屬性; //描述對象的狀態(tài)信息
方法; //描述對象的動作信息
}
注意：
狀態(tài)和動作當(dāng)具體到某個對象上之后，發(fā)現(xiàn)最終的結(jié)果可能不一樣。
對象和對象之間有共同特征，但是具體到對象之后有數(shù)據(jù)的差異。
* 類的定義【從這里開始編寫代碼】
語法結(jié)構(gòu)：
[修飾符列表] class 類名{
屬性;
方法;
}
學(xué)生類，描述所有學(xué)生對象的共同特征：
學(xué)生對象有哪些狀態(tài)信息：
* 學(xué)號【int】
* 名字【String】
* 性別【boolean】
* 年齡【int】【年齡是一個屬性，年齡是一個數(shù)據(jù)，是數(shù)據(jù)就應(yīng)該有數(shù)據(jù)類型】
* 住址【String】
.....
學(xué)生對象有哪些動作信息：
* 吃飯
* 睡覺
* 學(xué)習(xí)
* 玩
* 唱歌
* 跳舞
....
重點(diǎn)：屬性通常是采用一個變量的形式來完成定義的。
int no;
int age;
String name;
String address;
boolean sex;
* java語言中包括兩種數(shù)據(jù)類型：
- 基本數(shù)據(jù)類型
byte
short
int
long
float
double
boolean
char
- 引用數(shù)據(jù)類型
String.class SUN提供的
System.class SUN提供的
Student.class 程序員自定義的
User.class 程序員自定義的
Product.class 程序員自定義的
Customer.class 程序員自定義的
......
- java語言中所有的class都屬于引用數(shù)據(jù)類型。
// 定義一個類，類名Student
// Student是一個類，代表了所有的學(xué)生對象，是一個學(xué)生的模板。
public class Student{ // 定義一個公開的類，起名Student
// 屬性【描述的是對象的狀態(tài)信息】
// 熟悉通常采用變量的方式來定義
// 在類體當(dāng)中，方法體之外定義的變量被稱為“成員變量”
// 成員變量沒有賦值，系統(tǒng)賦默認(rèn)值：一切箱0看齊。
// 學(xué)號
int no;
// 姓名
String name;
// 性別
boolean sex;
// 年齡
int age;
// 住址
String address;
// 方法
// 方法描述的是對象的動作信息
// 當(dāng)前例子就只描述屬性了
}
// 學(xué)生類
// 學(xué)生類是一個模板
// 描述了所有學(xué)生的共同特征【狀態(tài)+行為】
// 當(dāng)前類只描述學(xué)生的狀態(tài)信息【屬性】
// Student是類，屬于引用數(shù)據(jù)類型，這個類型名就是：Student
public class Student{
// 類體-屬性+方法
// 屬性【存儲數(shù)據(jù)采用變量的形式】
// 由于變量定義在類體當(dāng)中，方法體之外，這種變量稱為成員變量
// 所有學(xué)生都有學(xué)好信息
// 但是每一個學(xué)生的學(xué)號都是不同的
// 所以要訪問這個學(xué)號必須先創(chuàng)建對象，通過對象去訪問學(xué)號信息
// 學(xué)號信息不能直接通過“類”去訪問，所以這種成員變量又被叫做：實(shí)例變量
// 對象又被稱為實(shí)例，實(shí)例變量又成為對象變量?！緦ο蠹墑e的變量】
// 不創(chuàng)建對象，這個no變量的內(nèi)存空間是不存在的，只有創(chuàng)建了對象，這個no變量內(nèi)存空間才會創(chuàng)建
int no;
// 姓名
String name;
// 年齡
int age;
// 性別
boolean sex;
// 住址
String addr;
}
// 成員變量沒有手動賦值的話，系統(tǒng)賦默認(rèn)值
// 默認(rèn)值
/*
數(shù)據(jù)類型 默認(rèn)值
---------------------------------
byte，short，int，long 0
float，double 0.0
boolean false
char \u0000
引用數(shù)據(jù)類型 null 空值
*/
// -----------------------------------------------------------------------------------------------------
/*
對象的創(chuàng)建和使用
*/
public class OOTest01
{
public static void main(String[] args){
// int 是基本數(shù)據(jù)類型
// i 是一個變量名
// 10是一個int類型的字面值
int i = 10;
// 通過一個類可以實(shí)例化N個對象
// 實(shí)例化對象的語法：new 類名();
// new是java語言當(dāng)中的一個運(yùn)算符
// new運(yùn)算符的作用是創(chuàng)建對象，在JVM堆內(nèi)存當(dāng)中開辟新的內(nèi)存空間
// 方法區(qū)內(nèi)存：在類加載的時候，class字節(jié)碼片段被加載到該內(nèi)存空間當(dāng)中
// 棧內(nèi)存（局部變量）：方法代碼片段執(zhí)行的時候，會給該方法分配內(nèi)存空間，在棧內(nèi)存中壓棧
// 堆內(nèi)存：new的對象在堆內(nèi)存中存儲
// Student是一個應(yīng)用數(shù)據(jù)類型
// s 是一個變量名
// new Student()是一個學(xué)生對象
// s是一個局部變量【在棧內(nèi)存中存儲】
// 什么是對象？new運(yùn)算符在堆內(nèi)存中開辟的內(nèi)存空間稱為對象
// 什么是引用？引用是一個變量，只不過這個變量保存了另一個java對象的內(nèi)存地址
// java語言當(dāng)中，程序員不能直接操作堆內(nèi)存，java中沒有指針，不像c語言
// java語言當(dāng)中，程序員只能通過“引用”去訪問堆內(nèi)存當(dāng)中對象內(nèi)部的示例變量
Student s = new Student();
// 訪問實(shí)例變量的語法格式：
// 讀取數(shù)據(jù)：引用.變量名
// 修改數(shù)據(jù)：引用.變量名 = 值
/*
int stuNo = s.no;
String stuName = s.name;
int stuAge = s.age;
boolean stuSex = s.sex;
String stuAddr = s.addr;
System.out.println("學(xué)號 = " + stuNo);
System.out.println("姓名 = " + stuName);
System.out.println("年齡 = " + stuAge);
System.out.println("性別 = " + stuSex);
System.out.println("地址 = " + stuAddr);
*/
s.no = 10;
s.name = "jack";
s.age = 20;
s.sex = true;
s.addr = "深圳";
System.out.println("學(xué)號 = " + s.no); // 10
System.out.println("姓名 = " + s.name); // jack
System.out.println("年齡 = " + s.age); // 20
System.out.println("性別 = " + s.sex); // true
System.out.println("地址 = " + s.addr); // 深圳
// 編譯報錯，no這個實(shí)例變量不能直接采用”類名“的方式訪問
// 因?yàn)閚o是實(shí)例變量，對象級別的變量，變量存儲在java對象的內(nèi)部，必須先有對象
// 通過對象才能訪問no這個實(shí)例變量，不能直接通過"類名"訪問
// System.out.println(Student.no);
// 在通過類實(shí)例化一個全新的對象
// stu是一個引用類型
// stu同時也是一個局部變量
// Student是變量的數(shù)據(jù)類型
Student stu = new Student();
System.out.println("學(xué)號 = " + stu.no); // 0
System.out.println("姓名 = " + stu.name); // null
System.out.println("年齡 = " + stu.age); // false
System.out.println("性別 = " + stu.sex); // 0
System.out.println("地址 = " + stu.addr); // null
}
}
/*
局部變量在棧內(nèi)存中存儲
成員變量中的實(shí)例變量在堆內(nèi)存的java對象內(nèi)存存儲
實(shí)例變量是一個對象一份，100個對象有100份。
*/
// 用戶類
public class User{
// 屬性【以下都是成員變量之實(shí)例變量】
// 用戶編號
// int 是一種基本數(shù)據(jù)類型：整數(shù)型
// no是一個實(shí)例變量
int no;
// 用戶名
// String 是一種引用數(shù)據(jù)類型：代表字符串
// name是一個實(shí)例變量
// name是一個引用
String name;
// 家庭住址
// Adddress是一種引用數(shù)據(jù)類型：代表家庭住址
// addr是一個實(shí)例變量
// addr是一個引用
Address addr;
}
// ----------------------------------------------------------------------
// 家庭住址類
public class Address{
// 屬性成員變量之實(shí)例變量】
// 城市
// String是一種引用數(shù)據(jù)類型，city是一個變量名，屬于實(shí)例變量
// oity是一個引用：保存內(nèi)存地址的一個變量，該變量保存內(nèi)存地址指向了堆內(nèi)存當(dāng)中的對象
String city;
// 街道
String street;
// 郵編
String zipcode;
}
// ----------------------------------------------------------------------
// 測試類
public class OOTest02{
public static void main(String[] args){
// 創(chuàng)建User對象
// u是局部變量
// u是一個應(yīng)用
// u保存內(nèi)存地址指向堆內(nèi)存的User對象
User u = new User();
// 輸出User對象內(nèi)部實(shí)例變量的值
System.out.println(u.no); // 0
System.out.println(u.name); // null
System.out.println(u.addr); // null
// 修改User對象內(nèi)部實(shí)例變量的值
u.no = 110;
u.name = "jack"; // "jack" 是一個java對象，屬于String對象
u.addr = new Address();
// 在main方法當(dāng)中目前只能看到一個引用“u”
// 一切都是只能通過u來進(jìn)行訪問
System.out.println(u.name + "居住在那個城市:" + u.addr.oity);
System.out.println(u.name + "居住在那個街道:" + u.addr.street);
System.out.println(u.name + "居住在那個郵編:" + u.addr.zipcode);
u.addr.oity = "深圳";
u.addr.street = "福田";
u.addr.zipcode = "516600";
System.out.println(u.name + "居住在那個城市:" + u.addr.oity);
System.out.println(u.name + "居住在那個街道:" + u.addr.street);
System.out.println(u.name + "居住在那個郵編:" + u.addr.zipcode);
}
}
public class OOTest03{
public static void main(String[] args){
// u是引用
// u是局部變量
User u = new User();
// 上一個版本中編寫的
// u.addr = new Address();
// a是引用
// a是局部變量
Address a = new Address();
u.addr = a;
System.out.println(u.addr.city); // null
a.city = "天津";
System.out.println(u.addr.city); // 天津
u.addr.city = "深圳";
System.out.println(u.addr.city); // 深圳
}
}
// 丈夫類
public class Husband{
// 姓名
String name;
// 丈夫?qū)ο螽?dāng)中含有妻子引用
Wife w;
}
// -----------------------------------------------------------------
// 妻子類
public class Wife{
// 姓名
String name;
// 妻子對象當(dāng)中含有丈夫引用
Husband h;
}
// -------------------------------------------------------------------
public class OOTest04{
public static void main(String[] args){
// 創(chuàng)建一個丈夫?qū)ο?
Husband huangXiaoMing = new Husband();
huangXiaoMing.name = "黃曉明";
// 創(chuàng)建一個妻子對象
Wife baby = new Wife();
baby.name = "baby";
// 結(jié)婚【能通過丈夫找到妻子，通過妻子也可以找到丈夫】
huangXiaoMing.w = baby;
baby.h = huangXiaoMing;
// 得到以上“黃曉明”的妻子的名字
System.out.println(huangXiaoMing.name + "的妻子名字叫：" + baby.name);
System.out.println(huangXiaoMing.name + "的妻子名字叫：" + huangXiaoMing.w.name);
}
}
知識點(diǎn)
// 顧客類
public class Customer
{
// id
int id;
}
// ------------------------------------------------------------------------
// 測試程序
public class OOTest05
{
public static void main(String[] args){
Customer c = new Customer();
System.out.println(c.id); // 0
c = null;
// 以下程序編譯可以通過，因?yàn)榉险Z法
// 運(yùn)行出現(xiàn)空指針異常
// 空應(yīng)用訪問“實(shí)例”相關(guān)的數(shù)據(jù)一定會出現(xiàn)空指針異常
// java.lang.NullPointerException
System.out.println(c.id);
}
}
// “實(shí)例”相關(guān)的數(shù)據(jù)表示：這個數(shù)據(jù)訪問的時候必須有對象的參與，這種數(shù)據(jù)就是實(shí)例相關(guān)的數(shù)據(jù)
/*
Java語言是面向?qū)ο?
要想創(chuàng)建對象必須先定義類
定義類的語法：
[修飾符列表] class 類名{
屬性：
方法：
}
屬性通常采用變量來表示，既然是變量那么變量肯定有數(shù)據(jù)類型?！緮?shù)據(jù)類型包括：基本數(shù)據(jù)類型 + 引用數(shù)據(jù)類型】
屬性對應(yīng)的是狀態(tài)信息。
觀察現(xiàn)實(shí)世界當(dāng)中超市中的商品，發(fā)現(xiàn)這所有的商品都有一些共同的特征，例如，每一個商品都有編號，每一個商品都有單價，所以定義以下的類，來代表所有的商品
*/
public class Product{
// 編號 【通常是一個數(shù)字，而且該數(shù)字通常是整數(shù)型的】
// productNo 是基本數(shù)據(jù)類型
// 實(shí)例變量
int productNo;
// 單價 【通常是一個數(shù)字，但是數(shù)字可能帶有小數(shù)，所以采用浮點(diǎn)型數(shù)據(jù)double表示】
// price 是基本數(shù)據(jù)類型
// 實(shí)例變量
double price;
// ----------------------------------------------------------------------
/*
每一個類中都可以編寫主方法，但是一般情況下
一個系統(tǒng)只有一個入口，所以主方法一般寫一個
*/
public class ProductTest{ // 商品測試類
// 程序入口
public static void main(String[] args){
// 創(chuàng)建對象，商品對象
// iphone7 局部變量
// iphone7 應(yīng)用
// iphone7 變量中保存內(nèi)存地址的指向堆內(nèi)存當(dāng)中的商品對象
Product iphone7 = new Product();
// 訪問實(shí)例變量的語法：引用.變量
// 讀?。阂?變量名
System.out.println("商品的編號：" + iphone7.productNo);
System.out.println("商品的單價：" + iphone7.price);
// 修改：引用.變量名 = 值;
iphone7.productNo = 111;
iphone7.price = 68000;
System.out.println("商品的編號：" + iphone7.productNo);
System.out.println("商品的單價：" + iphone7.price);
}
}
// 人類
public class Ren{
// 身份證號
String id;
// 名字
String name;
// 性別
boolean sex;
// 年齡
int age;
}
// -------------------------------------------------------------------------
/*
別墅類
* 面積
* 主人
*/
public class BieShu{
// 面積
double mianJi;
// 主人【人類】
// 變量/應(yīng)引用
// 變量怎么聲明：數(shù)據(jù)類型 變量名;
// 關(guān)聯(lián)關(guān)系： A has a B 關(guān)系【A對象中含有B對象的引用】
// BieShu對象含有Ren對象的引用
Ren zhuRen;
}
// ----------------------------------------------------------------------
public class Test{
public static void main(String[] args){
// 思路：先創(chuàng)造人物對象，再創(chuàng)造別墅對象，讓別墅有主人
Ren zhangsan = new Ren(); // 初始化
// 不采用系統(tǒng)默認(rèn)值
// 手動賦值
zhangsan.id = "45682110";
zhangsan.name = "張三";
zhangsan.sex = true;
zhangsan.age = 100;
// 創(chuàng)建別墅對象
BieShu fangzi = new BieShu();
fangzi.mianJi = 150.0;
fangzi.zhuRen = zhangsan;
// 想知道房子主人的名字是什么？
System.out.println(fangzi.zhuRen.name);
// 房子換主人
// 創(chuàng)建一個新的主人對象
Ren lisi = new Ren();
lisi.name = "李四";
// 換主人
fangzi.zhuRen = lisi;
System.out.println(fangzi.zhuRen.name);
}
}
// 學(xué)生類
class Student{
String name;
int no;
// 筆記本
Notebook book;
}
// ----------------------------------------------------------------------
// 筆記本類
class Notebook{
// 品牌
String brand;
// 型號
String model;
// 顏色
String color;
}
// ----------------------------------------------------------------------
/*
需求：
定義一個計算機(jī)類【電腦/筆記本】，計算機(jī)類有那些屬性
* 品牌 * 型號 * 顏色
定義一個學(xué)生類，學(xué)生類有那些屬性：
* 姓名 * 學(xué)號 * 學(xué)生有一臺筆記本電腦
請編寫程序來表示以上的類，然后分別將類創(chuàng)建為對象，對象數(shù)量不限，然后讓其中的一個學(xué)生去使用其中的一臺筆記本電腦
然后編譯并運(yùn)行，并且將整個執(zhí)行過程采用圖形的方式描述出來。
*/
// 測試類
public class OOTest06{
public static void main(String[] args){
// 創(chuàng)建筆記本對象
Notebook BiJiBen = new Notebook();
// 手動賦值
BiJiBen.brand = "華為";
BiJiBen.model = "KX100";
BiJiBen.color = "黑色";
// 創(chuàng)建學(xué)生對象
Student s = new Student();
// 手動賦值
s.no = 111;
s.name = "jack";
s.book = BiJiBen;
System.out.println(s.name);
System.out.println(s.no);
System.out.println(s.book.brand);
// 讓這個學(xué)生和筆記本對象產(chǎn)生關(guān)系【通過學(xué)生能找到他的筆記本】
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.brand);
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.model);
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.color);
// 修改品牌
s.book.brand = "蘋果";
System.out.println("學(xué)號：" + s.no + " 名字叫 " + s.name + " 的電腦品牌是：" + s.book.brand);
}
}
總結(jié)
本篇文章就到這里了，希望能給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！
相關(guān)文章
-
Druid連接池的自定義過濾功能實(shí)現(xiàn)方法
在數(shù)據(jù)密集型應(yīng)用中,監(jiān)控和分析數(shù)據(jù)庫操作對于確保性能和穩(wěn)定性至關(guān)重要,本文將探討如何實(shí)現(xiàn)一個自定義的Druid過濾器來捕獲數(shù)據(jù)庫請求并進(jìn)行日志記錄,以輔助開發(fā)和維護(hù)工作,需要的朋友可以參考下2023-11-11 -
Java編程使用UDP建立群聊系統(tǒng)代碼實(shí)例
這篇文章主要介紹了Java編程使用UDP建立群聊系統(tǒng)代碼實(shí)例，具有一定借鑒價值,需要的朋友可以參考下。2018-01-01 - 一般來講SpringBoot項目是不需要指定版本，而SSM項目是需要指定版本，SpringBoot的核心依賴就是spring-boot-starter-parent和spring-boot-starter-web兩個依賴，關(guān)于這兩個依賴的相關(guān)介紹具體今天小編給大家介紹下2022-06-06
-
Java Code Cache滿導(dǎo)致應(yīng)用性能降低問題解決
這篇文章主要介紹了Java Code Cache滿導(dǎo)致應(yīng)用性能降低問題解決,本篇文章通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下2021-08-08 - 這篇文章主要介紹了SpringBoot?JPA常用注解的使用方法,spring?boot作為當(dāng)前主流的技術(shù),來看看常用的注解怎么用,如果有錯誤的地方還請指正,需要的朋友可以參考下2023-03-03
-
java?freemarker實(shí)現(xiàn)動態(tài)生成excel文件
這篇文章主要為大家詳細(xì)介紹了java如何通過freemarker實(shí)現(xiàn)動態(tài)生成excel文件,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下2023-12-12 -
在spring?boot3中使用native?image的最新方法
這篇文章主要介紹了在spring?boot3中使用native?image?,今天我們用具體的例子來給大家演示一下如何正確的將spring boot3的應(yīng)用編譯成為native image，需要的朋友可以參考下2023-01-01 - 這篇文章主要為大家介紹了Java之冒泡排序與選擇排序，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2021-12-12
- 這篇文章主要為大家詳細(xì)介紹了maven搭建java ee項目圖文教程，感興趣的小伙伴們可以參考一下2016-04-04
- 這篇文章主要介紹了Java異常處理方法匯總，我們在軟件開發(fā)的過程中，任何語言的開發(fā)過程中都離不開異常處理。下面下小編加來給大家分享各種異常處理，希望對大家有所幫助,需要的朋友可以參考一下2021-12-12