Java基礎（二）面向對象（上）

時間  2019-12-04
標籤 java 基礎 面向對象 欄目 Java 简体版
原文   原文鏈接

面向對象基礎知識

面向對象是相對面向過程而言的 面向對象和麪向過程都是一種思想 面向過程強調的是功能行爲 面向對象將功能封裝進對象，強調具有了功能的對象 面向對象是基於面向過程的java

面向對象的特徵：數組

  • 封裝
  • 繼承
  • 多態

java中用類Class來描述事物： 屬性：對應類中的成員變量 行爲：對應類中的成員函數安全

成員變量 成員變量定義在類中，在整個類中均可以被訪問 成員變量隨着對象的創建而創建，存在於對象所在的堆內存中 成員變量有默認初始化值ide

局部變量 局部變量之定義在局部範圍內，如函數內 局部變量存在棧內存中 做用的範圍結束，變量空間會自動釋放 局部變量沒有默認初始化值函數

匿名對象 匿名對象是對象的簡化形式 匿名對象有兩種使用狀況： 當對象方法僅進行一次調用時 匿名對象能夠做爲實際參數進行傳遞this

heap-stack

java -x 輸出java的非標準選項 java -Xss<size> xxx 設置stack大小 如：java -Xss521kspa

java -Xmx 設置堆最大值 java -Xms 設置堆初始值code

java中對象和數組都位於堆內存中，局部變量函數參數等都位於棧內存中對象

封裝

封裝是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式blog

封裝原則： 將不須要對外提供的內容都隱藏起來 把屬性都隱藏起來，提供公共方法對其訪問

代碼例子：

package study_java.ex01;

public class ClassDemo1 {
    public static void main(String[] args){
        Man man = new Man();
        // 不能直接經過man訪問到money，只能經過getMoney方法
        System.out.println(man.getMoney());
        man.addMoney(100);
        System.out.println(man.getMoney());
        // 對於public的變量咱們能夠直接經過man訪問
        System.out.println(man.age);
    }

}

class Man{
    private int money = 100;
    public int age = 23;

    // 經過封裝的方式獲取money
    public int getMoney(){
        return money;
    }
    // 經過封裝的方式修改money
    public void addMoney(int num){
        money += num;
    }
}

private關鍵字

是一個權限修飾符 用於修飾成員變量和成員函數 被私有化的成員只在本類中有效

經常使用於： 將成員變量私有化，對外提供對應的set，get方法對其進行訪問，提升對數據訪問的安全性

構造函數

函數名與類名相同 不用定義返回值類型 沒有具體的返回值

做用：給對象進行初始化

package study_java.ex01;

public class ConstructDemo1 {

    public static void main(String[] args){
        Dog d = new Dog("aa");
        d.watch();
    }
}

class Dog{
    private String name;
    private String color;

    // 構造函數
    public Dog(String n){
        name = n;
        System.out.println("new Dog()");
    }

    public void watch(){
        System.out.println("旺旺");
        System.out.println(name);
    }

}

構造代碼塊也是類成員，是爲構造函數添加共有的一些內容 而且構造函數先於構造函數執行

對象的建立過程： 當new一個對象的時候

  • 在內個存中分配內存空間
  • 對成員變量賦默認值
  • 執行構造代碼塊或賦值語句，執行順序從上到下執行
  • 構造函數

靜態代碼塊

使用static修飾的代碼構造塊，在類加載的時候調用一次，之後再也不調用。 一般放置對靜態成員的初始化過程

static成員，跟對象無關，訪問的方式是經過Class.XXX()

this關鍵字

this:表明其所在函數所屬對象的引用，即this表明類對象的引用

static 關鍵字

用於修飾成員（成員變量和成員函數）

被修飾後的成員具有如下特色： 隨着類的加載而加載 優先於對象存在 被全部的對象所共享 能夠直接被類名調用

使用注意： 靜態方法只能訪問靜態成員 靜態方法不能寫this,super關鍵字 主函數是靜態的

代碼例子以下：

package study_java.ex01;

public class StaticDemo1 {
    public static void main(String[] args){
        System.out.println(Benz.brand1);

        Benz b1 = new Benz();
        System.out.println(b1.getBrand());

        // 直接訪問靜態方法
        System.out.println(Benz.getBrand1());
    }
}

class Benz{
    // 靜態成員
    private static String brand = "BENZ";

    public static  String brand1 = "BENZ1";

    private String color;

    public void setColor(String color){
        this.color = color;
    }

    public String getBrand(){
        return brand;
    }

    public static String getBrand1(){
        return brand;
    }
}

this(): 調用其餘構造函數的方式，並且必須做爲第一條語句

繼承

多個類中存在相同的屬性和行爲時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行爲，只要繼承那個類便可。

多個類能夠稱爲子類，單獨這個類稱爲父類 子類能夠直接訪問父類中國非私有的屬性和方法 經過extends關鍵字讓類與類之間產生繼承 java中只支持單衝繼承 + 多層繼承

簡單的例子：

package study_java.ex01;

public class ExtendsDemo1 {

    public static void main(String[] args){
        JingBa jingba = new JingBa();
        jingba.name = "大黃";
        jingba.watch();
        jingba.owner="zz";
    }


}


class Animal{
    public String name;
    public int weight;
    public void move(){
        System.out.println("move.....");
    }
}

class Dog extends Animal{
    public void watch(){
        System.out.println("有人來了");
    }
}

class JingBa extends Dog{
    public String owner;
}

super關鍵字

調用的是父類的構造函數，必須是第一條語句 經過下面例子理解：

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 建立對象
        BMWSportCar mychar = new BMWSportCar();
        mychar.color = "red";
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();

    }
}

class Car{
    public String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(String color){
        this.color = color;
        System.out.println("new car("+color+")");
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(int velocity){
        super("yellow");
        this.velocity = velocity;
        System.out.println("new SportCar("+velocity +")");
    }
}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        super(200);
        System.out.println("new BMWSportCar");
    }
}

若是被繼承的父類的屬性是私有的，若是想要訪問或者更改，能夠經過定義公有的方法來實現，代碼例子以下：

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 建立對象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有屬性
    private String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(){
        System.out.println("new SportCar()");
    }
}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

super和this的用法有點類似

  • this表明本類對象的引用
  • super表明父類的內存空間的標識
  • 子類要調用父類構造函數時，可使用super()語句
  • 當子類和父類出現同名成員時，能夠用super進行區分

super()和this()

調用父類的構造函數，必須是第一條語句

package study_java.ex01;

public class ExtendsDemo2 {

    public static void main(String[] args){
        // 建立對象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有屬性
    private String color;
    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;
    public SportCar(){
        System.out.println("new SportCar()");
    }
    public void setColorPro(String color){
        // this.color = color;  //這裏和下面的的super是同樣的
        super.setColor(color);
    }

    public void setColor(String color){
        super.setColor(color);
    }

}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

任何一個對象的建立都包含整個家族簇的建立，任何一個成員的建立，都包含這一整個順序的完成 經過下面代碼理解這個過程

package study_java.ex01;

public class ExtendsDemo3 {
    public static void main(String[] args){
        // 建立對象
        BMWSportCar mychar = new BMWSportCar();
        mychar.setColor("red");
        mychar.velocity = 200;
        mychar.price = 20000;
        mychar.run();
        System.out.println(mychar.getColor());

    }
}

class Car{
    //私有屬性
    private String color;

    {
        System.out.println("Cons Block in Car");
    }

    public void run(){
        System.out.println("running.....");
    }

    public Car(){

        System.out.println("new car()");
    }
    // 公有方法
    public String getColor(){
        return color;
    }
    public void setColor(String color){
        this.color = color;
    }
}

class SportCar extends Car{
    public int velocity;

    {
        System.out.println("Cons Block in SportCar");
    }
    public SportCar(){
        System.out.println("new SportCar()");
    }
    public void setColor(String color){
        super.setColor(color);
    }

}

class BMWSportCar extends SportCar{
    public int price;

    public BMWSportCar(){
        System.out.println("new BMWSportCar");
    }
}

函數覆蓋

子類中出現與父類中如出一轍的方法時，會出現覆蓋操做，也稱爲重寫或者複寫 父類中的私有方法不能夠被覆蓋 在子類覆蓋方法中，繼續使用被覆蓋的方法能夠經過super函數名獲取

覆蓋時須要注意的問題： 覆蓋時，子類方法權限必定要大於等於父類方法權限 靜態只能覆蓋靜態

主要的應用是： 當子類須要父類的功能，而功能主題子類有本身特有的內容時，能夠複寫父類中的方法，這樣就既沿襲了父類 的功能，又定義了父類特有的內容

代碼例子：

package study_java.ex01;

public class OverrideDemo1 {
    public static void main(String[] args){
        Rich2Man s2 = new Rich2Man();
        s2.consume(200000);
    }
}

class RichMan{
    public void consume(int money){
        if(money < 500){
            System.out.println("消費了"+money+"w");
        }
        else {
            System.out.println("不能消費了");
        }

    }
}

class Rich2Man extends RichMan{
    public void consume(int money){
        if(money < 50000){
            System.out.println("消費了"+money+"w");
        }
        else {
            System.out.println("不能消費了");
        }

    }
}

子類的實例化過程

子類中全部的構造函數morning都會訪問父類中空參數的構造函數 由於每個構造函數的第一行都有一條默認的語句super() 子類會具有父類中的數據，因此要先明確父類是如何對這些數據初始化的。 當父類中沒有空參數的構造函數時，子類的構造函數必須經過this或者super語句指定要訪問的構造函數

final 關鍵字

final 能夠修飾類，方法和變量

final 修飾的類不能夠被繼承

final 修飾的方法不能夠被覆蓋(能夠繼承)

final 修飾的變量是一個常量只能被賦值一次

內部類只能訪問被final修飾的局部變量

 

package study_java.ex01;

public class FinalDemo1 {
    public static void main(String[] args){
        Jing8 j = new Jing8();
        j.watch();
        System.out.println(j.name);
    }
}

class Dog1{
    // 常量
    public final String name = "aaa";
    
    // final 修飾的方法不能重寫
    public /*final */ void watch(){
        System.out.println("來人了");
    }
}

class Jing8 extends Dog1{
    public void watch() {
        System.out.println("聽一聽");
        super.watch();
    }
}

關於內部類 定義在class內部的類 編譯產生OuterClass$Innerc.class 內部類訪問外部類的局部變量，須要final修飾

代碼例子：

package study_java.ex01;

public class InnerClassDemo {
    public static void main(String[] args){
        Car2 c = new Car2();
        c.run();
    }
}

class Car2{
    public String color = "red";
    public int tires;

    public void run(){
        new Engine().fire();
        System.out.println("running.....");
    }

    class Engine{
        public void fire(){
            System.out.println("fire");
        }
    }
}

可是若是內部類寫在了方法裏，這裏有一個問題須要注意：

public class InnerClassDemo {
    public static void main(String[] args){
        Car2 c = new Car2();
        c.run();
    }
}

class Car2{
    public String color = "red";
    public int tires;

    public void run(){
        // 這裏的key必須是final 字段
        final String key = "ss";
        class Engine{
            public void fire(){
                System.out.println("插入鑰匙"+key);
                System.out.println("fire");
            }
        }
        new Engine().fire();
        System.out.println("running.....");
    }


}

抽象類

抽象類的定義： 抽象就是從多個事物中將共性的，本質的內容抽取出來 java 中能夠定義沒有方法體的方法，該方法的具體實現交給子類完成該 方法稱爲抽象方法，包含抽象方法的類就是抽象類

抽象類和抽象方法必須用abstract關鍵字修飾 抽象方法只有方法聲明，沒有具體的方法體，定義在抽象類中 抽象類不能夠被實例化，也就是不能用new建立對象 抽象類經過其子類實例化，而子類須要覆蓋掉抽象類中全部的方法後才能夠建立對象，不然該子類也是抽象類

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程