建站
咨詢
售后
建站咨詢
新聞中心
這篇文章主要介紹了java有哪三大特性，具有一定借鑒價值，需要的朋友可以參考下。希望大家閱讀完這篇文章后大有收獲。下面讓小編帶著大家一起了解一下。
臺江ssl適用于網(wǎng)站、小程序/APP、API接口等需要進行數(shù)據(jù)傳輸應(yīng)用場景，ssl證書未來市場廣闊！成為創(chuàng)新互聯(lián)的ssl證書銷售渠道，可以享受市場價格4-6折優(yōu)惠！如果有意向歡迎電話聯(lián)系或者加微信：13518219792（備注：SSL證書合作）期待與您的合作！
java三大特性：1、封裝，是指隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外提供公共訪問方式；2、繼承，從已有的類中派生出新的類，新的類能吸收已有類的數(shù)據(jù)屬性和行為，并能擴展新的能力；3、多態(tài)，一個方法可以有多種實現(xiàn)版本，即“一種定義， 多種實現(xiàn)”。
Java 三大特性，算是Java獨特的表現(xiàn)，提到Java 的三大特性， 我們都會想到封裝， 繼承和多態(tài) 這是我們Java 最重要的特性。
封裝(Encapsulation) ：
封裝：是指隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外提供公共訪問方式。
好處：
將變化隔離。
便于使用。
提高重用性。
提高安全性。
封裝原則：
將不需要對外提供的內(nèi)容都隱藏起來。
把屬性都隱藏，提供公共方法對其訪問 。
private關(guān)鍵字：
是一個權(quán)限修飾符。
用于修飾成員(成員變量和成員函數(shù))
被私有化的成員只在本類中有效。
常用之一：
將成員變量私有化，對外提供對應(yīng)的set ， get方法對其進行訪問。提高對數(shù)據(jù)訪問的安全性。
舉個栗子：
我們常說的失血模型
public class Demo {
private String name;
private String sex ;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}構(gòu)造代碼塊和構(gòu)造方法（Construct）：
構(gòu)造方法：
用于給對象進行初始化，是給與之對應(yīng)的對象進行初始化，它具有針對性，函數(shù)中的一種。
特點：
- 該函數(shù)的名稱和所在類的名稱相同。
- 不需要定義返回值類型。
- 該函數(shù)沒有具體的返回值。
- 構(gòu)造函數(shù)并不是由我們手動調(diào)用的（手動調(diào)用指的是如b1.baby();），而是在創(chuàng)建對應(yīng)的對象時，JVM就會主動調(diào)用到對應(yīng)的構(gòu)造函數(shù)。
- 如果一個類沒有顯式的寫上一個構(gòu)造方法時，那么Java編譯器會為該類添加一個無參的構(gòu)造函數(shù)的。
- 如果一個類已經(jīng)顯式的寫上一個構(gòu)造方法時，那么Java編譯器則不會再為該類添加一個無參的構(gòu)造方法。
- 構(gòu)造函數(shù)是可以在一個類中以函數(shù)重載的形式存在多個的。
- 構(gòu)造方法有無參構(gòu)造方法和有參構(gòu)造方法。無參構(gòu)造方法JVM 默認創(chuàng)建一個，如果手動創(chuàng)建了有參構(gòu)造方法，那么系統(tǒng)會默認識別有參構(gòu)造方法。
構(gòu)造函數(shù)的定義格式：
修飾符 函數(shù)名(形式參數(shù)){
函數(shù)體;
}
修飾符 函數(shù)名(){
函數(shù)體;}構(gòu)造方法與普通方法的區(qū)別：
（1）返回值類型的區(qū)別：
①構(gòu)造函數(shù)是沒有返回值類型的，如果加上void或者別的返回值類型，就變成一個普通的函數(shù)，就需要我們手動去調(diào)用。
②普通函數(shù)是有返回值類型的，即使函數(shù)沒有返回值，返回值類型也要寫上void。
（2）函數(shù)名的區(qū)別：
①構(gòu)造函數(shù)的函數(shù)名必須要與類名一致。
②普通函數(shù)的函數(shù)名只要符合標識符的命名規(guī)則即可。
（3）調(diào)用方式的區(qū)別：
①構(gòu)造函數(shù)是在創(chuàng)建對象的時候由JVM調(diào)用的。
②普通函數(shù)是由我們使用對象調(diào)用的，一個對象可以調(diào)用多次普通的函數(shù)。
（4）作用上的區(qū)別：
①構(gòu)造函數(shù)的作用用于初始化一個對象。每創(chuàng)建一個對象就會有一個初始值。
②普通函數(shù)是用于描述一類事物的公共行為的。
注意事項：
（1）Java編譯器添加的無參的構(gòu)造方法的權(quán)限修飾符與類的權(quán)限修飾符是一致的。
（2）構(gòu)造函數(shù)是創(chuàng)建對象的時候調(diào)用的，所以就可以把屬性值傳到構(gòu)造函數(shù)中，在構(gòu)造函數(shù)中設(shè)置參數(shù)接收屬性值。
（3）JVM和Java編譯器是不同的，Java編譯器編譯生成的.class文件是給JVM看的，所以經(jīng)過編譯后的class類打開后會是亂碼，我們可以通過反編譯來查看。
構(gòu)造代碼塊：
1.構(gòu)造代碼塊的作用與構(gòu)造函數(shù)的作用的對比：
（1）構(gòu)造代碼塊的作用：給所有對象進行統(tǒng)一的初始化，對象一建立就運行并且優(yōu)先于構(gòu)造函數(shù)，比如所有的嬰兒出生都會哭。
（2）構(gòu)造函數(shù)的作用：給對應(yīng)的對象（new ）進行初始化。
構(gòu)造代碼塊的格式：
{
構(gòu)造代碼塊;
}
注意：構(gòu)造代碼塊的大括號必須位于成員的位置上。代碼塊的類別：
（1）構(gòu)造代碼塊：在工作中經(jīng)常會用到。
（2）局部代碼塊：大括號位于方法之內(nèi)，基本上寫不寫沒什么區(qū)別，現(xiàn)實開發(fā)中也很少會用到。它的作用是縮短局部變量的生命周期，節(jié)省一點點內(nèi)存。
（3）靜態(tài)代碼塊：使用static修飾的代碼塊。
注意的事項：
（1）Java編譯器在編譯一個Java源文件的時候，會把成員變量的聲明語句提前至一個類的最前端。
（2）成員變量的初始化工作其實都是在構(gòu)造函數(shù)中執(zhí)行的。
（3）一旦經(jīng)過Java編譯器編譯后，那么構(gòu)造代碼塊的代碼就會被移動到構(gòu)造函數(shù)中執(zhí)行，構(gòu)造代碼塊的代碼是在構(gòu)造函數(shù)之前執(zhí)行的，構(gòu)造函數(shù)中的代碼是最后執(zhí)行的。
（4）成員變量的顯示初始化與構(gòu)造代碼塊的代碼是按照當前代碼的順序執(zhí)行的。
繼承(inheritance)：
繼承是面向?qū)ο笞铒@著的一個特性。 繼承是從已有的類中派生出新的類， 新的類能吸收已有類的數(shù)據(jù)屬性和行為，并能擴展新的能力。
在JAVA中， 被繼承的類叫父類(parent class)或超類(superclass)， 繼承父類的類叫子類(subclass)或派生類(derivedclass)。 因此， 子類是父類的一個專門用途的版本， 它繼承了父類中定義的所有實例變量和方法， 并且增加了獨特的元素 。
繼承的結(jié)構(gòu)：
繼承的使用 ：
關(guān)鍵字：extends。
使用繼承
– 編寫父類
– 編寫子類， 繼承父類
class Animal {
//公共的屬性和方法
}
class Chicken extends Animal{
//子類特有的屬性和方法
}
class Duck extends Animal {
}基本語法：
class Chicken extends Animal{ }上述代碼表示Chicken類繼承Animal類，使用extends關(guān)鍵詞將Animal類（父類/超類）和Chicken類（子類）連接接起來；
在繼承關(guān)系下，Chicken類將擁有Animal類所有的非私有的方法和屬性，Chicken類還可以擁有自己獨有的方法和屬性；
聲明Animal類，實例化Chicken類時， Chicken類會自動向上轉(zhuǎn)型為Animal類；
舉個栗子：
//創(chuàng)建動物類
public class Animal {
private String type;
private String skin;
private int legCount;
public void eat(){
System.out.println("動物正在吃東西");
}
public void breath(){
System.out.println("動物正在呼吸");
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getSkin() {
return skin;
}
public void setSkin(String skin) {
this.skin = skin;
}
public int getLegCount() {
return legCount;
}
public void setLegCount(int legCount) {
this.legCount = legCount;
}
}
//雞類
public class Chicken extends Animal {
public void eat(){
System.out.println(“雞正在吃東西”);
}
public void run(){
System.out.println(“雞在跑");
}
}
//鴨類
public class Duck extends Animal {
public void eat(){
System.out.println(“鴨正在吃東西”);
}
public void run(){
System.out.println(“鴨在跑");
}
}
//測試類
public class Test {
public static void main(String[] args){
Chicken chicken=new Chicken ();
chicken.eat();
chicken.setType(“雞”);
chicken.setSkin(“金色");
chicken.setLegCount(2);
System.out.println("動物品種是： "+chicken.getType()+"， 膚色是： "+chicken.getSkin()+"， 腿數(shù)"+t.getLegCount());
chicken.run();
Duck duck =new Duck ();
duck.eat();
duck.fight();
}
}繼承執(zhí)行的順序：
java中， new一個類的對象， 類里面的靜態(tài)代碼塊、 非靜態(tài)代碼塊、無參構(gòu)造方法、 有參構(gòu)造方法、 類的一般方法等部分， 它們的執(zhí)行順序相對比較簡單， 例如：
public class FatherTest{
private String name;
public FatherTest(){
System.out.println(“--父類的無參數(shù)構(gòu)造方法--”);
}
public FatherTest(String name){
System.out.println(“--父類的有參數(shù)構(gòu)造方法--”+this.name);
}
static{
System.out.println(“--父類的靜態(tài)代碼塊--”);
}
{
System.out.println(“--父類的非靜態(tài)代碼塊--”);
}
public void speak(){
System.out.println(“--父類的方法--”);
}
}
public static void main(String[] args){
System.out.println(“--父類主程序--”);
FatherTest father = new FatherTest(“父親的名字”);
father.speak();
}
執(zhí)行結(jié)果為：
--父類的靜態(tài)代碼塊--
--父類主程序--
--父類的非靜態(tài)代碼塊--
--父類的有參構(gòu)造函數(shù)--父親的名字
--父類的方法--
執(zhí)行順序總結(jié)：
靜態(tài)代碼塊—>主程序—>非靜態(tài)代碼塊—>構(gòu)造函數(shù)—>一般方法加入子類繼承后的執(zhí)行順序， 例如 ：
public class SonTest extends FatherTest{
private String name;
static{
System.out.println("--子類的靜態(tài)代碼塊--"); }
{
System.out.println("--子類的非靜態(tài)代碼塊--");
}
public SonTest(){
System.out.println("--子類的無參構(gòu)造方法--");
}
public SonTest(String name){
System.out.println("--子類的有參構(gòu)造方法--"+name);
}
@Override
public void speak() { System.out.println("--子類重寫了父類的方法--"); }
}
public static void main(String[] args) {
System.out.println("--子類主程序--");
FatherTest father=new FatherTest("父親的名字");
father.speak();
SonTest son=new SonTest("兒子的名字");
son.speak();
}
執(zhí)行結(jié)果為：
--父類的靜態(tài)代碼塊--
--子類的靜態(tài)代碼塊--
--子類主程序--
--父類的非靜態(tài)代碼塊--
--父類的有參構(gòu)造函數(shù)--父親的名字
--父類的方法--
--父類的非靜態(tài)代碼塊--
--父類的無參構(gòu)造函數(shù)--
--子類的非靜態(tài)代碼塊--
--子類的有參構(gòu)造方法--兒子的名字
--子類重寫了父類的方法--方法的重寫：
方法重寫是在繼承關(guān)系下， 子類擁有與父類方法名、 參數(shù)(個數(shù)、順序、 類型)、 返回值類型完全相同， 訪問修飾符只能擴大或相等， 不可縮小， 但實現(xiàn)過程與父類不同的方法。 方法重寫也是多態(tài)的一種變現(xiàn)形式。
重寫必須滿足以下幾個條件：
在子類中可以根據(jù)需要對從基類中繼承來的方法進行重寫；
重寫的方法和被重寫的方法必須具有相同方法名稱、 參數(shù)列表和返回類型；
重寫方法不能使用比被重寫的方法更嚴格的訪問權(quán)限 ；
舉個栗子：
//雞類
class Chicken extends Animal {
public void eat(){
System.out.println(“雞正在吃東西”);//對父類Animal中的eat方法進
行重寫
}
public void run(){
System.out.println(“雞在跑");//可以添加新的方法
}
}Super關(guān)鍵字：
super關(guān)鍵字是一個特殊的變量， 它提供了對父類的方法。 可以用super主動調(diào)用父類的構(gòu)造方法、 訪問父類中的成員。
super調(diào)用父類的構(gòu)造方法：
public class Duck extends Animal {
public Duck(String name){
super(name);//主動調(diào)用父類的構(gòu)造方法
}
}super訪問父類的成員：
在子類方法中使用super訪問父類中隱藏的成員， 訪問形式是：
super.變量；
super.方法名(參數(shù));
public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println(super.name);//使用super調(diào)用父類的屬性
eat();
super.eat();//使用super調(diào)用父類的eat()方法
}
public static void main(String[] args) {
new Duck().quack();//創(chuàng)建Duck類對象并調(diào)用quack方法
}
}final 關(guān)鍵字：
“final”關(guān)鍵字用來修飾類、 方法和變量， 其含義“不可改變的、 最終的”。
修飾類 聲明為final的類不能派生子類，即此類不能被繼承；
public final class Person{ }
修飾變量 表示它為一個常量，變量一旦初始化，將不能改變；
final int COUNT = 5;
修飾方法 表示向編譯器表明子類不能重寫此方法；
public final void eat(){ }多態(tài)(polymorphism)
在面向?qū)ο笳Z言中， 多態(tài)性是指一個方法可以有多種實現(xiàn)版本，即“一種定義， 多種實現(xiàn)”。 利用多態(tài)可以設(shè)計和實現(xiàn)可擴展的系統(tǒng)， 只要新類也在繼承層次中。 新的類對程序的通用部分只需進行很少的修改， 或不做修改。 類的多態(tài)性表現(xiàn)為方法的多態(tài)性，方法的多態(tài)性主要有方法的重載和方法的覆蓋。
重載：
方法重載(overload)是指在同一個類中的多個方法可以同名但參數(shù)列表必須不同。 重載表現(xiàn)為同一個類中方法的多態(tài)性。
class Chicken {
public void eat(){
System.out.println(“雞正在吃東西”);
}
public void eat(String food){
System.out.println(“雞在吃"+food);//重載eat方法
}
}方法重寫(override)是指子類沖定義了父類中同名的方法。 重寫表現(xiàn)為父子與子類之間方法的多態(tài)性。
//雞類
class Chicken extends Animal {
public void eat(){
System.out.println(“雞正在吃東西”);//對父類Animal中的eat方法進
行重寫
}
}對象類型轉(zhuǎn)換：
基本類型的數(shù)據(jù)可以轉(zhuǎn)換類型， 當轉(zhuǎn)換類型較高時可以自動轉(zhuǎn)換， 當轉(zhuǎn)換類型較低時需要強制轉(zhuǎn)換。 對象類型也允許轉(zhuǎn)換， 這個轉(zhuǎn)換只限于java類層次結(jié)構(gòu)圖上的一根枝干上， 即父類和子類之間。 枝干上離Object較近的為上， 相反較遠的為下， 由此對象的類型轉(zhuǎn)換分為“向上轉(zhuǎn)型”和“向下轉(zhuǎn)型”兩種。
public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a1 = new Animal();//實例化過程
Animal a2 = new Duck();//向上轉(zhuǎn)型
a1.eat();
a2.eat();
//a2.quack();//去除注釋會怎樣？
}
}向下轉(zhuǎn)型：只能針對指向子類對象的基類對象引用進行 。
public class Duck extends Animal {
@Override
public void eat() {
System.out.println();
}
public void quack(){
System.out.println("嘎嘎嘎");
}
public static void main(String[] args) {
Animal a = new Duck();//向上轉(zhuǎn)型
Duck b = (Duck) a;//向下轉(zhuǎn)型
a.eat();
b.eat();
b.quack();
}
}Instanceof 關(guān)鍵字 ：
instanceof關(guān)鍵字是用來判斷其左邊對象是否為其右邊的實例， 返回boolean類型的數(shù)據(jù) .
boolean result = Object instanceof class
同時， 也可以用來判斷繼承中的子類的實例是否為父類的實現(xiàn)。
.....
public static void main(String[] args) {
Animal a = new Duck();//向上轉(zhuǎn)型
if(a instanceof Duck){
((Duck) a).quack();
}
}
.....感謝你能夠認真閱讀完這篇文章，希望小編分享java有哪三大特性內(nèi)容對大家有幫助，同時也希望大家多多支持創(chuàng)新互聯(lián)，關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，遇到問題就找創(chuàng)新互聯(lián)，詳細的解決方法等著你來學(xué)習(xí)!
名稱欄目：java有哪三大特性
轉(zhuǎn)載源于：http://fisionsoft.com.cn/article/pjoegp.html
