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;
}
}
}
}
相關文章
- 1. C++ static 靜態類對象構造
- 2. python基礎（面向對象設計（靜態方法、類方法））
- 3. Java 面向對象之構造方法
- 4. Java基礎 - 面向對象 - 構造方法
- 5. JAVA語言基礎-面向對象(構造方法)
- 6. java基礎-12.1 面向對象（構造方法、this）
- 7. JAVA基礎--面向對象08
- 8. Python 面向對象編程OOP (三) 類方法，靜態方法
- 9. Java 基礎08-OOP面向對象編程
- 10. Java 靜態對象 static
- 更多相關文章...
- • PHP 面向對象 - PHP教程
- • Lua 面向對象 - Lua 教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
- • Java 8 Stream 教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
