07-Java面向對象構造方法,static關鍵字,main方法,說明書,math隨機數

構造方法

構造方法的概述和作用

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

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

        Person p2 = new Person();               
        //再次創建對象

        p2.show();
    }
}

/*
* A:構造方法概述和作用
    * 給對象的數據(屬性)進行初始化
* B:構造方法格式特點
    * a:方法名與類名相同(大小也要與類名一致)
    * b:沒有返回值類型，連void都沒有
    * c:沒有具體的返回值return;
*/

class Person {
    private String name;
    private int age;

    //構造方法
    public Person() {
        //System.out.println("Hello World!");
        //return;                               //構造方法也是有return語句的,格式是return;
        name = "張三";
        age = 23;
    }

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

構造方法格式的特點

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

沒有返回值類型,連void都沒有

沒有具體的返回值return

• 構造方法不能用對象調用
• 構造方法也是有return語句的,格式是return;

構造方法的重載及注意事項

案例演示

class Demo2_Person {
    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();
    }
}
/*
* A:案例演示
    * 構造方法的重載
    * 重載:方法名相同,與返回值類型無關(構造方法沒有返回值),只看參數列表
* B:構造方法注意事項
    * a:如果我們沒有給出構造方法，系統將自動提供一個無參構造方法。
    * b:如果我們給出了構造方法，系統將不再提供默認的無參構造方法。
        * 注意：這個時候，如果我們還想使用無參構造方法，就必須自己給出。建議永遠自己給出無參構造方法

*/
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);
    }
}

構造方法重載注意事項

• 如果沒有給出構造方法,系統將自動提供一個無參的構造方法
• 如果我們給出了構造方法,系統將不再提供默認的無參構造方法
  
  • 注意 這時候我們還想使用無參構造方法,就必須自己給出.建議永遠自己給出無參的構造方法

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

setXxx()方法

• 修改屬性值

構造方法

• 給對象中屬性進行初始化
  

  這兩種方式,setXxx在開發中使用更多一些,因爲比較靈活

class Demo3_Person {
    public static void main(String[] args) {
        Person p1 = new Person("張三",23);
        //p1 = new Person("張天一",23);    
        //這種方式看運行結果貌似是改名了,其實是將原
        對象變成垃圾
        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());
    }
}
/*
構造方法
    給屬性進行初始化
setXxx方法
    修改屬性值
    這兩種方式,在開發中用setXxx更多一些,因爲比較靈活
*/
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;
    }
}

學生類

class Demo4_Student {
    public static void main(String[] args) {
        Student s1 = new Student();                 //使用空參構造
        s1.setName("張三");                           //設置姓名
        s1.setAge(23);                              //設置年齡

        System.out.println("我的姓名是:" + s1.getName() + ",我的年齡是:" + s1.getAge());
        //getXxx()獲取屬性值,可以打印,也可以賦值給其他的變量,做其他的操作
        Student s2 = new Student("李四",24);
        s2.show();                                  //只是爲了顯示屬性值
    }
}
/*
* A:案例演示
    * 學生類：
        * 成員變量：
            * name，age
        * 構造方法：
            * 無參，帶兩個參
        * 成員方法：
            * getXxx()/setXxx()
            * show()：輸出該類的所有成員變量值
* B:給成員變量賦值：
    * a:setXxx()方法
    * b:構造方法

* C:輸出成員變量值的方式：
    * a:通過getXxx()分別獲取然後拼接
    * b:通過調用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);
    }
}

手機類

class Demo5_Phone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setBrand("蘋果");
        p1.setPrice(1500);
        System.out.println(p1.getBrand() + "..." + p1.getPrice());

        Phone p2 = new Phone("小米",98);
        p2.show();
    }
}
/*
手機類:
    成員變量:
        品牌brand,價格price
    構造方法
        無參,有參
    成員方法
        setXxx和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);
    }
}

創建一個對象的步驟

• Student.class加載進內存
• 聲明一個Student類型引用s
• 在堆內存創建對象
• 給對象中屬性默認初始化值
• 屬性進行顯示初始化
• 構造方法進棧,對對象中的屬性賦值,構造方法彈棧
• 將對性的地址值賦值給s

class Demo1_Student {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

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

    public Student() {
        name = "李四";
        age = 24;
    }

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

長方形

class Test1_Rectangle {                         //Rectangle矩形
    public static void main(String[] args) {
        Rectangle r = new Rectangle(10,20);
        System.out.println(r.getLength());      //周長
        System.out.println(r.getArea());        //面積
    }
}
/*
* A:案例演示
    * 需求：
        * 定義一個長方形類,定義 求周長和麪積的方法，
        * 然後定義一個測試類進行測試。
    分析:
        成員變量:
            寬width,高high
        空參有參構造
        成員方法:
            setXxx和getXxx
            求周長:getLength()
            求面積:getArea()
*/
class Rectangle {
    private int width;              //寬
    private int high;               //高

    public Rectangle(){}            //空參構造

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

    public void setWidth(int width) {//設置寬
        this.width = width;
    }

    public int getWidth() {         //獲取寬
        return width;
    }

    public void setHigh(int high) { //設置高
        this.high = high;
    }

    public int getHigh() {          //獲取高
        return high;
    }

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

    public int getArea() {          //獲取面積
        return width * high;
    }
}

員工類

class Test2_Employee {                      //employee員工
    public static void main(String[] args) {
        Employee e = new Employee("令狐沖","9527",20000);
        e.work();
    }
}
/*
* 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 getName() {               //獲取姓名
        return name;
    }

    public void setId(String id) {          //設置id
        this.id = id;
    }

    public String getId() {                 //獲取id
        return id;
    }

    public void setSalary(double salary) {  //設置工資
        this.salary = salary;
    }

    public double getSalary() {             //獲取工資
        return salary;
    }

    public void work() {
        System.out.println("我的姓名是:" + name + ",我的工號是:" + id + ",我的工資是:" + salary 
            + ",我的工作內容是敲代碼");
    }
}

static關鍵字及內存圖

案例演示

• 通過案例引入static關鍵字(國籍 日本)

class Demo1_Static {
    public static void main(String[] args) {
        /*Person p1 = new Person(); //創建對象
        p1.name = "蒼老師";            //調用姓名屬性並賦值
        p1.country = "日本";      //調用國籍屬性並賦值


        Person p2 = new Person();
        p2.name = "小澤老師";       //調用姓名屬性並賦值
        //p2.country = "日本";        //調用國籍屬性並賦值

        p1.speak();
        p2.speak();*/

        Person.country = "日本";  //靜態多了一種調用方式,可以通過類名.
        System.out.println(Person.country);
    }
}

class Person {
    String name;                    //姓名
    static String country;                  //國籍

    public void speak() {           //說話的方法
        System.out.println(name + "..." + country);
    }
}

static關鍵字的特點

隨着類的加載而加載

優先於對象存在

被類的所有對象共享

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

靜態多了一種調用方式,可以用 (類名.) 調用

static的注意事項

class Demo2_Static {
    public static void main(String[] args) {
        //Demo d = new Demo();
        //d.print1();

        Demo.print2();
    }
}

/*
* A:static的注意事項
    * a:在靜態方法中是沒有this關鍵字的
        * 如何理解呢?
            * 靜態是隨着類的加載而加載，this是隨着對象的創建而存在。
            * 靜態比對象先存在。
    * b:靜態方法只能訪問靜態的成員變量和靜態的成員方法
        * 靜態方法：
            * 成員變量：只能訪問靜態變量
            * 成員方法：只能訪問靜態成員方法
        * 非靜態方法：
            * 成員變量：可以是靜態的，也可以是非靜態的
            * 成員方法：可是是靜態的成員方法，也可以是非靜態的成員方法。
        * 簡單記：
            * 靜態只能訪問靜態。
*/

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(this.num1);
        //靜態的成員方法不能訪問非靜態的,
        //錯誤: 無法從靜態上下文中引用非靜態 變量 num1
        System.out.println(num2);
    }
}

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

• 靜態是隨着類的加載而加載,this是隨着對象的創建而存在
• 靜態比對象先存在

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

• 靜態方法
  
  • 成員變量:只能訪問靜態變量
  • 成員方法:只能訪問靜態成員方法
• 非靜態方法
  
  • 成員變量:可以使靜態的,也可以是非靜態的
  • 成員方法:可以使靜態陳元方法,也可以是非靜態成員方法
    

    總結一句話:靜態只能訪問靜態;非靜態即可訪問靜態又可訪問非靜態

class Demo3_Static {
    public static void main(String[] args) {

        /*method();  錯誤: 無法從靜態上下文中引用非靜態 
        方法 method()*/

        Demo3_Static.print();                   
        //在主方法中調用本類的靜態方法,可以省略類名.,系統會默認加上
        Demo3_Static d = new Demo3_Static();    
        //非靜態方法在調用的時候必須創建對象調用
        d.method();
    }

    public void method() {                  
        System.out.println("Hello World!");     
    }

    public static void print() {
        System.out.println("Hello World!");
    }
}

靜態變量和成員變量的區別

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

所屬不同

• 靜態變量屬於類,所以也成爲類變量
• 成員變量屬於對向,所以也叫實例變量(對象變量)

內存中的位置不同

• 靜態變量儲存與方法區的靜態區
• 成員變量儲存於堆內存

出現時間不同

• 靜態變量隨着類的加載而加載,隨着類的消失而消失
• 成員變量隨着對象的創建而存在,隨着對象的消失而消失

調用不同

• 靜態變量可以通過類名調用,也可通過對象調用
• 成員變量只能通過對象名調用

main方法的格式詳細解釋

main方法的格式

• public static void main(String[] args){}
• public 被jvm調用,訪問權限足夠大
• static 被jvm調用,不同創建對象,直接類名訪問
• void 被jvm調用,不需要給jvm返回值
• main 一個通用的名稱,雖然不是關鍵字,但是被jvm識別
• String[] args 以前用於接受鍵盤錄入

class Demo3_Main {
    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]);
        }
    }
}

==創建對象內存圖==

==靜態內存圖==

工具類中使用靜態

製作一個工具類(static)

• ArrayTool
• 獲取最大值
• 數組遍歷
• 數組反轉

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

class ArrayTool{
    /**
    私有構造方法(沒有意義的註釋,私有內容不會體現)
    */
    private ArrayTool(){}
    /**
    這是獲取數組中最大值的方法
    @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=arr[i];
            }
        }
        return max;
    }
    /**
    這是遍歷數組的方法
    @param arr 接受一個int類型的數組
    */
    public static void print(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]+" ")
        }
    }
    /**
    這是遍歷數組的方法
    @param arr 接受一個int類型的數組
    */
    public static void revArray(int[] arr){
        for(int i=0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i]=arr[length-1-i];
            arr[length-1-i]=temp;
        }
    }
}

如果一個類中所有方法都是靜態的,需要將構造方法私有,目的是不讓其他類創建本類對象

製作文檔說明書

對工具類加入文檔註釋

/**
這是一個數組工具類,裏面封裝了查找數組最大值,打印數組,數組反轉的方法
@author fengjia
@version v1.0
*/
public class ArrayTool {
    //如果一個類中所有的方法都是靜態的,需要再多做一步,私有構造方法,目的是不讓其他類創建本類對象
    //直接用類名.調用即可
    /**
    私有構造方法
    */
    private ArrayTool(){}

    //1,獲取最大值

    /**
    這是獲取數組中最大值的方法
    @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;                             
        //將最大值返回
    }
    //2,數組的遍歷
    /**
    這是遍歷數組的方法
    @param arr 接收一個int類型數組
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ;i++ ) {  
        //遍歷數組
            System.out.print(arr[i] + " ");
        }
    }
    //3,數組的反轉
    /**
    這是數組反轉的方法
    @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]  交換
            arr[1]與arr[arr.length-1-1]  交換
            arr[2]與arr[arr.length-1-2] 交換
            */
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

通過javadoc命令生成說明書

@author 提取作者內容

@version 提取版本內容

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

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

==生成文檔說明書要有修飾符public==

生成文檔的操作(dos下): javadoc -d api -version -author ArrayTool.java

Math類的隨機數功能

Math類的概述

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

Math類的特點

• 由於Math類在java.long包下,所以不需要導包
• 因爲他的成員全部都是靜態的,所以私有了構造方法

獲取隨機數的方法

• public static double random();

class Demo2_Math {
    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的隨機數
        //Math.random()0.0000000 - 0.999999999
        //Math.random() * 100 ====> 0.00000 - 99.999999999
        //(int)(Math.random() * 100) ====> 0 - 99
        //(int)(Math.random() * 100) + 1

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

返回帶正號的double值,改值大於等於0.0且小於1.0
*

猜數字小遊戲(數據在1-100之間)

import java.util.Scanner;
class Test1_GuessNum{
    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 result=sc.nexrInt();
            if(result>guessNum){
                System.out.print("大了");
            }else if(result<guessNum){
                System.out.print("小了");
            }else{
                System.out.print("中了");
                break;
            }
        }
    }
}