黑馬程序員.bobo.DAY.6

Day-6

1.面向對象(static 關鍵字)

/*
靜態:static
用法:是一個修飾符,用於修飾成員(成員變量,成員函數),
當成員被靜態修飾後,就多了一個調用方式,除了能夠被對象調用外,能夠直接被類名調用,類名.靜態成員
 
static 特色:
1,隨着類的加載而加載.
也就是說:靜態會隨着類的消失而消失,說明它的生命週期最長.
2,優先於的對象存在
明確一點:靜態是先存在.對象是後存在的.
 
3,被全部對象所共享
4,能夠直接被類名所調用.
 
實例變量和類變量的區別:
1,存放位置.
實例類變量隨着類的加載而加載而存在於方法區中.隨着類消失而消
實例變量隨着對象的創建而存在於堆內存中.
2,生命週期:
類變量生命週期最長,隨着類的消失而消失.
實例變量生命週期隨着對象的消失而消失.
3,主函數是靜態的.
 
靜態使用注意事項:
1,靜態方法只能訪問靜態成員.
非靜態方法既能夠訪問靜態也能夠訪問非靜態.
2,靜態方法中不能夠定義this,super關鍵字.
由於靜態又相遇對象存在.因此靜態方法中不能夠出現this.
靜態有有利有弊
利處:對對象共享數據進行單獨空間的存儲,節省空間.沒有必要每個對象中都存儲一份.
能夠直接被類名調用.
弊端:生命週期過長.
訪問出現侷限性.(靜態雖好,只能訪問靜態.)
*/
class Person
{
String name;//成員變量,實例變量.
static String country = "CN";//靜態的成員變量,類變量.
public static void show()
{
System.out.println("::");
this.haha();
}
public void haha();
{}
}
class StaticDemo
{
public static void main(String[] args)
{
//Person p = new Person();
//p.name = "zhangsan";
//	p.show();
//System.out.println(p.name);
//System.out.println(Person.country);//新的調用方式 類名.靜態成員
Person.show();
}
}

 

2.面向對象(main關鍵字)

/*
public static void main(String[] args)
主函數:是一個特殊的函數.做爲程序的入口,能夠被JVM調用.
主函數的定義:
public:表明着該函數訪問權限是最大的.
static: 表明主函數隨着類的加載就已經存在了.
void: 主函數沒有具體的返回值.
main:不是關鍵字,可是是一個特殊的單詞,能夠被JVM識別.
(String[] arr):函數的參數:參數類型是一個數組,該數組中的元素是字符串,字符串類型的數組.
主函數是固定格式的:jvm識別.被虛擬機調用
jvm在調用主函數時,傳入的是new String[0];
*/
class MainDemo
{
public static void main(String[] args) // new String[]
{
String[] arr = {"haha","hehe","heihei","xixi","hiahia"};
MainTest.main(arr);
}
 
}
//String[] args = new String[3];
 
class MainTest
{
public static void main (String[] args)
{
for(int x = 0;x<args.length;x++)
System.out.println(args[x]);
}
}

3.面向對象(靜態何時使用)

/*
何時試用靜態?
要從兩方面下手:
由於靜態修飾的內容有成員變量和函數.
何時定義靜態變量(類變量);
當對象中的出現共享數據時,該數據被靜態修飾.
對象中的特有數據要定義成非靜態存在於堆內存中.
 
 
何時定義靜態的函數呢?
 
當功能內部沒有訪問到非靜態數據(對象的特有數據),
那麼該功能能夠定義靜態的.
*/
class Person
{
String name;
public static void show()
{
System.out.println("hah");
//若是加了name,好比System.out.println(name+"hah");這時,不能使用靜態
}
}
class
{
public static void main(String[] args)
{
//Person p = new Person();
//p.show();
Person.show();
}
}

4.面向對象(靜態的應用)

 

class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr = {3,1,87,32,9};
int max = ArrayTool.getMax(arr);
System.out.println("max="+max);
/*
ArrayTool tool = new ArrayTool();//當前目錄下有沒有這文件,有就進行編譯
int max = tool.getMax(arr);
System.out.println("max="+max);
int min=tool.getMin(arr);
System.out.println("Min="+min);
tool.printArray(arr);
tool.selectSort(arr);
tool.printArray(arr);
int [] arr1 = {};
ArrayTool tool1 = new ArrayTool();
*/
}
}

----------------------------------------------------------------------------------------------------------------------

 

/*
靜態的應用
 
每個應用程序中都有共性的功能,
能夠將這些功能進行抽取,獨立封裝.
以便複用.
雖然能夠經過創建ArrayTool的對象使用這些工具方法,對數組進行操做.
發現了問題:
1,對象是用於封裝數據的,但是ArrayTool對象並未封裝特有數據.
2,操做數組的每個方法都沒有用到ArrayTool對象中的特有數據
這時就考慮,讓程序更嚴謹,是不須要對象的.
能夠將ArrayTool中的方法都定義成static的.直接經過類名調用便可.
 
將方法都靜態後,能夠方便於使用,可是該類仍是能夠被其它程序簡歷對象的,爲了更爲嚴謹,強制讓該類不能創建對象.
能夠經過將構造函數私有化完成
*/
class ArrayTool
{
private ArrayTool(){}
public static int getMax(int[] arr)
{
int max = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
public static void bubbleSort(int[] arr)
{
for(int x= 0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
/*
class Demo
{
public static void main(String[] args)
{
int[] arr = {3,4,1,8};
int max = getMax(arr);
System.out.println("max="+arr[max]);
}
public static int getMax(int[] arr)
{
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
}
class Test
{
 
}
class ArrayTool
{
public static void main(String[] args)
{
}
}
*/

 

5.面向對象(幫助文檔的製做)

cmd 輸入 javadoc -d myclass -author -version ArrayTool.java

/*
靜態的應用
 
每個應用程序中都有共性的功能,
能夠將這些功能進行抽取,獨立封裝.
以便複用.
雖然能夠經過創建ArrayTool的對象使用這些工具方法,對數組進行操做.
發現了問題:
1,對象是用於封裝數據的,但是ArrayTool對象並未封裝特有數據.
2,操做數組的每個方法都沒有用到ArrayTool對象中的特有數據
這時就考慮,讓程序更嚴謹,是不須要對象的.
能夠將ArrayTool中的方法都定義成static的.直接經過類名調用便可.
 
將方法都靜態後,能夠方便於使用,可是該類仍是能夠被其它程序簡歷對象的,爲了更爲嚴謹,強制讓該類不能創建對象.
能夠經過將構造函數私有化完成
 
接下來,將ArrayTool.class文件發送給其它人,其它人只要將該文件設置到classpath路徑下,就可使用該工具類.
可是,很遺憾,該類中到底定義了多少方法,對方不清楚,由於該類並無使用說明書.
 
開始製做程序的說明書.Java的說明書經過文檔註釋來完成.
*/
/**
這是一個能夠對數組進行操做的工具類,該類中提供了,獲取最值,排序等功能.
@author 劉雲博
@version v1.1
*/
public class ArrayTool
{
/**
空參數構造函數.
*/
private ArrayTool(){}
/**
獲取一個整型數組中的最大值.
@param arr 接收一個int類型的數組.
@return 會返回一個該數組中的最大值.
*/
public static int getMax(int[] arr)
{
int max = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]>arr[max])
max=x;
}
return arr[max];
}
/**
獲取一個整型數組中的最小值.
@param arr 接收一個int類型的數組.
@return 會返回一個該數組中的最值.
*/
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
/**
給int數組進行選擇排序
@param arr 接收一個int類型的數組.
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
swap(arr,x,y);
}
}
}
}
/**
給int數組進行冒泡排序
@param arr 接收一個int類型的數組.
*/
public static void bubbleSort(int[] arr)
{
for(int x= 0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
{
swap(arr,y,y+1);
}
}
}
}
/**
給數組中元素進行位置的置換.
@param arr 接收一個int類型的數組
@param a 要置換的位置
@param b 要置換的位置
*/
private static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
用於打印數組中的元素.打印形式是:[elemet1,elemet2,...]
@param arr 接收一個int類型的數組
*/
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}
 
/*
一個類中默認會有一個空參數的構造函數,
這個默認的構造函數的權限和所屬類一致,
若是類被public修飾,那麼默認的構造函數也帶public修飾符.
若是類沒有被public修飾,那麼默認的構造函數,也沒有public修飾.
默認夠早函數的權限是隨着類的變化而變化的.
*/

6.面向對象(靜態代碼塊)

/*
靜態代碼塊
格式:
static
{
靜態代碼塊中的執行語句.
}
特色:隨着類的加載而執行,只執行一次.並優先於主函數
用於給類進行初始化的.
*/
class StaticCode
{
int num = 9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");
}
{
System.out.println("c"+this.num);
}
StaticCode(int x)
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
//System.out.println("b");
}
public static void main(String[] args)
{
new StaticCode(4); //a c d
//new Static();
//new Static();
//System.out.println("over");
//StaticCode.show();
//StaticCode s = null;
//s = new StaticCode();
//StaticCode.show();
}
static
{
//System.out.println("c");
}
}
//d:\javabobo\day06>java StaticCodeDemo
//b c a over

 

7.面向對象(對象的初始化過程)

class Person
{
private String name = "hah";
private int age;
private static String country = "cn";
Person(String name,int age)
{
this.name = name;
this.age = age;
}
{
System.out.println(name+".."+age);
}
public void setName(String name)
{
this.name = name;
}
public void speak()
{
System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
System.out.println("country="+country);
}
}
class	PersonDemo
{
public static void main(String[] args)
{
Person p = new Person("zhangsan",20);
}
}
/*
Person p = new Person("zhangsan",20);
這句話都作了什麼事情?
1,由於new用到了Person.class,因此先找到Person.class文件並加載到內存中
2,執行該類中的Static代碼塊,若是有的話,給Person.class類進行初始化.
3,在堆內存中開闢空間,分配內存地址.
4,在堆內存中創建對象的特有屬性.並進行默認初始化.
5,對屬性進行顯示初始化.
6,對對象進行構造代碼塊化
7,對對象進行對應的構造函數初始化.
8,將內存地址付給棧內存中的p變量.
 
*/

 

8.面向對象(對象調用成員過程)

9.面向對象(單例設計模式)

/*
設計模式:解決某一類問題最行之有效的方法
Java中23種設計模式:
單例設計模式:解決一個類在內存中只存在一個對象.
 
想要保證對象惟一.
1,爲了不其它程序程序過多創建該類對象.先禁止其它進制其它程序創建該類對象
2,還爲了讓其它程序能夠訪問到給類對象,只好在本類中,自定義一個對象.
3,爲了方便其它程序對自定義對象的訪問,能夠對外提供一些訪問方式.
 
這三步怎麼用代碼提現呢?
1,將構造函數私有化.
2,在類中建立一個本類對象.
3,提供一個方法能夠獲取到該對象.
 
對於事物該怎麼描述,還怎麼描述
當須要將該事物的對象保證在內存中惟一時,就將以上的三步加上便可.
*/
class Single
{
private int num;
public void setNum(int num)
{
this.num = num;
}
public int getNum()
{
return num;
}
private Single(){}
private static Single s = new Single();
public static Single getInstance()
{
return s;
}
}
 
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
s1.setNum(23);
System.out.println(s2.getNum());
// Single s1 = new Single();
// Single s2 = new Single();
// s1.setNum(30);
// System.out.println(s2.getNum());
// Student s1 = new Student();
// s1.getAge(30);
// Student s2 = new Student();
// s2.getAge(12);
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
}
 
}
class Student
{
private int age;
private static Student s = new Student();
private Student(){}
public static Student getStudent()
{
return s;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
}

 

10.面向對象(單例設計模式方式二)

/* 
這個先初始化對象.
稱爲:餓漢式.
Single一進內存就建立好了對象
class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
 */
 //對象是方法被調用時,才初始化,也叫作對象的延時加載.成爲:懶漢式.
//Single類進內存,對象還有存在,只有調用了getInstance方法時,才簡歷對象
 class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}
//記錄原則:定義單例:建議使用餓漢式
class SingleDemo2
{
public static void main(String[] args)
{
System.out.println();
}
}

添加好友

小額贊助

微信	支付寶