資訊專欄INFORMATION COLUMN
摘要：面向對象之封裝繼承多態封裝將類中的信息進行隱藏在類的內部，不允許外部程序信息直接訪問，而是只能通過該類的提供的方法來實現對隱藏信息的提供和訪問。與之對應，包含內部類的類被稱為外部類。
面向對象之封裝、繼承、多態 封裝
將類中的信息進行隱藏在類的內部，不允許外部程序信息直接訪問，而是只能通過該類的提供的方法來實現對隱藏信息的提供和訪問。
好處
只能隱藏規定的方法和數據 隱藏類的實現細節，方便修改和實現
封裝的實現步驟
1. 用private等修飾符修飾屬性 2. 創建屬性的getter/setter方法 3. 在getter/setter方法中加入屬性的控制語句java中的訪問修飾符
java中的訪問修飾符一個有四個，我們主要學習private、protected、public三個。java中的this關鍵字
this關鍵字代表當前對象
this.屬性 操作當前對象的屬性 this.方法 操作當前對象的方法
封裝對象的屬性的時候會經常使用this關鍵字
package com.test.cat; // 定義包
public class Cat {
int a;
int b;
public void send() {
System.out.print("send");
}
public int getA() {
this.send(); // 調用方法
return a;
}
public void setA(int a) {
this.a = a; // 調用屬性
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
public Cat() {
System.out.println("Cat 實例化了");
}
}
java中的內部類
內部類（ Inner Class ）就是定義在另外一個類里面的類。與之對應，包含內部類的類被稱為外部類。
內部類的主要作用
1. 內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類 2. 內部類的方法可以直接訪問外部類的所有數據，包括私有的數據 3. 內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便
內部類的分類
成員內部類 靜態內部類 方法內部類 匿名內部類
先舉個例子
//外部類HelloWorld
public class HelloWorld {
// 內部類Inner，類Inner在類HelloWorld的內部
public class Inner {
// 內部類的方法
public void show() {
System.out.println("welcome to imooc!");
}
}
public static void main(String[] args) {
// 創建外部類對象
HelloWorld hello = new HelloWorld();
// 創建內部類對象
Inner i = hello.new Inner();
// 調用內部類對象的方法
i.show();
}
}
java中的成員內部類(普通內部類)
package innerClass;
// 外部類
public class Outer {
private int out; // 外部類成員
private int b; // 外部的b
public int getOut() {
return out;
}
public void setOut(int out) {
this.out = out;
}
// 外部類構造函數
public Outer(int _out) {
this.out = _out;
System.out.println("外部類實例化中.....");
// 外部類則無法訪問內部類的數據
}
// 內部類
public class Inner{
private int in; // 內部類成員
private int b; // 內部的b
// 內部類構造函數
public Inner(int _in) {
this.in = _in;
System.out.println("內部類實例化中....");
System.out.println(out); // 內部類可以訪問外部類中的任何數據
System.out.println(this.b); // 如果遇上重名，那么默認是使用內部的變量，如果想要使用外部的變量，可以使用this
}
}
public static void main(String [] args) {
Outer o = new Outer(100); // 創建一個外部對象
System.out.println(o.getOut());
Inner i = o.new Inner(200); // 創建一個內部對象
}
}
注意事項
1. Inner 類定義在 Outer 類的內部，相當于 Outer 類的一個成員變量的位置，Inner 類可以使用任意訪問控制符，如 public 、 protected 、 private 等 2. Inner 類中定義的 test() 方法可以直接訪問 Outer 類中的數據，而不受訪問控制符的影響 3. 定義了成員內部類后，必須使用外部類對象來創建內部類對象，而不能直接去 new 一個內部類對象，即：內部類 對象名 = 外部類對象.new 內部類( ); 4. 編譯上面的程序后，會發現產生了兩個 .class 文件 其中，第二個是外部類的 .class 文件，第一個是內部類的 .class 文件，即成員內部類的 .class 文件總是這樣：外部類名$內部類名.class
外部類是不能直接使用內部類的成員和方法滴
如果外部類和內部類具有相同的成員變量或方法，內部類默認訪問自己的成員變量或方法，如果要訪問外部類的成員變量，可以使用 this 關鍵字。
Java 中的靜態內部類靜態內部類是 static 修飾的內部類
特點
1. 靜態內部類不能直接訪問外部類的非靜態成員，但可以通過 new 外部類().成員 的方式訪問 2. 如果外部類的靜態成員與內部類的成員名稱相同，可通過“類名.靜態成員”訪問外部類的靜態成員；如果外部類的靜態成員與內部類的成員名稱不相同，則可通過“成員名”直接調用外部類的靜態成員 3. 創建靜態內部類的對象時，不需要外部類的對象，可以直接創建 內部類 對象名= new 內部類();
package static_inner_class;
public class Outer {
private int a; // 外部普通成員變量
static int b = 10; //外部靜態變量
public Outer(int _a) {
this.a = _a;
System.out.println("外部類實例化中....");
}
// 內部類
public static class Inner{
private int b;
public Inner(int _b) {
this.b = _b;
System.out.println("內部類實例化中....");
}
public void test() {
System.out.println("訪問外部類中的b：" + Outer.b);
// 訪問外部靜態變量，建議使用class.staticName ，即使這是處理外部類和內部類存在同名變量的情況下
System.out.println("訪問內部類中的b：" + b); // 訪問內部變量可以直接訪問
}
}
public static void main(String [] args) {
Outer o = new Outer(10);
Inner i = new Inner(20); // 創建內部類可以直接使用該方法，不用先實例化外部類
i.test();
}
}
Java 中的方法內部類
方法內部類就是內部類定義在外部類的方法中，方法內部類只在該方法的內部可見，即只在該方法內可以使用。
//外部類
public class HelloWorld {
private String name = "愛慕課";
// 外部類中的show方法
public void show() {
// 定義方法內部類
class MInner {
int score = 83;
public int getScore() {
return score + 10;
}
}
// 創建方法內部類的對象
MInner mi=new MInner();
// 調用內部類的方法
int newScore=mi.getScore();
System.out.println("姓名：" + name + "
加分后的成績：" + newScore);
}
// 測試方法內部類
public static void main(String[] args) {
// 創建外部類的對象
HelloWorld mo=new HelloWorld();
// 調用外部類的方法
mo.show();
}
}
繼承
繼承就是類與類之間的一種 is a的關系
java中繼承是單繼承的，也就是只能由一個父類
好處
1. 實現代碼的復用 2. 子類擁有父類的所有屬性和方法 3. 但是private修飾的屬性和方法卻無法訪問到
語法規則
例子
// Animal.java
package inhert_demo1;
public class Animal {
public int age;
public String name;
public void eat() {
System.out.println("動物可以吃東西");
}
}
// Cat.java
package inhert_demo1;
public class Cat extends Animal{
// 【方法的重寫】
public void eat() {
System.out.println("貓咪可以吃東西");
}
}
// test.java
package inhert_demo1;
public class test {
public static void main(String [] args) {
Cat c = new Cat();
c.eat();
}
}
方法的重寫
如果子類對繼承父類的方法不滿意，是可以重寫父類的方法的，當調用的時候，優先調用子類的方法
// 規定 1. 返回值相同 2. 參數類型及個數相同 3. 方法名相同繼承的出發順序
1. 先初始化父類，然后再初始化子類 2. 先執行初始化對象中的屬性，然后再執行構造函數中的初始化
// 執行順序為
package inhert_demo1;
public class Animal {
public int age = 10; //【1】 屬性初始化
public String name;
public Animal() {
age = 20; // 【2】構造函數中的初始化
}
public void eat() {
System.out.println("動物可以吃東西");
}
}
final "最終的"
final可以修飾類、屬性、方法、變量
final修飾的類，則該類不能被繼承 final修飾的方法，則方法不允許被覆蓋（也就是方法的重寫） final修飾的屬性： 屬性初始化必須是在屬性初始化或者構造方法中初始化，只能人選其一 final修飾的變量，這個變量就成為了常量，只能賦值一次super
super關鍵字代指父類 （在對象內部使用、可以代表父類對象）
// 子類 cat
package inhert_demo1;
public class Cat extends Animal{
public int age = 20;
public void eat() {
System.out.println("貓咪可以吃東西");
}
public void meyhod () {
// super代表父類
System.out.println(super.age); // 使用父類的屬性
super.eat(); // 子類中調用父類的方法
}
}
注意
1. 如果子類中的構造方法沒有顯示的調用父類的構造方法，那么系統將默認調用父類的無參構造方法 也就是會隱世的調用`super()` 2. 如果父類沒有無參構造方法，而是有有參的構造方法，那么子類中就必須顯示的調用父類的構造方法。Object類
Object類是所有類的父類，如果一個類沒有明確的使用extends來指定繼承一個類，那么這個類默認繼承Object（Object類中的方法適合子類）
方法一、toString()
Object中的類方法toString()返回的是一個對象的哈希Code碼（對象的地址引用）
// 我們則是想使用該方法來返回屬性的值，因此我們可以重寫該方法
// cat類中
public String toString() {
return "Cat [age=" + age + "]";
}
//使用
package inhert_demo1;
public class test {
public static void main(String [] args) {
Cat c = new Cat();
System.out.println(c.toString());
}
}
方法二、equals()
比較對象的引用是否指向同一塊內存地址。
Dog d1 = new Dog(); Dog d2 = new Dog(); d1.d2是兩個地址，是不相同的 // 如果我們想要用equals來比較兩個對象的值是否相同，這就需要我們重寫該方法
// cat中重寫
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())// getClass 獲取到的是類對象
return false;
Cat other = (Cat) obj;
if (age != other.age)
return false;
return true;
}
Cat c = new Cat();
System.out.println(c.toString());
Cat c1 = new Cat();
if(c1.equals(c)) {
System.out.println("兩個對象的屬性相同");
}
補充 getClass 獲取到的是類對象
多態多態指的是對象的多種形態
1. 引用多態
父類的引用可以指向子類的對象
父類的引用可以指向本類的對象
public static void main(String [] args) {
Animal d1 = new Animal();
Animal d2 = new Dog();
Dog d3 = new Animal(); // 報錯了，因為是子類的引用指向了父類的對象
}
2. 方法多態
創建本類對象時，調用的時本類的方法
創建子類對象時，調用的方法時子類重寫的方法或者時父類繼承過來的方法
Animal d1 = new Animal();
Animal d2 = new Dog();
d1.eat(); // 調用父類的eat方法
d2.eat(); // 調用子類重寫的eat方法
多態中的引用類型轉換
1. 向上類型轉換（隱式/自動類型轉換） 小類型 => 大類型 2. 向下類型轉換（強制類型轉換） 大類型 => 小類型 3. instanceof可以解決引用對象的類型，來避免轉換類型的安全性問題
package polymorphic;
public class test {
public static void main(String [] args) {
Dog dog = new Dog();
Animal animal = dog; // 小類型 => 大類型
// Dog dog2 = animal; // 報錯了，因為大類型 => 小類型 存在風險
Dog dog2 = (Dog)animal; // 強制類型轉換，就不報錯了
// Cat cat =(Cat) animal; // 編譯時Cat類型，運行時時Dog類型
if(animal instanceof Dog) {
} else {
}
}
}
抽象類
使用abstract修飾的類成為抽象類
1. 某一個父類只知道子類應該含有怎樣的方法，但是無法確定這個子類的方法如何實現 2. 從多個具有相同特征的類中抽象出一個抽象類，以這個抽線類作為子類的模板，從而避免了子類設計的隨意性
使用規則
abstract定義抽象方法，只有聲明、不需要實現 抽象類中可以有普通方法，也可以有抽象方法 抽象類不能直接創建，我們可以定義引用變量
public abstract class telphone {
// 定義抽象方法
public abstract void call();
public abstract void message();
// 抽象方法沒有方法體，因此以分號結束
}
實例
// Telphone.java
package abstrated;
public abstract class Telphone {
// 定義抽象方法
public abstract void call();
public abstract void message();
// 抽象方法沒有方法體，因此以分號結束
}
// Cellphone.java
package abstrated;
public class Celltelphone extends Telphone {
public void call() {
System.out.println("通過鍵盤打電話");
}
public void message() {
System.out.println("通過鍵盤發短信");
}
}
// smartphone.java
package abstrated;
public class Smarttelphone extends Telphone{
public void call() {
System.out.println("通過語音打電話");
}
public void message() {
System.out.println("通過語音發短信");
}
}
// initial.java
package abstrated;
public class initial {
public static void main(String[] args) {
// TODO Auto-generated method stub
Telphone t1 = new Celltelphone(); // 使用父類的引用創建子類對象
t1.call();
t1.message();
Telphone t2 = new Smarttelphone(); // 使用父類的引用創建子類對象
t2.call();
t2.message();
}
}
接口
接口可以理解為時一種特殊的類，由全局常量和公共的抽象方法來組成
它是類的一種具體實現，而接口定義了某一批類所需要遵守的【規范】，接口并不關心這些類的內部實現，也不關心這些類的實現細節，只是規定了這些類的必須實現的某些方法。
接口定義
interface A{//定義一個接口
public static final String MSG = "hello";//全局常量
public abstract void print();//抽象方法
}
// X.java
package interfaceDemo1;
interface A{
public static final String MSG = "hello"; // 全局常量
public abstract void print(); // 抽象方法
}
interface B{
public static final int a = 10;
public abstract void get();
}
public class X implements A,B{
// X實現了兩個接口
public void print() {
System.out.println("接口A的抽象方法print()");
}
public void get() {
System.out.println("接口B的抽象方法get()");
}
}
// test.java
package interfaceDemo1;
public class test {
public static void main(String[] args) {
// TODO Auto-generated method stub
X x = new X(); // 實例化子類
A a = new X();
B b = new X();
x.print();
x.get();
a.print();
b.get();
}
}
未完待續
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/76700.html
摘要：方法即為收集器，它接收高階函數和的后端掘金年的第一天，我坐在獨墅湖邊，寫下這篇文章。正因如此，所以最全系列教程后端掘金是從版本開始引入的一個新的，可以替代標準的。 設計模式之單例模式 - 掘金前言 作為一個好學習的程序開發者，應該會去學習優秀的開源框架，當然學習的過程中不免會去閱讀源碼，這也是一個優秀程序員的必備素養，在學習的過程中很多人會遇到的障礙，那就是設計模式。很多優秀的框架會運...
摘要：很多情況下，通常一個人類，即創建了一個具體的對象。對象就是數據，對象本身不包含方法。類是相似對象的描述，稱為類的定義，是該類對象的藍圖或原型。在中，對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中，對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了，離年底老媽老爸...
摘要：很多情況下，通常一個人類，即創建了一個具體的對象。對象就是數據，對象本身不包含方法。類是相似對象的描述，稱為類的定義，是該類對象的藍圖或原型。在中，對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中，對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了，離年底老媽老爸...
摘要：很多情況下，通常一個人類，即創建了一個具體的對象。對象就是數據，對象本身不包含方法。類是相似對象的描述，稱為類的定義，是該類對象的藍圖或原型。在中，對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中，對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了，離年底老媽老爸...
閱讀 1661·2021-08-13 15:03
閱讀 2091·2019-08-30 15:54
閱讀 3551·2019-08-26 10:30
閱讀 1027·2019-08-26 10:22
閱讀 2753·2019-08-23 14:42
閱讀 1814·2019-08-22 11:16
閱讀 1046·2019-08-21 18:33
閱讀 3170·2019-08-21 17:28
