国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十)

這篇具有很好參考價值的文章主要介紹了從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十)。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方,請大家不吝賜教,您也可以點擊"舉報違法"按鈕提交疑問。

第一章 多態(tài)

1.1 多態(tài)的形式

多態(tài)是繼封裝、繼承之后,面向對象的第三大特性。

多態(tài)是出現(xiàn)在繼承或者實現(xiàn)關系中的。

多態(tài)體現(xiàn)的格式

父類類型 變量名 = new 子類/實現(xiàn)類構造器;
變量名.方法名();

多態(tài)的前提:有繼承關系,子類對象是可以賦值給父類類型的變量。例如Animal是一個動物類型,而Cat是一個貓類型。Cat繼承了Animal,Cat對象也是Animal類型,自然可以賦值給父類類型的變量。

1.2 多態(tài)的使用場景

如果沒有多態(tài),在下圖中register方法只能傳遞學生對象,其他的Teacher和administrator對象是無法傳遞給register方法方法的,在這種情況下,只能定義三個不同的register方法分別接收學生,老師和管理員。

從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十),java基礎,學習,java,spring boot,開發(fā)語言,spring cloud

有了多態(tài)之后,方法的形參就可以定義為共同的父類Person。

要注意的是:

  • 當一個方法的形參是一個類,我們可以傳遞這個類所有的子類對象。
  • 當一個方法的形參是一個接口,我們可以傳遞這個接口所有的實現(xiàn)類對象(后面會學)。
  • 而且多態(tài)還可以根據(jù)傳遞的不同對象來調用不同類中的方法。

從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十),java基礎,學習,java,spring boot,開發(fā)語言,spring cloud

代碼示例:

父類:
public class Person {
    private String name;
    private int age;

    空參構造
    帶全部參數(shù)的構造
    get和set方法

    public void show(){
        System.out.println(name + ", " + age);
    }
}

子類1public class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理員的信息為:" + getName() + ", " + getAge());
    }
}

子類2public class Student extends Person{

    @Override
    public void show() {
        System.out.println("學生的信息為:" + getName() + ", " + getAge());
    }
}

子類3public class Teacher extends Person{

    @Override
    public void show() {
        System.out.println("老師的信息為:" + getName() + ", " + getAge());
    }
}

測試類:
public class Test {
    public static void main(String[] args) {
        //創(chuàng)建三個對象,并調用register方法

        Student s = new Student();
        s.setName("張三");
        s.setAge(18);


        Teacher t = new Teacher();
        t.setName("王建國");
        t.setAge(30);

        Administrator admin = new Administrator();
        admin.setName("管理員");
        admin.setAge(35);



        register(s);
        register(t);
        register(admin);


    }



    //這個方法既能接收老師,又能接收學生,還能接收管理員
    //只能把參數(shù)寫成這三個類型的父類
    public static void register(Person p){
        p.show();
    }
}

1.3 多態(tài)的定義和前提

多態(tài): 是指同一行為,具有多個不同表現(xiàn)形式。

從上面案例可以看出,Cat和Dog都是動物,都是吃這一行為,但是出現(xiàn)的效果(表現(xiàn)形式)是不一樣的。

前提【重點】

  1. 有繼承或者實現(xiàn)關系

  2. 方法的重寫【意義體現(xiàn):不重寫,無意義】

  3. 父類引用指向子類對象【格式體現(xiàn)】

    父類類型:指子類對象繼承的父類類型,或者實現(xiàn)的父接口類型。

1.4 多態(tài)的運行特點

調用成員變量時:編譯看左邊,運行看左邊

調用成員方法時:編譯看左邊,運行看右邊

代碼示例:

Fu f = new Zi()//編譯看左邊的父類中有沒有name這個屬性,沒有就報錯
//在實際運行的時候,把父類name屬性的值打印出來
System.out.println(f.name);
//編譯看左邊的父類中有沒有show這個方法,沒有就報錯
//在實際運行的時候,運行的是子類中的show方法
f.show();

1.5 多態(tài)的弊端

我們已經(jīng)知道多態(tài)編譯階段是看左邊父類類型的,如果子類有些獨有的功能,此時多態(tài)的寫法就無法訪問子類獨有功能了。

class Animal{
    public  void eat()System.out.println("動物吃東西!")}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
   
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
}

class Test{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.catchMouse();//編譯報錯,編譯看左邊,Animal沒有這個方法
    }
}

1.6 引用類型轉換

1.6.1 為什么要轉型

多態(tài)的寫法就無法訪問子類獨有功能了。

當使用多態(tài)方式調用方法時,首先檢查父類中是否有該方法,如果沒有,則編譯錯誤。也就是說,不能調用子類擁有,而父類沒有的方法。編譯都錯誤,更別說運行了。這也是多態(tài)給我們帶來的一點"小麻煩"。所以,想要調用子類特有的方法,必須做向下轉型。

回顧基本數(shù)據(jù)類型轉換

  • 自動轉換: 范圍小的賦值給范圍大的.自動完成:double d = 5;
  • 強制轉換: 范圍大的賦值給范圍小的,強制轉換:int i = (int)3.14

? 多態(tài)的轉型分為向上轉型(自動轉換)與向下轉型(強制轉換)兩種。

1.6.2 向上轉型(自動轉換)

  • 向上轉型:多態(tài)本身是子類類型向父類類型向上轉換(自動轉換)的過程,這個過程是默認的。
    當父類引用指向一個子類對象時,便是向上轉型。
    使用格式:
父類類型  變量名 = new 子類類型();
如:Animal a = new Cat();

**原因是:父類類型相對與子類來說是大范圍的類型,Animal是動物類,是父類類型。Cat是貓類,是子類類型。Animal類型的范圍當然很大,包含一切動物。**所以子類范圍小可以直接自動轉型給父類類型的變量。

1.6.3 向下轉型(強制轉換)

  • 向下轉型:父類類型向子類類型向下轉換的過程,這個過程是強制的。
    一個已經(jīng)向上轉型的子類對象,將父類引用轉為子類引用,可以使用強制類型轉換的格式,便是向下轉型。

使用格式:

子類類型 變量名 = (子類類型) 父類變量名;:Aniaml a = new Cat();
   Cat c =(Cat) a;  

1.6.4 案例演示

當使用多態(tài)方式調用方法時,首先檢查父類中是否有該方法,如果沒有,則編譯錯誤。也就是說,不能調用子類擁有,而父類沒有的方法。編譯都錯誤,更別說運行了。這也是多態(tài)給我們帶來的一點"小麻煩"。所以,想要調用子類特有的方法,必須做向下轉型。

轉型演示,代碼如下:

定義類:

abstract class Animal {  
    abstract void eat();  
}  

class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void catchMouse() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void watchHouse() {  
        System.out.println("看家");  
    }  
}

定義測試類:

public class Test {
    public static void main(String[] args) {
        // 向上轉型  
        Animal a = new Cat();  
        a.eat(); 				// 調用的是 Cat 的 eat

        // 向下轉型  
        Cat c = (Cat)a;       
        c.catchMouse(); 		// 調用的是 Cat 的 catchMouse
    }  
}

1.6.5 轉型的異常

轉型的過程中,一不小心就會遇到這樣的問題,請看如下代碼:

public class Test {
    public static void main(String[] args) {
        // 向上轉型  
        Animal a = new Cat();  
        a.eat();               // 調用的是 Cat 的 eat

        // 向下轉型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 調用的是 Dog 的 watchHouse 【運行報錯】
    }  
}

這段代碼可以通過編譯,但是運行時,卻報出了 ClassCastException ,類型轉換異常!這是因為,明明創(chuàng)建了Cat類型對象,運行時,當然不能轉換成Dog對象的。

1.6.6 instanceof關鍵字

為了避免ClassCastException的發(fā)生,Java提供了 instanceof 關鍵字,給引用變量做類型的校驗,格式如下:

變量名 instanceof 數(shù)據(jù)類型 
如果變量屬于該數(shù)據(jù)類型或者其子類類型,返回true。
如果變量不屬于該數(shù)據(jù)類型或者其子類類型,返回false。

所以,轉換前,我們最好先做一個判斷,代碼如下:

public class Test {
    public static void main(String[] args) {
        // 向上轉型  
        Animal a = new Cat();  
        a.eat();               // 調用的是 Cat 的 eat

        // 向下轉型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 調用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 調用的是 Dog 的 watchHouse
        }
    }  
}

1.6.7 instanceof新特性

JDK14的時候提出了新特性,把判斷和強轉合并成了一行

//新特性
//先判斷a是否為Dog類型,如果是,則強轉成Dog類型,轉換之后變量名為d
//如果不是,則不強轉,結果直接是false
if(a instanceof Dog d){
    d.lookHome();
}else if(a instanceof Cat c){
    c.catchMouse();
}else{
    System.out.println("沒有這個類型,無法轉換");
}

1.7 綜合練習

需求:根據(jù)需求完成代碼:
	1.定義狗類
		屬性:
			年齡,顏色
		行為:
			eat(String something)(something表示吃的東西)
			看家lookHome方法(無參數(shù))
2.定義貓類
	屬性:
		年齡,顏色
	行為:
		eat(String something)方法(something表示吃的東西)
		逮老鼠catchMouse方法(無參數(shù))
3.定義Person//飼養(yǎng)員
	屬性:
		姓名,年齡
	行為:
		keepPet(Dog dog,String something)方法
			功能:喂養(yǎng)寵物狗,something表示喂養(yǎng)的東西
	行為:
		keepPet(Cat cat,String something)方法
			功能:喂養(yǎng)寵物貓,something表示喂養(yǎng)的東西
	生成空參有參構造,set和get方法  
4.定義測試類(完成以下打印效果):
	keepPet(Dog dog,String somethind)方法打印內容如下:
		年齡為30歲的老王養(yǎng)了一只黑顏色的2歲的狗
		2歲的黑顏色的狗兩只前腿死死的抱住骨頭猛吃
	keepPet(Cat cat,String somethind)方法打印內容如下:
		年齡為25歲的老李養(yǎng)了一只灰顏色的3歲的貓
		3歲的灰顏色的貓瞇著眼睛側著頭吃魚
5.思考:		
	1.Dog和Cat都是Animal的子類,以上案例中針對不同的動物,定義了不同的keepPet方法,過于繁瑣,能否簡化,并體會簡化后的好處?
	2.Dog和Cat雖然都是Animal的子類,但是都有其特有方法,能否想辦法在keepPet中調用特有方法?

畫圖分析:

從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十),java基礎,學習,java,spring boot,開發(fā)語言,spring cloud

代碼示例:

//動物類(父類)
public class Animal {
    private int age;
    private String color;


    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

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

    public void eat(String something){
        System.out.println("動物在吃" + something);
    }
}

//貓類(子類)
public class Cat extends Animal {

    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "歲的" + getColor() + "顏色的貓瞇著眼睛側著頭吃" + something);
    }

    public void catchMouse(){
        System.out.println("貓抓老鼠");
    }

}

//狗類(子類)
public class Dog extends Animal {
    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    //行為
    //eat(String something)(something表示吃的東西)
    //看家lookHome方法(無參數(shù))
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "歲的" + getColor() + "顏色的狗兩只前腿死死的抱住" + something + "猛吃");
    }

    public void lookHome(){
        System.out.println("狗在看家");
    }
}


//飼養(yǎng)員類
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //飼養(yǎng)狗
   /* public void keepPet(Dog dog, String something) {
        System.out.println("年齡為" + age + "歲的" + name + "養(yǎng)了一只" + dog.getColor() + "顏色的" + dog.getAge() + "歲的狗");
        dog.eat(something);
    }

    //飼養(yǎng)貓
    public void keepPet(Cat cat, String something) {
        System.out.println("年齡為" + age + "歲的" + name + "養(yǎng)了一只" + cat.getColor() + "顏色的" + cat.getAge() + "歲的貓");
        cat.eat(something);
    }*/


    //想要一個方法,能接收所有的動物,包括貓,包括狗
    //方法的形參:可以寫這些類的父類 Animal
    public void keepPet(Animal a, String something) {
        if(a instanceof Dog d){
            System.out.println("年齡為" + age + "歲的" + name + "養(yǎng)了一只" + a.getColor() + "顏色的" + a.getAge() + "歲的狗");
            d.eat(something);
        }else if(a instanceof Cat c){
            System.out.println("年齡為" + age + "歲的" + name + "養(yǎng)了一只" + c.getColor() + "顏色的" + c.getAge() + "歲的貓");
            c.eat(something);
        }else{
            System.out.println("沒有這種動物");
        }
    }
}

//測試類
public class Test {
    public static void main(String[] args) {
        //創(chuàng)建對象并調用方法
       /* Person p1 = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        p1.keepPet(d,"骨頭");


        Person p2 = new Person("老李",25);
        Cat c = new Cat(3,"灰");
        p2.keepPet(c,"魚");*/


        //創(chuàng)建飼養(yǎng)員的對象
        Person p = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        Cat c = new Cat(3,"灰");
        p.keepPet(d,"骨頭");
        p.keepPet(c,"魚");

    }
}

第二章 包

2.1 包

? 包在操作系統(tǒng)中其實就是一個文件夾。包是用來分門別類的管理技術,不同的技術類放在不同的包下,方便管理和維護。

在IDEA項目中,建包的操作如下:

從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十),java基礎,學習,java,spring boot,開發(fā)語言,spring cloud

包名的命名規(guī)范

路徑名.路徑名.xxx.xxx
// 例如:com.itheima.oa
  • 包名一般是公司域名的倒寫。例如:黑馬是www.itheima.com,包名就可以定義成com.itheima.技術名稱。
  • 包名必須用”.“連接。
  • 包名的每個路徑名必須是一個合法的標識符,而且不能是Java的關鍵字。

2.2 導包

什么時候需要導包?

? 情況一:在使用Java中提供的非核心包中的類時

? 情況二:使用自己寫的其他包中的類時

什么時候不需要導包?

? 情況一:在使用Java核心包(java.lang)中的類時

? 情況二:在使用自己寫的同一個包中的類時

2.3 使用不同包下的相同類怎么辦?

假設demo1和demo2中都有一個Student該如何使用?

代碼示例:

//使用全類名的形式即可。
//全類名:包名 + 類名
//拷貝全類名的快捷鍵:選中類名crtl + shift + alt + c 或者用鼠標點copy,再點擊copy Reference
com.itheima.homework.demo1.Student s1 = new com.itheima.homework.demo1.Student();
com.itheima.homework.demo2.Student s2 = new com.itheima.homework.demo2.Student();

第三章 權限修飾符

3.1 權限修飾符

? 在Java中提供了四種訪問權限,使用不同的訪問權限修飾符修飾時,被修飾的內容會有不同的訪問權限,我們之前已經(jīng)學習過了public 和 private,接下來我們研究一下protected和默認修飾符的作用。

  • public:公共的,所有地方都可以訪問。

  • protected:本類 ,本包,其他包中的子類都可以訪問。

  • 默認(沒有修飾符):本類 ,本包可以訪問。

    注意:默認是空著不寫,不是default

  • private:私有的,當前類可以訪問。
    public > protected > 默認 > private

3.2 不同權限的訪問能力

public protected 默認 private
同一類中
同一包中的類
不同包的子類
不同包中的無關類

可見,public具有最大權限。private則是最小權限。

編寫代碼時,如果沒有特殊的考慮,建議這樣使用權限:

  • 成員變量使用private ,隱藏細節(jié)。
  • 構造方法使用 public ,方便創(chuàng)建對象。
  • 成員方法使用public ,方便調用方法。

小貼士:不加權限修飾符,就是默認權限

第四章 final關鍵字

4.1 概述

? 學習了繼承后,我們知道,子類可以在父類的基礎上改寫父類內容,比如,方法重寫。

如果有一個方法我不想別人去改寫里面內容,該怎么辦呢?

Java提供了final 關鍵字,表示修飾的內容不可變。

  • final: 不可改變,最終的含義。可以用于修飾類、方法和變量。
    • 類:被修飾的類,不能被繼承。
    • 方法:被修飾的方法,不能被重寫。
    • 變量:被修飾的變量,有且僅能被賦值一次。

4.2 使用方式

4.2.1 修飾類

final修飾的類,不能被繼承。

格式如下:

final class 類名 {
}

代碼:

final class Fu {
}
// class Zi extends Fu {} // 報錯,不能繼承final的類

查詢API發(fā)現(xiàn)像 public final class String 、public final class Mathpublic final class Scanner 等,很多我們學習過的類,都是被final修飾的,目的就是供我們使用,而不讓我們所以改變其內容。

4.2.2 修飾方法

final修飾的方法,不能被重寫。
格式如下:

修飾符 final 返回值類型 方法名(參數(shù)列表){
    //方法體
}

代碼:

class Fu2 {
	final public void show1() {
		System.out.println("Fu2 show1");
	}
	public void show2() {
		System.out.println("Fu2 show2");
	}
}

class Zi2 extends Fu2 {
//	@Override
//	public void show1() {
//		System.out.println("Zi2 show1");
//	}
	@Override
	public void show2() {
		System.out.println("Zi2 show2");
	}
}

4.2.3 修飾變量-局部變量

  1. 局部變量——基本類型
    基本類型的局部變量,被final修飾后,只能賦值一次,不能再更改。代碼如下:
public class FinalDemo1 {
    public static void main(String[] args) {
        // 聲明變量,使用final修飾
        final int a;
        // 第一次賦值 
        a = 10;
        // 第二次賦值
        a = 20; // 報錯,不可重新賦值

        // 聲明變量,直接賦值,使用final修飾
        final int b = 10;
        // 第二次賦值
        b = 20; // 報錯,不可重新賦值
    }
}

思考,下面兩種寫法,哪種可以通過編譯?

寫法1:

final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}

寫法2:

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

根據(jù) final 的定義,寫法1報錯!寫法2,為什么通過編譯呢?因為每次循環(huán),都是一次新的變量c。這也是大家需要注意的地方。

4.2.4 修飾變量-成員變量

成員變量涉及到初始化的問題,初始化方式有顯示初始化和構造方法初始化,只能選擇其中一個:

  • 顯示初始化(在定義成員變量的時候立馬賦值)(常用);
public class Student {
    final int num = 10;
}
  • 構造方法初始化(在構造方法中賦值一次)(不常用,了解即可)。

    注意:每個構造方法中都要賦值一次!

public class Student {
    final int num = 10;
    final int num2;

    public Student() {
        this.num2 = 20;
//     this.num2 = 20;
    }
    
     public Student(String name) {
        this.num2 = 20;
//     this.num2 = 20;
    }
}

被final修飾的常量名稱,一般都有書寫規(guī)范,所有字母都大寫。

后記
????????美好的一天,到此結束,下次繼續(xù)努力!欲知后續(xù),請看下回分解,寫作不易,感謝大家的支持??! ??????
文章來源地址http://www.zghlxwxcb.cn/news/detail-652798.html

到了這里,關于從零開始學習 Java:簡單易懂的入門指南之多態(tài)(十)的文章就介紹完了。如果您還想了解更多內容,請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章,希望大家以后多多支持TOY模板網(wǎng)!

本文來自互聯(lián)網(wǎng)用戶投稿,該文觀點僅代表作者本人,不代表本站立場。本站僅提供信息存儲空間服務,不擁有所有權,不承擔相關法律責任。如若轉載,請注明出處: 如若內容造成侵權/違法違規(guī)/事實不符,請點擊違法舉報進行投訴反饋,一經(jīng)查實,立即刪除!

領支付寶紅包贊助服務器費用

相關文章

  • 從零開始學習 Java:簡單易懂的入門指南之方法(六)

    1.1 方法的概念 ? 方法(method)是程序中最小的執(zhí)行單元 注意: 方法必須先創(chuàng)建才可以使用,該過程成為方法定義 方法創(chuàng)建后并不是直接可以運行的,需要手動使用后,才執(zhí)行,該過程成為方法調用 2.1 無參數(shù)方法定義和調用 定義格式: 范例: 調用格式: 范例: 注意:

    2024年02月14日
    瀏覽(99)
  • 從零開始學習 Java:簡單易懂的入門指南之數(shù)組(五)

    概念: ? 指的是一種容器,可以同來存儲同種數(shù)據(jù)類型的多個值。 ? 但是數(shù)組容器在存儲數(shù)據(jù)的時候,需要結合隱式轉換考慮。 比如: ? 定義了一個int類型的數(shù)組。那么boolean。double類型的數(shù)據(jù)是不能存到這個數(shù)組中的, ? 但是byte類型,short類型,int類型的數(shù)據(jù)是可以存

    2024年02月14日
    瀏覽(95)
  • 從零開始學習 Java:簡單易懂的入門指南之異常(二十八)

    從零開始學習 Java:簡單易懂的入門指南之異常(二十八)

    異常,就是不正常的意思。在生活中:醫(yī)生說,你的身體某個部位有異常,該部位和正常相比有點不同,該部位的功能將受影響.在程序中的意思就是: 異常 :指的是程序在執(zhí)行過程中,出現(xiàn)的非正常的情況,最終會導致JVM的非正常停止。 在Java等面向對象的編程語言中,異常本身

    2024年02月08日
    瀏覽(87)
  • 從零開始學習 Java:簡單易懂的入門指南之反射(三十八)

    ? 專業(yè)的解釋: ? 是在運行狀態(tài)中,對于任意一個類,都能夠知道這個類的所有屬性和方法; ? 對于任意一個對象,都能夠調用它的任意屬性和方法; ? 這種動態(tài)獲取信息以及動態(tài)調用對象方法的功能稱為Java語言的反射機制。 ? 通俗的理解: 利用 反射 創(chuàng)建的對象 可

    2024年02月08日
    瀏覽(90)
  • 從零開始學習 Java:簡單易懂的入門指南之包裝類(十九)

    Java提供了兩個類型系統(tǒng),基本類型與引用類型,使用基本類型在于效率,然而很多情況,會創(chuàng)建對象使用,因為對象可以做更多的功能,如果想要我們的基本類型像對象一樣操作,就可以使用基本類型對應的包裝類,如下: 基本類型 對應的包裝類(位于java.lang包中) byte

    2024年02月11日
    瀏覽(100)
  • 從零開始學習 Java:簡單易懂的入門指南之類和對象(七)

    從零開始學習 Java:簡單易懂的入門指南之類和對象(七)

    1.1 類和對象的理解 客觀存在的事物皆為對象 ,所以我們也常常說萬物皆對象。 類 類的理解 類是對現(xiàn)實生活中一類具有共同屬性和行為的事物的抽象 類是對象的數(shù)據(jù)類型,類是具有相同屬性和行為的一組對象的集合 簡單理解:類就是對現(xiàn)實事物的一種描述 類的組成 屬性:

    2024年02月14日
    瀏覽(97)
  • 從零開始學習 Java:簡單易懂的入門指南之面向對象(九)

    從零開始學習 Java:簡單易懂的入門指南之面向對象(九)

    類的定義格式如下: 例如: 例如: 1.3.1 封裝的步驟 1.使用 private 來修飾成員變量。 2.使用 public 修飾getter和setter方法。 1.3.2 封裝的步驟實現(xiàn) private修飾成員變量 public修飾getter和setter方法 1.4.1 構造方法的作用 在創(chuàng)建對象的時候,給成員變量進行初始化。 初始化即賦值的意

    2024年02月13日
    瀏覽(95)
  • 從零開始學習 Java:簡單易懂的入門指南之時間類(十七)

    java.util.Date`類 表示特定的瞬間,精確到毫秒。 繼續(xù)查閱Date類的描述,發(fā)現(xiàn)Date擁有多個構造函數(shù),只是部分已經(jīng)過時,我們重點看以下兩個構造函數(shù) public Date() :從運行程序的此時此刻到時間原點經(jīng)歷的毫秒值,轉換成Date對象,分配Date對象并初始化此對象,以表示分配它的時

    2024年02月11日
    瀏覽(1072)
  • 從零開始學習 Java:簡單易懂的入門指南之for循環(huán)(四)

    從零開始學習 Java:簡單易懂的入門指南之for循環(huán)(四)

    在一個程序執(zhí)行的過程中,各條語句的執(zhí)行順序對程序的結果是有直接影響的。所以,我們必須清楚每條語句的執(zhí)行流程。而且,很多時候要通過控制語句的執(zhí)行順序來實現(xiàn)我們想要的功能。 1.1 流程控制語句分類 ? 順序結構 ? 判斷和選擇結構(if, switch) ? 循環(huán)結構(for, w

    2024年02月12日
    瀏覽(88)
  • 從零開始學習 Java:簡單易懂的入門指南之線程池(三十六)

    從零開始學習 Java:簡單易懂的入門指南之線程池(三十六)

    當線程被創(chuàng)建并啟動以后,它既不是一啟動就進入了執(zhí)行狀態(tài),也不是一直處于執(zhí)行狀態(tài)。線程對象在不同的時期有不同的狀態(tài)。那么Java中的線程存在哪幾種狀態(tài)呢?Java中的線程 狀態(tài)被定義在了java.lang.Thread.State枚舉類中,State枚舉類的源碼如下: 通過源碼我們可以看到Ja

    2024年02月08日
    瀏覽(90)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請作者喝杯咖啡吧~博客贊助

支付寶掃一掃領取紅包,優(yōu)惠每天領

二維碼1

領取紅包

二維碼2

領紅包