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

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

  • A:構造方法概述和做用java

    • 給對象的數據(屬性)進行初始化
  • 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:案例演示dom

    • 構造方法的重載
    • 重載:在同一類中,方法名相同,與返回值類型無關(構造方法沒有返回值),只看參數列表
    • 有參構造的好處:能夠動態的給屬性賦值
  • B:構造方法注意事項jvm

    • 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;
            }
        } 
    }
}
相關文章
相關標籤/搜索