面向對象的優點是:不造重復的輪子,也就是說不干重復的活。
創新互聯公司專注于鳳翔企業網站建設,成都響應式網站建設公司,成都做商城網站。鳳翔網站建設公司,為鳳翔等地區提供建站服務。全流程按需搭建網站,專業設計,全程項目跟蹤,創新互聯公司專業和態度為您提供的服務
java中把具有相同共性的一類事物抽象為一個類,而對象是這個類的其中一個實體。
例如:人是一個類(有共同的屬性,有頭發、眼睛、鼻子.....),張三、李四、王五是三個實體對象,而每個對象的屬性又是不同的,例如張三是黑頭發,李四是黃頭發、王五是紅頭發。
這樣復用性比較好。
一.面向對象:
1.何謂對象:在面向對象程序設計中,我們將問題空間中的元素以及他們在方案空間中的的表示物稱作對象(object)
Alan Kay總結了smalltalk中對象的5大基本特征:
所有的東西都是對象。
程序是一大堆對象的集合,他們通過消息傳遞,各個對象之間知道要做些什么。
每個對象都分配有自己的存儲空間,可容納其他對象。
每個對象都有一個類型。
同一類的所有對象能接收相同的消息。
-----而所有的編程語言的最終目的是提供一種抽象方法----
2.對象的接口:我們向對象發出請求是通過它的接口定義的,對象的類型決定了它的接口形式。
3.OOP中唯一關心的:就是接口是什么,就像汽車的發動機一樣,我們不必要知道它的結構是什么,只要它能工作就行了。所有的程序是由一定的屬性(數據)和行為(方法)組成的,不同的對象訪問通過函數調用來完成,對象間的所有交流都是通過方法調用,通過對封裝數據對象,很大程度上提高復用率。
4.對象的3個主要特征:
behavior—說明這個對象能做什么。
State—當對象施加方法時對象的反映。
Identity---與其他相似行為對象的區分標志,每一個對象有唯一的indentity, 而這3者是相互影響的。
5.面向對象中最重要的思想就是類,類是模板是藍圖,從類中構造一個對象,即創建了一個類的實例。(類好比一個建材市場,其中有許多子類--各種各樣的裝飾材料,而我們裝修自己的房子就要選擇我們需要的材料,(為了建立我們自己的程序,我們必須選 擇我們需要的類)這個比喻可以很形象的解釋類是什么。
6.類之間的關系:
依賴關系:use-a A類中的一個方法操作了另一個類中的對象。
聚合關系:has-a A類中的對象包含B類的對象。
繼承關系:is-a A繼承了B類,此時A類不僅有了B類的方法,還加入了自己的方法。以便我們創建我們自己需要的對象。
Java中定義的每一個類都必須繼承另一個類,使用關鍵字extends,如果一個類在定義中不現實使用關鍵字extends,這個類就會隱式繼承Object類。Object類又叫根超類,或基類。,我們從根超類繼承來的叫子類。Java中每個類都是根超類的子類。
8.接口(interface)規定了可對特定的對象發出哪些請求。
9.繼承=重新使用接口:創建出一個數據類型后,當需要新建立一個數據類型去實現相同的功能,是很沒有意義的一件事,此時對其克隆后,再根據情況改進實現自己的目的就是繼承。
10.封裝:就是把數據和行為結合在一起在一個包中,并對對象使用者隱藏數據的實現過程。Java用3個關鍵字來設置邊界,從而進行對數據的隱藏。Public(共有)的定義任何人都可使用.private(私有)意味著除你自己,類型創建者及那個類型的內部函數成員可以訪問外其他任何人使用都會產生錯誤。Friendly(友好)
意味在包(package)中是可以訪問的。(以上過程也可叫方案隱藏)
11.引用(Handle)操控對象:
當創建一個引用時必須要對其進行初始化
例: String s=”happy”(未建立連接)
String s=new string(“happy”)與一個新的對象連接使用new 。此句建立了一個引用,并且連接引用并初始化對象 賦值字符串“happy”.
12.對象的創建及存在時間:數據存放的地點
1:寄存器-速度快,數量少,在cpu內部,我們對寄存器沒有控制權。
2:堆棧:駐留長規內存中,堆棧指針下移建立新的內存,上移釋放內存。
3:堆:常用內存池,保存對象,有極大的靈活性,java的數據就存放在此,但是要以時間及效率為代價。Java的對象建立是在程序運行時才決定。而c++是在設計時建立對象。
對象的生存時間(lifetime)java提出的垃圾收集器可以很好的發現無須再用的對象,使用GC(grabage collector)垃圾收集器。清除對象,釋放內存。
為此我們就要付出一定的運行期的開銷。
13.在此我們就會有這樣一個印象,一個程序只是一系列對象的集合,他們的方法將其他對象作為自己的變量使用.
14.主要類型: java的主要類型有:boolean,char,byte,short,int,long,float,double,void.這些主類型的大小都不隨機器的結構變化而變化,提供了java很好的可移植性.
15.字段方法:字段又叫數據成員,成員函數又叫方法,java的全部工作就是定義類,制作累得對象及發送消息.
16.一個程序只是一系列對象的集合,他們的方法將其他的對象作為自己的變量使用,而且將消息發給那些對象.
17.名字的可見性:為了使名字不重復,作者可以定義自己的庫,一般用自己域名的倒寫形式 如: COM.:Leeak.utility.foidles
18.static關鍵字:即使沒有創建對象,也需要一愕能調用的方法,此時可以使用static
19.java.lang默認自動的導入每個java程序中
20.OOP中對象使對屬性和方法的封裝,對象具有信息的隱蔽的性質,對細節的隱藏,對象只需要知道去這樣做,而不知道如何做的細節,類的方法應謹慎控制對java數據的訪問,可以用get讀取方法,用set修改方法.
21:pakage:Java API中每個類和接口屬于一個特定的包,包實際上市對類和接口進行組織的目錄結構,提供了一種軟件復用機制.
22.創建可復用的類得步驟:1.定義一個public類
2.選擇一個包名,并把pakage語句加到可復用的類的源碼中.
3.編譯這個類.
4.把可復用的類導入其他程序中即可.
23.java中提出在類定義的括號外的僅有2個語句,pakage和import.
24.軟件的復用性,軟件的復用性就是利用紫的已有的,定義良好的的經過仔細測試的文檔清晰的可移植的易于獲得的軟件構件開發新的軟件.
以上就是java面向對象的一些基本術語的概述,其中的有些部分可以擴展的更深,看過think in java的 朋友就會有此種感覺.此文章向對初學者闡述了面向對象的基本概念.對已是java程序員的朋友可以對他們的基本知識做以回顧.
代碼如下:
class?Person?{
protected?String?name;
protected?int?age;
protected?String?address;
public?Person(String?name,?int?age,?String?address)?{
this.name?=?name;
this.age?=?age;
this.address?=?address;
}
public?void?sayHi()?{
System.out.println(this.name?+?","?+?this.age?+?","?+?this.address);
}
}
class?Student?extends?Person?{
private?String?stuId;
public?Student(String?stuId,?String?name,?int?age,?String?address)?{
super(name,?age,?address);
this.stuId?=?stuId;
}
public?void?sayHi()?{
System.out.println(this.stuId?+?","?+?this.name?+?","?+?this.age?+?","?+?this.address);
}
}
class?Teacher?extends?Person?{
private?float?salary;
public?Teacher(String?name,?int?age,?String?address,?float?salary)?{
super(name,?age,?address);
this.salary?=?salary;
}
public?void?sayHi()?{
System.out.println(this.name?+?","?+?this.age?+?","?+?this.address?+?","?+?this.salary);
}
}
class?Doctor?extends?Person?{
private?String?level;
public?Doctor(String?name,?int?age,?String?address,?String?level)?{
super(name,?age,?address);
this.level?=?level;
}
public?void?sayHi()?{
System.out.println(this.name?+?","?+?this.age?+?","?+?this.address?+?","?+?this.level);
}
}
public?class?Test?{
public?static?void?main(String[]?args)?{
Student[]?students?=?new?Student[2];
students[0]?=?new?Student("201803010001",?"小明",?20,?"廣東深圳");
students[1]?=?new?Student("201803010002",?"小王",?22,?"上海");
for(Student?student?:?students)?{
student.sayHi();
}
Teacher[]?teachers?=?new?Teacher[2];
teachers[0]?=?new?Teacher("張三",?30,?"廣東廣州",?5000);
teachers[1]?=?new?Teacher("李四",?35,?"廣東廣州",?6000);
for(Teacher?teacher?:?teachers)?{
teacher.sayHi();
}
Doctor[]?doctors?=?new?Doctor[2];
doctors[0]?=?new?Doctor("張三",?30,?"北京",?"主治醫師");
doctors[1]?=?new?Doctor("李四",?35,?"上海",?"主任醫師");
for(Doctor?doctor?:?doctors)?{
doctor.sayHi();
}
}
}
第一次寫插入排序的,寫得有點亂,但是加了注釋后應該是比較容易理解的:
public class InsertSort {
public static void main(String[] args){
int[] nums={15, 5, 56, 8, 2};
sort(nums,0);
}
public static int[] sort(int[] nums,int start){
//定義新的數組,用來存儲每一次排序后的結果
int[] result=new int[nums.length];
//如果開始的下標大于0,則先把之前已排序好的元素拷貝進來
if(start0){
for(int i=0;istart;i++){
result[i]=nums[i];
}
}
int tag=start;//定義用來存儲該次最小元素的下標
int min=nums;
//從當前下標開始,查找數組中的最小元素,并更新下標
for(int i=start;inums.length;i++){
for(int j=i+1;jnums.length;j++){
if(minnums[j]){
min=nums[j];
tag=j;
}
}
}
//將該次排序后最小的元素存儲在開始下標處的位置
result=min;
for(int i=start;itag;i++){
result[i+1]=nums[i];
}
//將從當前開始下標處到最后的所有元素原樣保存到新數組
for(int i=tag+1;inums.length;i++){
result[i]=nums[i];
}
//-----------遍歷每一次排序后的數組----------
String split="";
for(int i=0;iresult.length;i++){
System.out.print(split+result[i]);
split=",";
}
System.out.println();
//---------遍歷結束------------
//將這一次開始的下標自加,作為下一個排序要開始的下標
start++;
//如果當前開始的下標已經達到最大值,則返回結果數組,否則將該次排序后的數組遞歸排序
if(start==nums.length-1){
return result;
}else{
return sort(result,start);
}
}
}
順便說一下,一樓的,你寫的不是插入法排序的啊,而且你也沒有輸出每一次的排序結果。
優點
1、抽象:抽象就是忽略一個主題中與當前目標無關的那些方面,以便更充分地注意與當前目標有關的方面。抽象并不打算了解全部問題,而只是選擇其中的一部分,暫時不用部分細節。抽象包括兩個方面,一是過程抽象,二是數據抽象。
2、繼承:繼承是一種聯結類的層次模型,并且允許和鼓勵類的重用,它提供了一種明確表述共性的方法。對象的一個新類可以從現有的類中派生,這個過程稱為類繼承。新類繼承了原始類的特性,新類稱為原始類的派生類(子類),而原始類稱為新類的基類(父類)。派生類可以從它的基類那里繼承方法和實例變量,并且類可以修改或增加新的方法使之更適合特殊的需要。
3、封裝:封裝是把過程和數據包圍起來,對數據的訪問只能通過已定義的界面。面向對象計算始于這個基本概念,即現實世界可以被描繪成一系列完全自治、封裝的對象,這些對象通過一個受保護的接口訪問其他對象。
4、多態:多態性是指允許不同類的對象對同一消息作出響應。多態性包括參數化多態性和包含多態性。多態性語言具有靈活、抽象、行為共享、代碼共享的優勢,很好的解決了應用程序函數同名問題。
缺點
1、過度封裝:使用OOP時,會把一些復雜的問題分拆抽象成較簡單的獨立對象,通過對象的互相調用去實現方案。但是,由于對象包含自己封裝的數據,一個問題的數據集會被分散在不同的內存區域。互相調用時很可能會出現數據的cache miss的情況。
2、多態:在C++的一般的多態實現中,會使用到虛函數表。虛函數表是通過加入一次間接層來實現動態派送。但在調用的時候需要讀取虛函數表,增加cache miss的可能性。基本上要支持動態派送,無論用虛函數表、函數指針都會形成這個問題,但如果類的數目極多,把函數指針如果和數據放在一起有時候可放緩問題。
java 開發是近幾年流行的比較熱門的編程語言,但是很多從事java語言的技術員,及java編程愛好者,都只是了解java 優勢,很少人知道java的劣勢,今天就聽西安java專業培訓老師給大家講述,java 的優點和風險。
一、好處并發編程之所以讓人迷惑是因為有不止一種問題的解決需要使用并發,也有不止一種方法去實現并發,而且他們之間也沒有清晰的映射。
使用并發編程來解決的問題可以劃分為兩類,即“speed”和“designmanageability”。
1、速度優勢:
多處理器:多處理器上面并發變成無疑會讓程序運行很快。
單處理器:如果是單處理器的機器,那么并發編程可能相對于順序編程沒有什么變化。但是,如果其中某一個任務也許會發生阻塞的話,那么即使是單處理器,使用并發編程也會帶來很大的好處,這樣,某個任務阻塞的時候,其他任務也可以繼續運行了。
反應靈敏的用戶界面:在單處理器上面性能提升典型的列子就是“事件驅動的編程”,比如創建一個有反應的用戶界面,其中有個按鈕,如果我們不使用并發編程,那么我們需要在我們編寫的每一個代碼片段中都要有對用戶輸入的檢測,如果我們使用并發編程,我們只需要重新開啟一個線程去用戶的輸入即可。
并發的實現:實現并發的直接的方式是在操作系統級別,使用進程,進程一種自包含的程序,使用自己的地址空間,操作系統會讓進程之間相互隔離,所以進程編程相對容易一些,不需要考慮共享資源的同步等問題。但是在Java中的并發編程,由于線程之間共享相同的memory或者IO等資源,所以Java多線程編程中需要考慮共享資源的同步問題。
進程和Java線程之間的選擇:進程的確是一種實現并發的方式,butunfortunately there are generally quantity and overhead limitations toprocesses that prevent their applicability across the concurrency spectrum.
2、設計上的優勢:
一般來說,線程使得你能夠創建更加松耦合的設計。
單處理器:盡管單處理器上面的并發編程在同一時刻處理器仍然只能做一件事情,但是帶來一個組織上面的重要優勢:就是你的設計(design)會極大地簡化。比如。
二、風險1、安全性問題
主要是多個線程共享數據時可能會產生于期望不相符的結果
2、活躍性問題(liveness)
當某個操作無法繼續進行下去時,就會發生活躍性問題。比如死鎖、饑餓、活鎖等問題。
3 性能問題
a.線程過多時會使得CPU頻繁切換,花在調度上時間太多。
b.多線程環境必須使用同步機制,導致很多編譯器想做的優化被抑制。
任何東西都有自己的優點和劣勢,所以我們在學習的時候就要有針對的,理解性的學習,才能學的更深入,更透徹,更多專業知識,歡迎咨詢:西安java專業培訓老師,免費為您詳解。
請聯系網站客服,了解詳細的優惠課程信息~
優質、便捷、省心
網頁題目:java面對對象代碼優化,java代碼優化的方法
網址分享:http://vcdvsql.cn/article26/heopcg.html
成都網站建設公司_創新互聯,為您提供網站維護、自適應網站、全網營銷推廣、網站策劃、營銷型網站建設、企業建站
聲明:本網站發布的內容(圖片、視頻和文字)以用戶投稿、用戶轉載內容為主,如果涉及侵權請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網站立場,如需處理請聯系客服。電話:028-86922220;郵箱:631063699@qq.com。內容未經允許不得轉載,或轉載時需注明來源: 創新互聯