Java編程基礎08——面向對象_構造方法&靜態static

張巨偉發布于2019-08-19 11:03 / 3320人閱讀

摘要：如果我們給出了構造方法，系統將不再提供默認的無參構造方法。概念方便在沒有創建對象的情況下來進行調用方法變量。因為它的成員全部是靜態的所以私有了構造方法獲取隨機數的方法返回帶正號的值，該值大于等于

1.構造方法Constructor概述和格式(掌握)

A:構造方法概述和作用

給對象的數據(屬性)進行初始化

B:構造方法格式特點

a:方法名與類名相同(大小寫也要與類名一致)

b:沒有返回值類型，連void都沒有

c:沒有具體的返回值return;

public class JavaObject {    //創建對象JavaObject 
    public static void main(String [] args) {
        Person p = new Person(); //在一創建對象的時候，系統就幫我們調用了構造方法
        //p.Person();   //構造方法不能用對象調用
        p.show();

        Person p = new Person(); //再次創建對象
        p.show();
    }
}

class Person {
    private String name; //成員變量都私有
    private int age;

    //構造方法
    public Person() {
        //System.out.println("hello");
        //return;                    //構造方法也是有return語句的；
        name = "張三";
        age = 23;
    }
    public void show() {
        System.out.println(name + "..." + age);
    }
}

2.構造方法的重載及注意事項(掌握)

A:案例演示

構造方法的重載

重載:在同一類中,方法名相同,與返回值類型無關(構造方法沒有返回值),只看參數列表

有參構造的好處:可以動態的給屬性賦值

B:構造方法注意事項

a:如果我們沒有給出構造方法，系統將自動提供一個無參構造方法。

b:如果我們給出了構造方法，系統將不再提供默認的無參構造方法。

注意：這個時候，如果我們還想使用無參構造方法，就必須自己手動給出，應自己給出無參構造方法。

public class JavaObject {    //創建對象
    public static void main(String [] args) {
        Person p1 = new Person();
        p1.show();
        System.out.println("-------------------");
        Person p2 = new Person("張三",23);
        p2.show();
        System.out.println("-------------------");
        Person p3 = new Person("李四",24);    //初始化，并動態的賦值
        p3.show();
    }
}
class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("空參的構造");
    }
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("有參的構造");
    }

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

}

3.給成員變量賦值的兩種方式的區別

A：setXxx()方法—— 修改屬性值(開發中用的多一些,因為靈活)

B：構造方法—— 給對象中屬性進行初始化。

public class JavaObject {    //創建對象phone  
    public static void main(String [] args) {
        Person p1 = new Person("張三",23);
        p1 = new Person("李天一",25);    //將元對象變成了垃圾
        System.out.println(p1.getName() + "..." + p1.getAge());
        System.out.println("-------------------");
        Person p2 = new Person();  //空參構造創建對象
        p2.setName("李四");
        p2.setAge(24);
        p2.setName("李鬼")；
        System.out.println(p2.getName() + "..." + p2.getAge());
    }
}
class Person {
    private String name;
    private int age;

    public Person() {        //空參構造
    }
    public Person(String name,int age) {        //有參構造
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {        //設置姓名
        this.name = name;
    }
    public String getName() {        //獲取姓名
        return name;
    }

    public void setAge(int age) {        //設置年齡
        this.age = age;
    }
    public int getAge() {        //獲取年齡
        return age;
    }
}

4.學生類的代碼及測試(掌握)

A:案例演示學生類：

成員變量：name，age

構造方法：無參，帶兩個參

成員方法： getXxx()/setXxx() java bean類(實體類) show()：輸出該類的所有成員變量值

B:給成員變量賦值：

a:setXxx()方法

b:構造方法

C:輸出成員變量值的方式：

a:通過getXxx()分別獲取然后拼接

b:通過調用show()方法搞定

c:兩者區別:
getXxx()獲取屬性值,可以打印,也可以賦值給其他的變量,做其他的操作
show()只是為了顯示屬性值

class Student {
    private String name;
    private int age;

    public Student() {        //空參構造
    }
    public Student(String name,int age) {        //有參構造
        this.name = name;
        this.age = age;
    }
    public void setName(String name) {        //設置姓名
        this.name = name;
    }
    public String getName() {        //獲取姓名
        return name;
    }

    public void setAge(int age) {        //設置年齡
        this.age = age;
    }
    public int getAge() {        //獲取年齡
        return age;
    }

    public void show() {
        System.out.println("我的姓名是" + name + "我的年齡是" + age);
    }
}
public class JavaObject {    
    public static void main(String [] args) {
        Student s1 = new Student();  //空參構造創建對象
        s1.setName("李四");   //設置姓名
        s1.setAge(24);        //設置年齡
        System.out.println("我的姓名是" + s1.getName() + "..." + "我的年齡是" + s1.getAge());
        System.out.println("-------------------");
        //getXxx()獲取屬性值，可以打印，也可以賦值給其他的變量，做其他的操作
        Student s2 = new Student("張三",23); //使用有參構造
        s2.show();   //只是為了顯示屬性值
    }
}

5.手機類案例(掌握)

成員變量：品牌brand，價格price

構造方法：無參有參

成員發法：setXxxh和getXxx、show

class Phone {
    private String brand;
    private int price;

    public Phone() {        //空參構造
    }
    public Phone(String brand,int price) {        //有參構造
        this.brand = brand;
        this.price = price;
    }
    public void setBrand(String brand) {        //設置品牌
        this.brand = brand;
    }
    public String getBrand() {        //獲取拼拍
        return brand;
    }
    public void setPrice(int price) {        //設置價格
        this.price = price;
    }
    public int getPrice() {        //獲取價格
        return price;
    }
    public void show() {
        System.out.println(brand + "..." + price);
    }
}
public class JavaObject {    
    public static void main(String [] args) {
        Phone s1 = new Phone();  //空參構造創建對象
        s1.setBrand("小米");   //設置品牌
        s1.setPrice(2400);        //設置價格
        System.out.println("品牌名稱是" + s1.getBrand() + "..." + "價格是" + s1.getPrice());
        System.out.println("-------------------");
        //getXxx()獲取屬性值，可以打印，也可以賦值給其他的變量，做其他的操作
        Phone s2 = new Phone("張三",23); //使用有參構造
        s2.show();   //只是為了顯示屬性值
    }
}

6.創建一個對象的步驟(掌握)

畫圖說明一個對象的創建過程(如何加載到內存)做了哪些事情?

Student s = new Student();

1,Student.class加載進內存

2,聲明一個Student類型引用s

3,在堆內存創建對象,

4,給對象中屬性默認初始化值

5,屬性進行顯示初始化

6,構造方法進棧,對對象中的屬性賦值,構造方法彈棧

7,將對象的地址值賦值給s

class Student {
    private String name = "張三";
    private int age = 23;

    public Student() {        
        name = "李四";
        age = 24;
    }
    public void show() {
        System.out.println(name + "..." + age);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Student s = new Student();  //空參構造創建對象
        s.show();   //只是為了顯示屬性值
    }
}

7.長方形案例練習(掌握)

A:案例演示

需求：

定義一個長方形類,定義求周長和面積的方法，

然后定義一個測試類進行測試。

分析

成員變量：寬width，高height，空參有參構造setXxxx和getXxx;

求周長getLength()，求面積getArea()

class Rectangle {
    private int width;
    private int height;


    public Rectangle() {        //空參構造
    }
    public Rectangle(int width,int height) {        //有參構造
        this.width = width;
        this.height = height;
    }

    public void setWidth(int width) { //設置寬
        this.width = width;
    }
    public int setWidth() {   //獲取寬
        return width;
    }
    public void setheight(int height) { //設置高
        this.height = height;
    }
    public int setheight() {   //獲取高
        return height;
    }



    public int getLenght() {  //獲取周長
        return 2 * (width + height);
    }

    public int getArea() {  //獲取面積
        return width * height;
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Rectangle s = new Rectangle(10,20);  //空參構造創建對象
        System.out.println(s.getLenght());    //周長
        System.out.println(s.getArea());    //面積
    }
}

8.員工類案例練習(掌握)

A:案例演示

需求：定義一個員工類Employee

自己分析出幾個成員，然后給出成員變量

姓名name,工號id,工資salary

構造方法，

空參和有參的

getXxx()setXxx()方法，

以及一個顯示所有成員信息的方法。并測試。

work

class Employee {
    private String name;
    private String id;//
    private double salary;//工資

    public Employee() {        //空參構造
    }
    public Employee(String name,String id,double salary) {        //有參構造
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public void setName(String name) { //設置姓名
        this.name = name;
    }
    public String setName() {   //獲取姓名
        return name;
    }
    public void setId(String id) { //設置工號
        this.id = id;
    }
    public String setId() {   //獲取工號
        return id;
    }
    public void setSalary(double salary) { //設置工資
        this.salary= salary;
    }
    public double setSalary() {   //獲取工資
        return salary;
    }

    public void work() {  //獲取信息
        System.out.println("我的姓名是" + name + "，工號是" + id + "，工資是" + salary);
    }

}

class JavaObject {    
    public static void main(String [] args) {
        Employee e = new Employee("令狐沖","20000",40000);  //空參構造創建對象
            e.work();
    }
}

9.static關鍵字及內存圖(了解)

A:案例演示

通過一個案例引入static關鍵字。

人類：Person。每個人都有國籍，中國。

B:概念

方便在沒有創建對象的情況下來進行調用（方法/變量）。

static可以用來修飾類的成員方法、類的成員變量，另外可以編寫static代碼塊來優化程序性能。

class Person {
    String name;
    static String country;
    public void speak() {  //說話的方法
        System.out.println(name + "..." + country);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Person e = new Person();  //創建對象
            e.name = "張老師";    //調用姓名屬性并賦值
            e.country = "中國"; //調用國籍屬性并賦值
            e.speak();
        Person f = new Person();  //創建對象
            f.name = "李老師";    //調用姓名屬性并賦值
            //f.country = "中國"; //調用國籍屬性并賦值
            f.speak();
    }
}

static關鍵字的特點(掌握)

A:static關鍵字的特點

a:隨著類的加載而加載

b:優先于對象存在

c:被類的所有對象共享

舉例：咱們班級的學生應該共用同一個班級編號。

其實這個特點也是在告訴我們什么時候使用靜態?

如果某個成員變量是被所有對象共享的，那么它就應該定義為靜態的。

舉例：

飲水機(用靜態修飾)

水杯(不能用靜態修飾)

共性用靜態,特性用非靜態

d:可以通過類名調用

其實它本身也可以通過對象名調用。

推薦使用類名調用。

靜態修飾的內容一般我們稱其為：與類相關的，類成員

B:案例演示

static關鍵字的特點

class Person {
    String name;
    static String country;
    public void speak() {  //說話的方法
        System.out.println(name + "..." + country);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Person.country = "日本";  //靜態多了一種調用方式，可以通過類名。
            System.out.println(Person.country);
    }
}

static的注意事項(掌握)

A:static的注意事項

a:在靜態方法中是沒有this關鍵字的

如何理解呢?

靜態是隨著類的加載而加載，this是隨著對象的創建而存在。

靜態比對象先存在。

b:靜態方法只能訪問靜態的成員變量和靜態的成員方法

靜態方法：

成員變量：只能訪問靜態變量

成員方法：只能訪問靜態成員方法

非靜態方法：

成員變量：可以是靜態的，也可以是非靜態的

成員方法：可是是靜態的成員方法，也可以是非靜態的成員方法。

簡單記：

靜態只能訪問靜態。

B:案例演示

static的注意事項

class Demo {
    int num1 = 10;  //非靜態的成員變量
    static int num2 = 20;//靜態的成員變量

    //public void print1() {  //非靜態的成員方法，既可以訪問靜態的成員也可以訪問費靜態的成員
        //System.out.println(num1);
        //System.out.println(num2);
    //}

    public static void print2() {  //靜態的成員方法
        System.out.println(num1);  //靜態的成員方法不能訪問費靜態的 變量 num1
        System.out.println(num2);
    }
}
class JavaObject {    
    public static void main(String [] args) {
       // Demo d = new Demo();  //靜態多了一種調用方式，可以通過類名。
      //    d.print1();

        Demo.print2();
    }
}

靜態變量和成員變量的區別(掌握)

靜態變量也叫類變量成員變量也叫對象變量

A:所屬不同

靜態變量屬于類，所以也稱為為類變量

成員變量屬于對象，所以也稱為實例變量(對象變量)

B:內存中位置不同

靜態變量存儲于方法區的靜態區

成員變量存儲于堆內存

C:內存出現時間不同

靜態變量隨著類的加載而加載，隨著類的消失而消失

成員變量隨著對象的創建而存在，隨著對象的消失而消失

D:調用不同

靜態變量可以通過類名調用，也可以通過對象調用

成員變量只能通過對象名調用

main方法的格式詳細解釋(了解)

A:格式

public static void main(String[] args) {}

B:針對格式的解釋

public 被jvm調用，訪問權限足夠大。

static 被jvm調用，不用創建對象，直接類名訪問

void被jvm調用，不需要給jvm返回值

main 一個通用的名稱，雖然不是關鍵字，但是被jvm識別

String[] args 以前用于接收鍵盤錄入的

C:演示案例

通過args接收鍵盤例如數據

class JavaObject {    
    public static void main(String [] args) {
       /*
       public:被jvm調用，所以權限要足夠大
       static：被jvm調用，不需要創建對象，直接類名.調用即可
       void：被jvm調用不需要有任何的返回值。
       main：只有這樣寫才能被jvm識別，main不是關鍵字
       String [] args:以前是用來接收鍵盤錄入的
       */
       System.out.println(args.length);
       for (int i = 0;i < args.length ;i ++ ) {
           System.out.println(args[i])
       }
    }
}

工具類中使用靜態(了解)

A:制作一個工具類

ArrayTool

1,獲取最大值

2,數組的遍歷

3,數組的反轉

加static靜態化
如果一個類中所有的方法都是靜態的，需要多做一步，私有構造方法，
private ArrayTool(){}
目的是不讓其他類創建本類對象,直接用類名調用即可.

//文件ArrayTool.java

    class ArrayTool {
        public static int getMax(int[] arr) {
            int max = arr[0];   //記錄第一個元素
            for (int i= 1 ;i < arr.length ;i++) {//從第二個元素開始遍歷
                if (max < arr[i]) {//max與數組中其他的元素比較
                    max = arr[i];//記錄較大的
                }
            }
            return max;//將最大值返回
        }
        public static void print(int[] arr) {
            for (int i = 0;i < arr.length ; i++ ) { // 遍歷數組
                System.out.print(arr[i] + " ");
            }
        }
        public static void revArray(int[] arr) {
            for (int i = 0; i < arr.length / 2; i++) { //循環次數是元素個數的一半
                //arr[0]與arr[arr.length-1-0]交換
                int temp = arr[i];
                arr[i] = arr[arr.length-1-i];
                arr[arr.length-1-i] = temp;
            }
        }
    }

//文件Demo_ArrayTool.java

class Demo_ArrayTool {
    public static void main(String[] args) {
        int[] arr = {11,66,22,33,44,55,};
        /*
        非靜態的調用方法
        ArrayTool at = new ArrayTool();
        int max = at.getMax(arr);
        System.out.println(max);
        System.out.println("----------------");
        at.print(arr);
        System.out.println();
        System.out.println("----------------");
        System.out.println("反轉后");
        at.revArray(arr);
        at.print(arr);*/

        //靜態的調用方法
        ArrayTool.print(arr);
    }
}

說明書的制作過程(了解)

A:對工具類加入文檔注釋

B:通過javadoc命令生成說明書

@author(提取作者內容)

@version(提取版本內容)

javadoc -d 指定的文件目錄 -author -version ArrayTool.java

@param 參數名稱//形式參數的變量名稱@return 函數運行完返回的數據

/**
這是一個數組工具類，里面封裝了查找數組最大值，打印數組，數組反轉方法。
@author  zhengaidong
@version v1.0
*/

public class JavaObject {
    /**
    私有構造方法
    */
    private JavaObject(){
    }
    /**
    這是獲取數組中最大值得方法
    @param arr 接收一個int類型的數組
    @return 返回數組中的最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];   //記錄第一個元素
        for (int i= 1 ;i < arr.length ;i++) {//從第二個元素開始遍歷
            if (max < arr[i]) {//max與數組中其他的元素比較
                max = arr[i];//記錄較大的
            }
        }
        return max;//將最大值返回
    }

    /**
    這是遍歷數組的方法
    @param arr 接收一個int類型的數組
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ; i++ ) { // 遍歷數組
            System.out.print(arr[i] + " ");
        }
    }
    /**
    這是數組反轉的方法
    @param arr 接收一個int類型的數組
    */
    public static void revArray(int[] arr) {
        for (int i = 0; i < arr.length / 2; i++) { //循環次數是元素個數的一半
            //arr[0]與arr[arr.length-1-0]交換
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

如何使用JDK提供的幫助文檔(了解)

A:找到文檔，打開文檔

B:點擊顯示，找到索引，出現輸入框

C:你應該知道你找誰?舉例：Scanner

D:看這個類的結構(需不需要導包)

成員變量字段

構造方法構造方法

成員方法方法

學習Math類的隨機數功能(了解)

打開JDK提供的幫助文檔學習

A:Math類概述

類包含用于執行基本數學運算的方法

B:Math類特點

由于Math類在java.lang包下，所以不需要導包。

因為它的成員全部是靜態的,所以私有了構造方法

C:獲取隨機數的方法

public static double random():返回帶正號的 double 值，該值大于等于 0.0 且小于 1.0。

D:我要獲取一個1-100之間的隨機數，腫么辦?

int number = (int)(Math.random()*100)+1;

public class JavaObject {
    public static void main(String [] args) {
        //double d = Math.random();
        //System.out.println(d);
        //Math.random()會生成大于等于0.0并且小于1.0的偽隨機數

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

        //生成1到100的隨機數0.00000000000000-0.999999999999999
        //Math.random() * 100 ==>0.000000 - 99.9999999999
        //(int)(Math.random() * 32) ====> 0 - 99
        //(int)(Math.random() * 100) + 1

        for (int i = 0;i < 7 ;i++ ) {
            System.out.println((int)(Math.random() * 32) + 1);
        }
    }
}

猜數字小游戲案例(了解)

A:案例演示

需求：猜數字小游戲(數據在1-100之間)

import java.util.Scanner;
public class JavaObject {
    public static void main(String [] args) {
        Scanner sc = new Scanner(System.in);//創建鍵盤錄入對象
        System.out.println("請輸入一個整數，范圍在1-100之間");
        int guessNum = (int)(Math.random() * 100) + 1;//心理想的隨機數
        while (true) {
            int x = sc.nextInt();
            if (x > guessNum) {
                System.out.println("大了");
            } else if (x < guessNum) {
                System.out.println("小了");
            } else {
                System.out.println("中了");
                break;
            }
        } 
    }
}

云服務器 GPU云服務器 java面向對象基礎面向對象java編程 java面向對象編程面向對象編程

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/76913.html

Java編程基礎09——面向對象_代碼塊&amp;繼承&amp;方法&amp;final

摘要：每次調用構造都執行，并且在構造方法前執行靜態代碼塊在類中方法外出現，并加上修飾用于給類進行初始化，隨著類加載而加載，一般用來給類進行初始化，在加載的時候就執行，并且只執行一次。的構造方法這是一條隱藏語句，用來訪問父類中的空參構造。 1.代碼塊的概述和分類(了解)(實際不用） A:代碼塊概述在Java中，使用{}括起來的代碼被稱為代碼塊。 B:代碼塊分類根據其位置和聲明的不同...

LeviDing 2019-08-19 11:06 評論0 收藏0
Java編程基礎10——面向對象_多態&amp;抽象類&amp;接口

摘要：案例演示抽象類的成員特點抽象類的成員方法特性抽象方法強制要求子類做的事情。抽象類中定義的是該繼承體系的共性功能。 1.多態的概述及其成員訪問特點代碼體現 A:多態(polymorphic)概述事物存在的多種形態 B:多態前提- 1.要有繼承關系 2.要有方法重寫 3.要有父類引用指向子類對象。 C:多態中的成員訪問特點之成員變量：編譯和運行都看父類。成員方法：編...

dunizb 2019-08-19 11:05 評論0 收藏0
Java編程基礎11——面向對象_包&amp;權限修飾符&amp;匿名內部類

摘要：外部類要訪問內部類的成員，必須創建對象。前提存在一個類或者接口這里的類可以是具體類也可以是抽象類。 1.package關鍵字的概述及作用(了解) A:為什么要有包將字節碼(.class)進行分類存放包其實就是文件夾 B:包的概述舉例：學生：增加，刪除，修改，查詢老師：增加，刪除，修改，查詢 ... 方案1：按照功能分 com.heima.add ...

Bryan 2019-08-19 11:06 評論0 收藏0
Java編程基礎15——正則表達式&amp;常用工具類

摘要：正則表達式的概述和簡單使用正則表達式是指一個用來描述或者匹配一系列符合某個語法規則的字符串的單個字符串。例如，在表達式中，存在四個這樣的組組零始終代表整個表達式。 1_正則表達式的概述和簡單使用 A:正則表達式是指一個用來描述或者匹配一系列符合某個語法規則的字符串的單個字符串。其實就是一種規則。有自己特殊的應用。作用:比如注冊郵箱,郵箱有用戶名和密碼,一般會對其限制長度,這個...

miqt 2019-08-19 11:11 評論0 收藏0
SegmentFault 技術周刊 Vol.32 - 七夕將至，你的“對象”還好嗎？

摘要：很多情況下，通常一個人類，即創建了一個具體的對象。對象就是數據，對象本身不包含方法。類是相似對象的描述，稱為類的定義，是該類對象的藍圖或原型。在中，對象通過對類的實體化形成的對象。一類的對象抽取出來。注意中，對象一定是通過類的實例化來的。 showImg(https://segmentfault.com/img/bVTJ3H?w=900&h=385); 馬上就要到七夕了，離年底老媽老爸...

李昌杰 2019-08-16 10:40 評論0 收藏0