Java物件導向特點與使用方法是什麼

面向過程和物件導向的區別

面向過程：當事件比較簡單的時候，利用面向過程，注重的是事件的具體步驟和過程，注重的是過程中的具體行為，以函數為最小單位，考慮怎麼做。

物件導向：專注找“參與者”，將功能封裝進物件中，強調具備了功能的對象，以類別/物件為最小單位，考慮誰來做。

案例：小明從冰箱裡拿東西

面向過程：

物件導向:

面向過程—> 物件導向, 其實就是由執行者—> 指揮者的一個過渡

類別和物件的關係

萬物皆物件

物件：具體的事物，具體的實體，具體的實例，模板下具體的產品

類別：對物件向上抽取出像的部分，公佈部分，形成類別，類別是抽象的，是一個模板，一般在寫程式碼的時候先寫類，然後再根據類別創建對應的物件

類別是物件的抽象，物件是類別的實例化

類別和物件的建立

類別的建立

1.屬性（field 成員變數）

屬性用於定義該類別或該類別物件包含的資料或者說靜態特徵。屬性作用範圍是整個類別。

屬性定義格式：

[修飾符] 屬性類型屬性名稱= [預設值];

2.方法

方法用於定義該類別或該類別實例的行為特徵和功能實作。方法是類別和物件行為特徵的抽象。方法很類似於過程導向中的函數。在面向過程中，函數是最基本單位，整個程式由一個個函數呼叫組成。在物件導向中，整個程式的基本單位是類，方法是從屬於類別和物件的。

方法定義格式：

[修飾符] 方法傳回型別方法名稱（形參列表）{

#//Java語句

}

我們以上面王者榮耀英雄類別創建為例：

//创建英雄类
public class Hero {
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    //技能
    public void Kill(int number){
        //根据输入的数字释放几技能
        System.out.println(Name+"释放"+number+"技能！！！");
    }
    //输出该英雄的属性
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }

}

物件的創建

接下來我們對我們創建好的類別來創建物件

public class TestCode01 {
    //main方法，程序的入口
    public static void main(String[] args) {
        //创建一个对象(英雄)-->马克波罗
        Hero make = new Hero();
        make.Name = "马克波罗";
        make.Survive = 4;
        make.Attack = 6;
        make.Skill = 6;
        make.Difficulty = 5;
        //再创建一个英雄-->澜
        Hero lan = new Hero();
        lan.Name = "澜";
        lan.Survive = 3;
        lan.Attack = 5;
        lan.Skill = 4;
        lan.Difficulty = 6;
        lan.Kill(1);
        //输出两个英雄的属性
        make.print();
        System.out.println("-------------");
        lan.print();
        //释放技能
        make.Kill(3);
        System.out.println("-------------");
        lan.Kill(2);
    }
}

結果: 每個英雄都有相同的屬性，每個屬性又有不同的值，透過類別我們可以創建很多個對象，每個對象又有不同的屬性值。

例如：王者裡的一百多個英雄，每個都有不同的特色。

創建物件的過程：

（1）在第一次遇到一個類別的時候，對這個類別要加載，只加載一次。

（2）建立對象，在堆中開啟空間

（3）對對象進行初始化操作，屬性賦值都是預設的初始值。

（4）new關鍵字呼叫建構器，執行建構方法，在建構器中對屬性重新進行賦值

建構器

物件都是new出來的， new關鍵字其實在呼叫一個方法，這個方法叫做建構方法（建構器）

呼叫建構器的時候，如果你的類別中沒有寫構造器，那麼系統會預設給你一個建構器（空建構子）

建構方法格式：

[修飾符] 建構器名稱（）{

}

#建構器與方法的差異：

• 沒有方法的回傳值

• #方法體內部不能有return語句

• 建構器的名字很特殊，必須跟類別名稱一致

建構器的作用：不是為了創建對象，因為在呼叫建構器之前，這個物件就已經創建好了，並且屬性有預設的初始化的值。

呼叫建構器的目的是給屬性進行賦值操作的。

注意：我們一般不會在空構造器中進行初始化操作，因為那樣的話每個物件的屬性就一樣了。

下面範例：

class Hero{
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    public Hero(){
        Survive=4;
        Attack=5;
        Skill=6;
        Difficulty=7;
    }
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }
}
public class TestCode01 {
    public static void main(String[] args) {
        //创建两个英雄对象
        Hero make = new Hero();
        make.Name="马克";
        Hero lan=new Hero();
        lan.Name="澜";
        //输出两个属性
        make.print();
        lan.print();
    }
}

因為我們在建構器裡面賦值了，所以我們建立物件的時候屬性就一樣了

##實際上，我們只要保證空構造器的存在就可以了，裡面的東西不用寫，我們要用構造器賦值就要對構造器重載

構造器重載

#一般保證空構造器的存在，空構造器中一般不會進行屬性的賦值操作

#一般我們會重載構造器，在重載的構造器中進行屬性賦值操作

在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。所以我们重载构造器时，一般要保留默认构造器

当形参名字和属性名字重名的时候，会出现就近原则：在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

this的使用

this就是指当前的对象

this可以修饰属性

当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰（如果不发生重名问题的话，实际上你要是访问属性也可以省略this.）

this修饰方法

在同一个类中，方法可以互相调用，this.可以省略不写。

this可以修饰构造器

同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

static修饰

static可以修饰：属性、方法、代码块、内部类

static修饰属性

在类加载的时候，会将静态内容也加载到方法区的静态域中，静态的内容先于对象存在，并且这个静态内容被所有该类的对象共享。

• 在类加载的时候一起加载入方法区中的静态域中

• 先于对象存在

• 访问方式： 对象名.属性名 类名.属性名（推荐）

static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 -->这个情况下，就可以用static修饰的属性。

static修饰方法：

• static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行

• 在静态方法中不能使用this关键字

• 在静态方法中不能访问非静态的方法

• 在静态方法中不能访问非静态的属性

• 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐）

• 在同一个类中可以直接调用静态方法

代码块

代码块的分类： 普通块、构造块、静态块、同步块（多线程）

代码块执行顺序： 最先执行静态块–>再执行构造块，（不常用）–>再执行构造器–>再执行方法中的普通块

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }

    }
    public static void b(){
        System.out.println("------b");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
        System.out.println("这是空构造器");
    }
    public Test(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

包（import）

包的作用： 为了解决重名的作用，解决权限问题

包名的定义：

• 名字全部小写

• 中间用.隔开

• 一般都是公司域名倒着写：com.jd 、com.taobao

• 加上模块名字 ：com.taobao.login

• 不能使用系统中的关键字：null

• 包声明的位置一般都在非注释代码的第一行

导包：

（1）使用不同包下的类要需要导包， 例如：import java.util.Date;

（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。

（3）同一个包下的类想使用不需要导包，可以直接使用。

（4）在java.lang包下的类，可以直接使用无需导包

（5）可以直接导入*：

静态导入：

//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
        return 1000;
    }
}

以上是Java物件導向特點與使用方法是什麼的詳細內容。更多資訊請關注PHP中文網其他相關文章！