2. 程式人生 > >面向物件的基礎篇_03

面向物件的基礎篇_03

阿新 • • 發佈：2019-01-01

基礎篇_03的主要內容

  • 1丶物件比較
  • 2丶static 關鍵字的作用
  • 3、程式碼塊
  • 4丶內部類

一丶物件比較

  • 理解：就是判斷兩個物件的內容是否相等。
  • 核心：就是判斷兩個物件中的屬性是否完全相等。
比較的第一種情況
class Person {
    private String name ;
    private int age ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public
 
 String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
}
public class CompareDemo01 {
    public static void main(String args[]){
        Person per1 = new Person("張三",30) ;
        Person per2 = new Person("張三",30) ;
        if(per1.getName().equals(per2.getName()) 
            && per1.getAge() == per2.getAge()){
            System.out
 
.println("是同一個人！") ;
        } else {
            System.out.println("不是同一個人！") ;
        }
    }
}

如果按照以上的做法，由主方法進行比較，實際上就相當於增加了一個第三方，由第三方幫你進行比較，肯定不合適，所以最好的做法是在 Person 類中本身就已經具備了一個這樣的功能。

class Person {
    private String name ;
    private int age ;
    public Person(String name,int age){
        this
 
.name = name ;
        this.age = age ;
    }
    public boolean compare(Person person){
        if(this == person){  //  地址相等了
        return true ;
    }
    if(this.name.equals(person.name) && this.age==person.age){
        return true ;
    } else {
        return false ;
    }
}
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
}
public class CompareDemo02 {
    public static void main(String args[]){
    Person per1 = new Person("張三",30) ;
    Person per2 = new Person("張三",30) ;
    if(per1.compare(per2)){
        System.out.println("是同一個人！") ;
    } else {
        System.out.println("不是同一個人！") ;
    }
}

物件比較的操作程式碼，一定要熟練編寫。

二丶static 關鍵字的作用

  • static關鍵字在類中可以宣告屬性或方法。
    • 宣告的屬性將稱為全域性屬性。``【全域性屬性】
    • 宣告的方法將成為類方法。``【類方法】
1、宣告屬性
  • 公共屬性就可以使用 static 進行操作。
    • |- 假使每個物件佔用每個物件自己的屬性的話，對於每個物件公有的屬性而言，肯定會造成記憶體空間的浪費
    • `|- 公共屬性，所有的物件可以同時擁有，但是一般而言這些公共屬性雖然可以使用普通的物件呼叫，可一般不這樣操作，而是通過所有物件的最大級 —— 類，完成呼叫。
舉例：

| - 比如我們的學校都在石家莊的話，城市country石家莊是全域性屬性
| - 我們之間不同的屬性就有名字name和學號id

我們的程式如下：

class Person {
    private String name ;
    private int age ;
    String country = "石家莊" ;
    public Person(String name,int age){
            this.name = name ;
            this.age = age ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年齡：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo01{
    public static void main(String args[]){
    Person per1 = new Person("張三",20) ;
    Person per2 = new Person("李四",21) ;
    Person per3 = new Person("王五",22) ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    }
}

| - 這裡沒有使用static定義全域性變數。
| - 如果需要改變我們的地址為北京，上千人的資料很難一下更改。
| - 按照記憶體的分配來講，每一個物件都單獨佔著各自的 country屬性。

我們把程式中的country加上static作為全域性變數

class Person {
    private String name ;
    private int age ;
    static String country = "石家莊" ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年齡：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo02{
    public static void main(String args[]){
        Person per1 = new Person("張三",20) ;
        Person per2 = new Person("李四",21) ;
        Person per3 = new Person("王五",22) ;
        System.out.println(per1.getInfo()) ;
        System.out.println(per2.getInfo()) ;
        System.out.println(per3.getInfo()) ;
        System.out.println("---------------------") ;
        per1.country = "北京" ;
        System.out.println(per1.getInfo()) ;
        System.out.println(per2.getInfo()) ;
        System.out.println(per3.getInfo()) ;
    }
}

|-修改了一個物件中的 country屬性之後，所有物件的 country屬性都發生了變化
|-由於全域性屬性擁有可以通過類名稱直接訪問的特點，所以這種屬性又稱為類屬性。
|-類名稱直接訪問Person.country = “北京” ;

2、宣告方法
  • 全域性屬性可以通過類名稱直接訪問
  • static 定義一個“類方法”，也可以通過類名稱直接訪問。
  • Person.setCountry("北京") ;

類方法和類屬性的作用效果是一樣的

class Person {
    private String name ;
    private int age ;
    private static String country = "石家莊" ;
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public static void setCountry(String c){
        country = c ;
    }
    public String getInfo(){
        return "姓名：" + this.name + "，年齡：" + this.age + "，城市：" + country ;
    }
}
public class StaticDemo03 {
    public static void main(String args[]){
    Person per1 = new Person("張三",20) ;
    Person per2 = new Person("李四",21) ;
    Person per3 = new Person("王五",22) ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    System.out.println("---------------------") ;
    Person.setCountry("北京") ;
    System.out.println(per1.getInfo()) ;
    System.out.println(per2.getInfo()) ;
    System.out.println(per3.getInfo()) ;
    }
}
3、static的使用注意

  • static 本身宣告方法或宣告屬性，但是在方法的訪問上本身也存在著問題。
    1、 使用 static 宣告的方法，不能訪問非 static 的操作（屬性或方法）
    2、 非 static 宣告的方法，可以訪問 static 宣告的屬性或方法

  • 當一個例項化物件產生之後，可以呼叫所有的非 static 的操作，那麼肯定也就可以呼叫所有的 static 操作。
    1、 如果說現在一個類中的屬性或方法都是非 static 型別的，肯定是要有例項化物件才可以呼叫。
    2、 static 宣告的屬性或方法可以通過類名稱訪問，可以在沒有例項化物件的情況下呼叫。

  • 一個方法由主方法呼叫的格式：

public static 返回值型別 方法名稱(引數列表){
    [return 返回值 ;]
}
4、static的應用
  • static 的屬性是所有物件所共同擁有的，那麼就可以利用此特點完成一個自動命名的功能。
class Book {
    private String name ;
    private static int count = 0 ;
    public Book(){
        this.name = "無名字 - " + ++count ;
    }
    public Book(String name){
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
}
public class StaticDemo06 {
    public static void main(String args[]){
        System.out.println(new Book("JAVA基礎").getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book().getName()) ;
        System.out.println(new Book("Oracle").getName()) ;
    }
}

5、主方法的組成

  • 主方法：是所有呼叫的起點，定義如下：

    • public static void main(String args[])

  • 實際上每一個修飾符或引數都是有意義的：

    • public：表示外部都可以訪問
    • static：方法可以由類直接呼叫
    • void：程式的起點，一旦開始了就沒回頭路
    • main：系統規定好的預設的方法名稱
    • String args[]：是一個字串陣列，用於接收引數
    • 在主方法中，可以在一個程式執行時輸入多個引數，每個引數之間使y用空格分隔，所有的引數都靠 String args[]進行接收。
public class Hello {
    public static void main(String args[]){
        for(int x=0;x<args.length;x++){
            System.out.println(args[x]) ;
        }
    }
}

但是，如果現在要想輸入的引數中本身就包含了空格呢？通過雙引號完成。
| - “hello world” “hello mldn”

  • 主方法屬於一切操作的起點 。所 以主方法將作為一個程式的客戶端存在，那麼客戶端的操作程式碼越少越好。
  • 在進行程式類的結構劃分上，就一個原則：一個類只完成一個類的功能。

三丶程式碼塊

  • 在程式中使用“{}”括起來的一段程式碼就稱為程式碼塊，根據程式碼塊出現的位置或宣告的關鍵字的不同，分為四種：
    • 普通程式碼塊：在一個方法中定義的程式碼塊，稱為普通程式碼塊
    • 構造塊：在一個類中定義的程式碼塊
    • 靜態塊：使用 static 關鍵字宣告的程式碼塊
    • 同步程式碼塊：
      // 從實際的開發來看，程式碼塊的使用並不多。
1、普通程式碼塊
public class CodeTest {
    public static void main(String args[]) {
        {  // 普通程式碼塊
            int x = 10 ;
            System.out.println("x = " + x) ;
        }
        int x = 100 ;
        System.out.println("x = " + x) ;
    }
};

輸出的結果是：

x=10;
x=100;
2、構造塊

構造塊是定義在一個類中的程式碼塊。

class Demo {
    {
        System.out.println("構造塊!!!") ;
    }
    public Demo(){
        System.out.println("構造方法!!!!") ;
    }
}
public class CodeTest01 {
    public static void main(String args[]) {
        new Demo() ;
    }
}

構造塊會優先於構造方法執行，而且每當一個新的例項化物件產生時，都會呼叫構造塊，會呼叫多次。

//構造塊！！！
//構造方法！！！！
3、靜態塊
  • 使用 static 關鍵字定義的程式碼塊，而且靜態塊是定義在類中的。
    |- 在主類中定義的靜態塊將優先於主方法執行。
    |- 靜態塊優先於構造塊執行，而且只執行一次。
class Demo {
    static{
        System.out.println("靜態塊！！") ;
    }
    {
        System.out.println("構造塊！！！") ;
    }
    public Demo(){
        System.out.println("構造方法！！！！") ;
    }
}
public class CodeTest02 {
    static{
        System.out.println("主方法中的靜態塊。") ;
    }
    public static void main(String args[]) {
            System.out.println("--------------") ;
                new Demo() ;
    }
}

輸出的結果是：

//主方法中的靜態塊。
//--------------
//靜態塊！！
//構造塊！！！
//構造方法！！！！

四丶內部類

1、學習內部類，所需要認識的語法

○內部類就是指一個類【外部類】的內部還包含了另外的一個操作類【內部類】。
○被包含的類稱為內部類，包含的類稱為外部類。
|- 內部類可以方便的訪問外部類中的私有成員。

class Outer {  // 定義外部類
    private String info = "Hello" ;
        class Inner {  // 定 定 義 內 部類 類
            public void print(){
                System.out.println(info) ; // 輸 輸出 出 info  屬性
            }
    }
    public void fun(){
    new Inner().print() ;
    }
}
public class InnerDemo{
    public static void main(String args[]){
        new Outer().fun() ;
    }
}

|- 外部呼叫內部類，一定要先產生外部類的例項化物件，再產生內部類的例項化物件。

class Outer {  // 定義外部類
    private String info = "Hello" ;
        class Inner {  // 定義內部類
            public void print(){
            System.out.println(info) ;  // 輸出 info 屬性
            }
        }
}
public class InnerDemo01 {
    public static void main(String args[]){
        Outer.Inner in = null ; // 宣告內部類的物件
        in = new Outer().new Inner() ;
        in.print() ;
    }
}
2 、使用static宣告內部類
  • 使用 static 聲明瞭一個內部類：
    • 類將成為外部類。
    • 只能訪問外部類中的 static 成員。
class Outer {  // 定義外部類
    private static String info = "Hello" ;
        static class Inner {  // 定義內部類，是 static 變為外部類
            public void print(){
            System.out.println(info) ;  // 輸出 info 屬性
        }
    }
}
public class InnerDemo02 {
    public static void main(String args[]){
        Outer.Inner in = new Outer.Inner() ;
        in.print() ;
    }
}

上述情況會有輸出"Hello"

//當我們把方法不用static宣告之後
private String info = "Hello" ;
//會報出下列錯誤
//無法從靜態上下文中引用非靜態 變數 info
3、在方法中 宣告 內 部 類
  • 一個內部類可以在任意的位置上宣告
    |- 在方法中宣告內部類的操作出現的是最多的。
    |- 在方法中定義的內部類，依然可以訪問外部類中的屬性，但是對於方法的引數，這個內部類是無法直接訪問的，如果要訪問，則在引數前面必須使用* final *關鍵字進行宣告。
class Outer {
    private String info = "hello" ;
    public void fun(final int x){
        final int y = 100 ;
        class Inner {  // 方法中宣告內部類
            public void print(){
                System.out.println(info) ;
                System.out.println("x = " + x) ;
                System.out.println("y = " + y) ;
            }
        }
        new Inner().print() ;
    }
}
public class InnerDemo03 {
    public static void main(String args[]){
        new Outer().fun(30) ;
    }
}

特此說明：
歡迎大家提出合理的意見。

最後再聊幾句：
1、 this 關鍵字
|- this 關鍵字可以呼叫本類中的屬性
|- 可以呼叫本類中的方法，但是如果要呼叫構造方法的話，則一定要放在構造方法的首行，且至少保留一個構造方法中沒有使用 this 呼叫。
|- this 表示當前物件：當前操作類中方法的物件就是當前物件。
2、 引用傳遞的問題，可以使用引用表示出一些關係。
3、 連結串列基本上融合了類的設計、引用傳遞、構造方法、封裝型、this 關鍵字。
4、 物件比較的時候實際上是將兩個物件的每個屬性進行比較，是一個類的內部自己所提供的功能。
5、 static 關鍵字
|- static 關鍵字宣告的屬性稱為全域性屬性，為所有物件所共同擁有，可以直接通過類名稱進行訪問。
|- static 宣告的方法可以直接由類名稱呼叫，但是 static 的方法不能呼叫非 static 的操作，而非 static 的方法可以呼叫所有的 static 操作。
|- 主方法的組成。
6、 程式碼塊（瞭解）。
7、 內部類的結構及各個操作必須掌握。
|- 使用 static 宣告的內部類就是外部類。
|- 內部類可以在方法中宣告，但是此時，要想訪問方法中的引數，引數前必須加上final關鍵字。

相關推薦

面向物件的基礎篇_03

基礎篇_03的主要內容 1丶物件比較 2丶static 關鍵字的作用 3、程式碼塊 4丶內部類 一丶物件比較 理解：就是判斷兩個物件的內容是否相等。 核心：就是判斷兩個物件中的屬性是否完全相等。 比較的第一種情況 c

【PHP篇】面向物件基礎

1、宣告：class 類名{                          //成員屬性（變數） 修飾符 $變數名=初值；       &nb

Python之路【第五篇】：面向物件及相關 面向物件基礎

其他相關 一、isinstance(obj, cls)  檢查是否obj是否是類 cls 的物件 1 2

黑馬程式設計師----Java基礎之面向物件(最終篇)

------- <a href="http://www.itheima.com" target="blank">android培訓</a>、<a href="http://www.itheima.com" target="blank">java培訓</a&g

Java-面向物件（基礎篇）--面向物件基礎

面向物件（基礎篇） 一． 面向物件的基本概念 面向物件是針對使用者的要求進行分析，將分析的結果設計成圖紙，然後將一切的準備工作全部處理完之後再分塊製作，最後將各個部分組裝在一起。 對於面向物件的程式設計用封裝性、繼承性、多型性3個主要特性。 1.

java學習02（面向物件基礎）

1.物件可以簡單認識成一個記憶體塊，一個區域。 2.記憶體分為：棧記憶體，堆記憶體，方法區(堆的一部分，包括類的資訊，靜態方法，靜態變數，字串常量)，這點對理解很多東西都很有用 3.包先簡單理解成一個資料夾(域名倒著寫) 4.面向物件： 繼承： 類只能單繼承，接口才可以多繼承 子類建構函式呼叫前預

week6：面向物件基礎

一、基本概念 1.1、python  函式式+面向物件 函數語言程式設計可以做所有的事，是否合適？ 函式：def+函式名（引數): 二、面向物件 2.1、如何建立類 class 類名：         pass  

10 面向物件基礎（三）

10.1私有屬性和私有方法 class Dog(object): def __init__(self): self.__age = 10 # 在屬性名前面加倆下劃線，將屬性私有化，這個屬性稱為私有屬性（一般不允許物件來訪問修改這個屬性） # def

9 面向物件基礎（二）

9.1應用:存放傢俱 """ 存放傢俱：往家裡面存放傢俱（床）， 要考慮到家裡的剩餘的可用面積 """ class Home(object): def __init__(self, area): self.area = area # self.are

8 面向物件基礎（一）

8.1面向物件程式設計介紹 面向物件(object-oriented ;簡稱: OO) 面向物件程式設計(Object Oriented Programming-OOP) 面向過程 8.2 類和物件 8.3 定義類 8.4 建立物件 class

記 2018/11/08 面向物件基礎學習 1#

一、類與物件概述 　　1、為了把日常生活中實物用學習語言描述出來   　　2、如何描述現實事物 　　　　屬性：就是該事物的描述資訊（名詞） 　　　　行為：就是該事物能夠做什麼（動詞） 　　3、Java中最基本單位是類 　　　　成員變數：事物的屬性 　　　　成員方法：事物的行為 　　

Python開發【第七篇】：面向物件初級篇

面向物件初級篇 概述 面向過程：根據業務邏輯從上到下寫壘程式碼 函式式：將某功能程式碼封裝到函式中，日後便無需重複編寫，僅呼叫函式即可 面向物件：對函式進行分類和封裝，讓開發“更快更好更強...” 面向過程程式設計最易被初學者接受，其往往用一長段程式碼來實現指定功能，開發過程中最常見的

Java——面向物件基礎

　　1. 面向物件可以幫助我們從巨集觀上把握、從整體上分析整個系統。 但是具體到實現部分的微觀操作(就是一個個方法)，仍然需要面向過程的思路去處理。 　　2. 類可以看成一類物件的模板，物件可以看成該類的一個具體例項。 　　3. 對於一個類來說，一般有三種常見的成員：屬性field、方法method、構造

Python飛機大戰-面向物件基礎

140行小遊戲，更換完圖片可直接執行 import pygame,copy,random,time from pygame.locals import * class Base(): def init(self,windows,x,y): self.x = x self.y = y se

Python面向物件基礎2：設定物件屬性

用類儲存資料 類實際上就是一個數據結構，對於python而言，它是一個類似於字典的結構。當根據類建立了物件之後，這個物件就有了一個數據結構，包含一些賦值了的屬性。在這一點上，它和其它語言的struct的作用是類似的：儲存資料並提供資料檢索功能。 例如，下面是史上最簡單的類： class Person

C#面向物件 | 面向物件基礎之綜合練習

面向物件程式設計練習 使用類來描述遊戲中的角色 欄位：角色名字、簡介、暱稱、攻擊力、防禦力和速度。 方法：每個角色有三個不同的攻擊技能。 //角色一：埃洛克的基本資訊. AiLuoKe.cs. class AiLuoKe {

js面向物件基礎01

面向物件：不瞭解原理的情況下，會使用功能。 物件：黑盒子，不瞭解內部的結構，知道表面的各種操作。對外提供和一些操作。 JS中的面向物件 面向物件程式設計(OOP)的特點           抽象：抓住核心問題。（抽：把最主要的特徵、跟問題相關的特徵抽出來）     

C#學習筆記-面向物件基礎-多型

絕對路徑與相對路徑 相對路徑：相對於程式的路徑，儘量使用這個路徑。 File與Filestream #List 泛型集合 ##宣告方式 List listname = new List(); 名稱空間是 System.Collections ##陣列與集合之間的

C#學習筆記-面向物件基礎-繼承

名稱空間 namespace 解決類的重名問題。可以看做的是類的“資料夾”。 如果名稱空間缺失，可以選中類，用快捷鍵 alt+shift+F10，可以匯入名稱空間。 在一個專案中引用另一個專案的類 新增引用 引用名稱空間 值型別與引用型別

C# 學習筆記-面向物件基礎語法

面向物件的概念 面向過程：面向的是完成這件事的過程，強調的是完成這件事的動作； 把大象塞進冰箱裡： 1、開啟冰箱； 2、把大象塞進去； 3、關閉冰箱門。 如果我們用面向過程的思想來解決這件事兒，當執行這件事的人不同的時候，我們需要為每個不同的人量身定做解決事情的方法。