1、面向對象概念
面向對象是一種思想，可以讓複雜的問題簡單化，可以讓程序員的角色從執行者轉變爲指揮者。
***可以想幾個面向對象在生活中的例子（面試經常會問到面向對象的思想？）
面向過程強調的是功能行爲，而面向對象是將功能封裝進對象，強調的是具備了功能的對象。
2、面向對象特徵：封裝，繼承，多態。
開發：找對象，建立對象，使用對象。維護對象的關係。
3、類和對象的關係
類：就是對現實生活中事物的描述，是對具體事物的抽象。即提取對象中的共性內容。映射到java中就是class定義的類。
對象：就是這類事物實實在在存在的個體。映射到java中就是用new建立的實體。
生活中描述事物無非就是描述事物的屬性和行爲。如：人有身高、體重等屬性，有說話、學習等行爲。
屬性：對應類中的變量。
行爲：對應類中的函數（方法）。
定義類：就是在描述事物， 就是在定義屬性和行爲。屬性和行爲共同成爲類中的成員（即成員變量和成員函數）。
4、成員變量和局部變量的區別
作用範圍
成員變量：作用於整個類中
局部變量：作用於函數中，或者語句中。
存儲位置
成員變量：存在於堆內存中，因爲對象的存在，纔在內存中存在。
局部變量：存在棧內存中。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Car
{
//描述顏色
String color = "red";
//描述輪胎數
int num = 4;
//運行行爲
void run()
{
System.out.println(color+"..."+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//生產汽車。在java中通過new操作符來完成。
//其實就是在堆內存產生一個實體。
Car c = new Car();//c就是一個類類型變量。記住：類類型變量指向對象。
//需求：將已有車的顏色改成藍色。指揮該對象做事情。在java中指揮方式是:對象.對象成員
c.color = "blue";
c.run();
Car c1 = new Car();
c1.run();
}
}</span></span>運行結果：
5、對象在內存中的存儲：
棧內存：用於存儲局部變量，當數據使用完，所佔空間會自動釋放。局部變量沒有默認初始化值，不初始化是不可以參與運算的。
堆內存：用於存儲通過new建立的實體（數組和對象），每一個實體都有內存地址值，且實體中的變量都有默認初始化值，當實體不再被使用，虛擬機會在不確定的時間回收垃圾。
棧內存 堆內存
6、匿名對象
格式：new Xxx().xxx；
匿名對象使用方式一：當對象的方法只調用一次時，可以用匿名對象來完成。這樣寫比較簡化。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class CarDemo
{
public static void main(String[] args)
{
new Car().num = 5;
new Car().color = "blue";
new Car().run();
}
}</span></span>匿名對象在內存中的存儲：
***當沒有變量指向對象時，堆內存中的對象就會變成垃圾，由虛擬機不定時回收，若想對象變垃圾可以自己指定：x=null;
匿名對象使用方式二：可以將匿名對象作爲實際參數進行傳遞。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class CarDemo
{
public static void main(String[] args)
{
Car q = new Car(); //可以直接將匿名對象作爲實際參數進行傳遞
show(q); // show(new Car())；
}
public static void show(Car c)
{
c.num = 3;
c.color = "black";
c.run();
}
}</span></span>7、封裝概述
封裝：指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
封裝原則：把屬性都隱藏，提供公共方法對其訪問。對私有變量一般都提供setxxx及getxxx兩個函數。
java中函數是最小的封裝體，類，包，框架。
private 關鍵字
private：私有，權限修飾符：用於修飾類中的成員（成員變量，成員函數）。私有隻在本類中有效。
注意：私有僅僅是封裝的一種表現形式。
之所以對外提供訪問方式，就因爲可以在訪問方式加入邏輯判斷等語句，對訪問數據進行操作，提高代碼健壯性。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person
{
private int age;
public void setAge(int a)
{
if (a>0 && a<130)
{
age =a;
}
else
System.out.println("illegal age");
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("age:"+age);
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
System.out.println(p.getAge());
p.setAge(20);
System.out.println(p.getAge());
p.speak();
}
}</span></span>8、構造函數：與類名同名，無返回值類型，無return語句。
構造函數的作用：可以用於給對象初始化。
對象一建立就會調用與之對應的構造函數。構造函數可以重載，用於給對應的對象進行初始化。
當一個類中沒有定義構造函數時，那麼系統會默認給該類加一個空參數的構造函數。如果在類中定義了指定的構造函數，那麼類中的默認構造函數就沒有了。
構造函數與一般函數的區別：
構造函數：對象一建立就運行。給對象初始化。一個對象建立，構造函數只運行一次。
一般函數：對象調用時才執行。給對象添加對象具備的功能。一般函數可以被對象調用多次。
9、構造代碼塊：定義的是不同對象共性的初始化內容。給所有對象進行統一初始化。對象一建立就執行，且優於構造函數執行。
***開發一般不用，面試可能會問到構造函數執行順序。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person
{
private String name;
private int age;
public void setName(String n)
{
name = n;
}
public String getName()
{
return name;
}
public void setAge(int a)
{
if (a>0 && a<130)
{
age =a;
}
else
System.out.println("illegal age");
}
public int getAge()
{
return age;
}
{
cry();//構造代碼塊
}
Person()
{
System.out.println("A:name="+name+"---age="+age);
}
Person(String n)
{
name = n;
System.out.println("A:name="+name+"---age="+age);
}
Person(String n ,int a)
{
name = n;
age = a;
System.out.println("A:name="+name+"---age="+age);
}
public void cry()
{
System.out.println("cty.....");
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person p = new Person();
p.setName("mss");
p.setAge(13);
System.out.println("name="+p.getName()+";age="+p.getAge());
Person p1 = new Person("mashasha");
p1.setName("mashashagai");
p1.setAge(23);
System.out.println("name="+p1.getName()+";age="+p1.getAge());
Person p2 = new Person("mashasha",22);
}
}</span></span>運行結果：
10、this關鍵字
this：代表它所在函數所屬對象的引用。簡單說：哪個對象在調用this所在的函數，this就代表哪個對象。
類中的變量及函數其實都省略了this.
this的應用：
（1）用於區分局部變量和成員變量同名的情況。
（2）當定義類中功能時，該函數內部要用到調用該函數的對象時，這時用this來表示這個對象。（但凡本類功能內部使用到了本類對象，都用this表示）.
（3）用於構造函數之間進行相互調用。注意：this語句只能定義在構造函數的第一行。因爲初始化要先執行。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Person
{
private String name;
private int age;
Person(String name)
{
this.name = name;//出現同名變量，將成員變量省略的this.顯示的寫出來。
}
Person(String name ,int age)
{
this（）;//用於構造函數之間進行相互調用
this.age = age;
}
public void speak()
{
System.out.println("My name is "+name+" . I am "+age+" years old .");
//成員變量省略了this.
//也可以寫成System.out.println("My name is "+this.name+" . I am "+this.age+" years old .");
show();
//成員函數省略了this.
//也可以寫成this.show();
}
public void show()
{
System.out.println("name="+name+"---age="+age);
}
/*
需求：給人定義一個功能用於比較年齡是否相同，也就是是否爲同齡人。
*/
public boolean compare(Person p)
{
return this.age==p.age;//本類功能使用本類對象
}
}
class PersonDemo3
{
public static void main(String[] args)
{
Person p = new Person("mss",20);
Person p1 = new Person("mashasha",20);
p.speak();
p1.speak();
boolean b = p.compare(p1);
System.out.println(b);
}
}</span></span>運行結果：
11、static關鍵字
用法：是一個修飾符，用於修飾成員（成員變量，成員函數）。
當成員被static修飾後，就多了一個調用方式，除了可以被對象調用外，還可以直接被類名調用。類名.靜態成員。
特點：
（1）隨着類的加載而加載。也就是說：靜態會隨着類的消失而消失。說明它的生命週期最長。
（2）優先於對象存在。
（3）被所有對象所共享。
（4）可以直接被類名所調用。
實例變量和類變量的區別
存放位置
類變量隨着類的加載而存在於方法區中。
實例變量隨着對象的建立而存在於堆內存中。
生命週期
類變量生命週期最長，隨着類的消失而消失。
實例變量生命週期隨着對象的消失而消失。
靜態的使用注意事項：
（1）靜態方法只能訪問靜態成員（靜態成員變量和靜態成員函數）
非靜態方法即可以訪問靜態也可以訪問非靜態。
（2）靜態方法中不可以定義this，super關鍵字。
因爲靜態優先於對象存在。
（3）主函數是靜態的。
靜態有利有弊
利處：對對象的共享數據進行單獨空間的存儲，節省空間。沒有必要每一個對象中都存儲一份。
可以直接被類名調用。
弊端：生命週期過長。
訪問出現侷限性。（靜態只能訪問靜態）
什麼時候使用靜態？
要從兩方面下手:
因爲靜態修飾的內容有成員變量和成員函數。
什麼時候定義靜態變量（類變量）呢？
當對象中出現共享數據時，該數據被靜態所修飾。
例：定義一個Person類，成員變量包括姓名和國籍，國籍都爲中國，就可以將國籍靜態。
對象中的特有數據要定義成非靜態存在於堆內存中。
什麼時候定義靜態函數呢?
當功能內部沒有訪問到非靜態數據（對象特有的數據），那麼該功能可以定義成靜態的。
例：工具類
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">//java的說明書通過文檔註釋來完成。
/**
這是一個可以對數組進行操作的工具類，該類中提供了，獲取最值，排序等功能。
@author mashasha
@version V1.1
*/
class ArrayTool
{
private ArrayTool(){}//構造函數私有化，強制該類不能建立對象，防止內存中產生一些沒有用的對象。
/**
獲取一個整形數組中的最大值。
@param arr 接受一個int類型的數組。
@return 會返回一個該數組中的最大值。
*/
public static int getMax(int[] arr)
{
int max = 0;
for (int i=1; i<arr.length; i++ )
{
if(arr[i]>arr[max])
max = i;
}
return arr[max];
}
/**
獲取一個整形數組中的最小值。
@param arr 接受一個int類型的數組。
@return 會返回一個該數組中的最小值。
*/
public static int getMin(int[] arr)
{
int min = 0;
for (int i=1; i<arr.length; i++ )
{
if(arr[i]<arr[min])
min = i;
}
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);
}
}
}
}
/**
給int數組中的元素進行位置置換。
@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;
}
/**
用於打印數組中的元素。
@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 class ArrayToolDemo
{
public static void main(String[] args)
{
int[] arr = {3,4,8,43,22,77,23,576};
//ArrayTool tool = new ArrayTool();
int max = ArrayTool.getMax(arr);
System.out.println("max="+max);
int min = ArrayTool.getMin(arr);
System.out.println("min="+min);
ArrayTool.printArray(arr);
ArrayTool.selectSort(arr);
ArrayTool.printArray(arr);
}</span></span>運行結果：
幫助文檔的製作。用幫助文檔註釋，用javadoc.exe提取即可。javadoc.exe只能提取public修飾的類。
運行結果：
會自動生成很多文件，查看index索引即可
12、靜態代碼塊
格式：
static
{
靜態代碼塊中執行的語句。
}
特點：隨着類的加載而執行，只執行一次。
作用：用於給類進行初始化。
***要知道執行順序。考試會考。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class StaticCode
{
StaticCode()
{
System.out.println("a");
}
//靜態代碼塊，給類進行初始化。
static
{
System.out.println("b");
}
//構造代碼塊，給對象進行初始化。
{
System.out.println("c");
}
//構造函數，給對應對象進行初始化。
StaticCode(int x)
{
System.out.println("d");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);
}
}</span></span>打印結果爲bcd.
13、對象初始化的過程。
例：Person p = new Person("mashasha",20);
該句話都做了什麼事？
1、因爲new用到了Person.class，所以會先找到Person.class文件並加載到內存中。
2、執行該類中的static代碼塊，如果有的話，給Person.class類進行初始化。
3、在堆內存中開闢空間，分配內存地址。
4、在堆內存中建立對象的特有屬性。並進行默認初始化。
5、對屬性進行顯示初始化。
6、對對象進行構造代碼塊初始化。
7、對對象進行對應的構造函數初始化。
8、將內存地址賦給棧內存中的P變量。
14、設計模式：解決某一類問題最行之有效的方法。
java中有23種設計模式。
單例設計模式：解決一個類在內存中只存在一個對象。
例：程序A、B都要用到同一個配置文件。這個配置文件就是這個類中存在的唯一一個對象。
分析：想要保證對象唯一。
1、爲了避免其他程序過多建立該類對象。先禁止其他程序建立該類對象。
2、爲了讓其他程序可以訪問到該類對象，只好在本類中，自定義一個對象。
3、爲了方便其他程序對自定義對象的訪問，可以對外提供一些訪問方式。
方法：
1、將構造函數私有化。
2、在本類中創建一個本類對象。
3、提供一個方法可以獲取到該對象。
方法一：
餓漢式：先初始化對象。single類一進內存，就已經創建好了對象。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Single
{
private Single(){} //將構造函數私有化。
private static Single s = new Single(); //在本類中創建一個本類對象。
public static Single getInstance() //提供一個方法可以獲取到該對象。
{
return s;
}
}</span></span>方法二：
懶漢式：對象在方法被調用時才初始化，對象延時加載。Single類進內存，對象還未存在，只有調用getInstance方法時，才建立對象。
例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">class Single
{
private Single(){} //將構造函數私有化。
private static Single s = null； //在本類中創建一個本類對象。
public static Single getInstance() //提供一個方法可以獲取到該對象。
{
if（s==null）
s = new Single(); //對象延時加載。
return s;
}
}</span></span>