1、什麼叫面向對象？
面向對象(Object-Oriented，簡稱OO)就是一種常見的程序結構設計方法。面向對象思想的基礎是將相關的數據和方法放在一起，組合成一種新的複合數據類型，然後使用新創建的複合數據類型作爲項目的基礎。
面向對象是一個很抽象的概念，它相對面向過程而言。過程與對象都是一種解決問題的思想。
面向過程：強調的是功能行爲,一種過程,先幹啥,再幹啥;
面向對象：將功能封裝到對象裏，強調的是具備某功能的對象;
按照面向對象的思想，可以把任何的東西看做對象！
面向對象的三個特徵：
封裝(Encapsulation);
繼承(Inheritance);
多態(Polymorphism)。
package com.laobi.day06;
public class DuiXiang {
/**
* 面向對象：對於面向對象思想，強調的是對象（實體）
* C++、Java、C＃
*
*
* 面向過程：對於面向過程思想，強調的是過程（動作）
* 例子：大象裝進冰箱
* C語言
*
* 面向對象的特點：
* 1、面向對象就是一種常見的思想。符合人們的思考習慣
* 2、面向對象的出現，將複雜的問題簡單化
* 3、面向對象的出現，讓曾經在過程中的執行者，變成了對象的指揮者
*
* 用java語言對現實生活中的事物進行描述
* 通過類的形式來體現的
*
* 怎麼描述呢？
* 對於事物描述通常只關注兩方面
* 一個是屬性，一個是行爲
*
* 只要明確該事物的屬性和行爲並定義在類中即可
* 對象：其實就是該類事物實實在在存在的個體。
*
* 類與對象之間的關係？
* 類：事物的描述
* 對象：該類事物的實例。在java中通過new來創建的
*
* 成員變量和局部變量的區別：
* 1、
* 成員變量定義在類中，整個類中都可以訪問。
* 局部變量定義在函數，語句，局部代碼塊中，只在所屬都區域有效
* 2、
* 成員變量存在於堆內存的對象中
* 局部變量存在於棧內存的方法中
* 3、
* 成員變量隨着對象的創建而存在，隨着對象的消失而消失
* 局部變量隨着所屬區域的執行而存在，隨着所屬區域的結束而釋放
* 4、
* 成員變量都有默認初始化值
* 局部變量沒有默認初始化值
*
* 匿名對象：沒有名字的對象
* new Car();//匿名對象。其實就是定義對象的簡寫格式
* Car c=new Car()
* c.run();
* new Car().run()
*
* 1、當對象對方法僅進行一次調用對時候，就可以簡化成匿名對象
* 2、匿名對象可以作爲實際參數進行傳遞
*
* 封裝：是指隱藏對象屬性和實現細節，僅對外提供公共訪問方式
* 好處：
* 1、將變化隔離
* 2、便於使用
* 3、提高重用性
* 4、提高安全性
* 封裝原則：
* 將不需要對外的內容隱藏起來
* 把屬性都隱藏
*
* private：私有，是一個權限修飾符。用於修飾成員
* 私有都內容只在本類中有效。
*
* 注意：私有僅僅是封裝的一種體現而已。
*/
/*
* 描述小汽車
*
* 分析：
* 1、屬性
* 輪胎數
* 顏色
* 2、行爲
* 運行
*/
public static void main(String[] args) {
Car c = new Car();
// c.color="red";
// c.num=4;
// c.run();
show(c);
}
public static void show(Car c)
{
c.num = 3;
c.color="black";
System.out.println(c.num+"..."+c.color);
}
}
class Car
{
int num;
String color;
void run()
{
System.out.println(num+"..."+color);
}
}構造函數部分：
package com.laobi.day07;
public class GouZaoHanShu {
/**
* 構造函數
* 特點：
* 1、函數名與類名相同
* 2、不用定義返回值類型
* 3、沒有具體的返回值
* 作用：給對象進行初始化
* 注意：
* 1、默認構造函數的特點
*
*
* 構造函數：構建創造對象時調用的函數。作用：可以給對象進行初始化
* 創建對象都必須要通過構造函數初始化
*
* 一個類中如果沒有定義過構造函數，那麼該類中會有一個默認的無參構造函數
* 如果在類中定義類指定的構造函數，那麼類中的默認構造函數就沒有了
*
* 一般函數和構造函數什麼區別呢？
* 構造函數：對象創建時，就會調用與之對應的構造函數，對對象進行初始化
* 一般函數：對象創建後，需要函數功能時才調用
*
* 構造函數：對象創建時，會調用只調用一次
* 一般函數：對象創建後，可以被調用多次。
*
* 什麼時候定義構造函數？
* 在描述事物時，該事物已存在就具備的一些內容，這些內容都定義在構造函數中
*
* 構造函數可以有多個，用於對不同的對象進行鍼對性的初始化
* 多個構造函數在類中是以重載的形式來體現的
*
* this關鍵字
* 特點：this代表其所在函數所屬對象的引用，換言之就是，this在本類對象中的引用
*
* 當成員變量和局部變量重名，可以使用this來區分
*
* this：代表對象。
* this就是所在函數所屬對象的引用
*
* this也可以用於在構造函數中調用其他構造函數
* 注意：只能定義在構造函數的第一行，因爲初始化要先執行
*
*/
public static void main(String[] args) {
Person p = new Person();
}
}
class Person
{
private String name;
private int age;
Person()
{
System.out.println("person run");
}
public void speak()
{
System.out.println(name+"..."+age);
}
}
package com.laobi.day07;
public class JingTai {
/**
* 靜態修飾符
* static ：用於修飾成員（成員變量和成員函數）
*
* 被修飾後的成員具備一下特點
* 1、隨着類的加載而加載
* 2、優先於對象存在
* 3、被所有對象所共享
* 4、可以直接被類名調用
*
* 使用注意
* 1、靜態方法只能訪問靜態成員
* 2、靜態方法中不可以寫this、super關鍵字
* 3、主函數是靜態的
*
* static特點
* 1、static是一個修飾符，用於修飾成員
* 2、static修飾的成員被所有的對象所共享
* 3、static優先於對象存在，因爲static的成員隨着類的加載就已經存在
* 4、static修飾的成員多了一種調用方式，就可以直接被類名所調用。
* 5、static修飾的數據是共享數據，對象中的存儲的是特有數據
*
* 成員變量和靜態變量的區別
* 1、兩個變量的生命週期不同。
* 成員變量隨着對象的創建而存在，隨着對象的被回收而釋放。
* 靜態變量隨着類的加載而存在，隨着類的消失而消失
* 2、調用方式不同
* 成員變量只能被對象調用
* 靜態變量可以被對象調用，還可以被類名調用
* 3、別名不同
* 成員變量也稱爲實例變量
* 靜態變量稱爲類變量
* 4、數據存儲位置不同
* 成員變量數據存儲在堆內存對對象中，所以也叫對象對特有數據
* 靜態變量數據存儲在方法區（的靜態區），所以也叫對象的共享數據
*
* 靜態什麼時候用？
* 1、靜態變量
* 當分析對象中所具備的成員變量的值都是相同的，這時這個成員就可以被靜態修飾
* 只要數據在對象中都是不同的，就是對象的特有數據必須存儲在對象中，是非靜態的
* 如果是相同的數據，對象不需要做修改，只需要使用即可，不需要存儲在對象中，定義成靜態的
*
* 2、靜態函數
* 函數是否用靜態修飾，就參考一點，就是該功能是否有訪問到對象中到特有數據
* 簡單點說，從源代碼看，該功能是否需要訪問非靜態到成員變量，如果需要，該功能就是非靜態的
* 如果不需要，就可以將該功能定義成靜態的.當然也可以定義成非靜態的，但是非靜態需要被對象調用
* 而僅創建對象沒有調用非靜態的，沒有訪問特有數據的方法，該對象的創建是沒有意義的
*
* 靜態代碼塊：
* 隨着類的加載而執行，而且只執行一次
* 作用：
* 用於給類進行初始化
*/
public static void main(String[] args) {
new Demo().speak();
}
}
class Demo
{
int age;
static int num = 9;
public void speak()
{
System.out.println(num);
}
}
package com.laobi.day08;
public class JiCheng {
/**
* 繼承的好處：
* 1、提高了代碼的複用性
* 2、讓類與類之間產生關係，給第三個特徵多態提供了前提
*
* 在java中支持單繼承，不直接支持多繼承
* 單繼承：一個子類只能繼承一個父類
* 多繼承：一個子類可以支持多個父類（java中不允許）
* java支持多層（多重）繼承
* 也就出現了繼承體系
* 當要使用一個繼承體系：
* 1、查看該體系的頂層類，瞭解該體系的基本功能
* 2、創建體系中最子類的對象，完成功能的使用
* 什麼時候定義繼承？
* 當類與類之間存在所屬關係的時候，就定義繼承
*
* 成員變量
* 當本類的成員和局部變量同名用this區分
* 當子父類中的成員變量同名用super區分
* this：代表本類對象的引用
* super：代表一個父類空間
*
* 成員函數
* 當子父類中出現成員函數一摸一樣的時候，會運行子類的函數。
* 這種現象稱爲覆蓋操作。這是函數在子父類中的特性
*
* 函數的兩個特徵：
* 1、重載：同一個類中
* 2、覆蓋：在子類中
*
* 覆蓋注意事項：
* 1、子類覆蓋父類方法時，子類權限必須要大於等於父類的權限。
* 2、靜態只能覆蓋，或者被靜態覆蓋
*
* 什麼時候使用覆蓋操作？
* 當一個類進行子類的擴展時，子類需要保留父類的功能聲明，
* 但是要定義子類中該功能特有內容時，就使用覆蓋操作完成。
*
* 子父類中構造函數的特點：
* 在子類構造對象時，發現訪問子類構造函數時，父類也運行了
* 爲什麼呢？
* 原因是：在子類的構造函數中，第一行有一個默認的隱式構造函數 super（）
*
* 在子類實例化過程當中：子類所有的構造函數默認都會訪問空參數的構造函數
*
* 爲什麼子類實例化的時候要訪問父類中的構造函數？
* 因爲子類繼承了父類，獲取到父類中到內容（屬性），所以在使用父類內容之前
* 要看父類是如何對自己對內容進行初始化的。
* 所以子類在構造對象時，必須訪問父類中的構造函數
* 爲了完成必須這個動作，就在子類構造函數中加入了super語句
*
* 如果父類中沒有定義空參數構造函數，那麼子類的構造函數必須用super明確
* 要調用父類中哪個構造函數
*
* 注意：super語句必須要定義在子類構造函數的第一行。因爲父類的初始化動作要先完成
*
*
* 一個對象的實例化過程
* Person p ＝ new Person()
* 1、jvm會讀取指定路徑下的Person.class文件並加載僅內存，
* 並會先加載Person的父類（如果有直接的父類的情況下）
* 2、在堆內存中開闢空間，並分配地址值
* 3、並在對象空間中，對對象中的屬性進行默認初始化
* 4、調用對應的構造函數進行初始化
* 5、在構造函數當中，第一行會先調用父類中構造函數進行初始化
* 6、父類初始化完畢後，在對子類的屬性進行顯示初始化
* 7、在進行子類構造函數的特定顯示初始化
* 8、初始化完畢後，將地址值賦值給引用變量
* @param args
*/
public static void main(String[] args) {
Student s = new Student();
s.age=18;
s.name="旺財";
s.study();
}
}
class Person
{
String name;
int age;
}
class Student extends Person
{
public void study()
{
System.out.println(name+"...student study..."+age);
}
}
class Worker extends Person
{
public void work()
{
System.out.println(name+"...worker work..."+age);
}
}package com.laobi.day08;
public class DabLiMoShi {
/**
* 設計模式：對問題行之有效的解決方法，其實它是一種思想
*
* 單例設計模式
* 解決的問題：就是可以保證一個類在內存中的對象唯一性
*
*必須對於多個程序使用同一個配置信息對象時，就需要保證該對象的唯一性
*
*如何保證對象唯一性？
*1、不允許其他程序用new創建該類對象
*2、在該類創建一個本類實例
*3、對外提供一個方法讓其他程序可以獲取對象
*
*步驟：
*1、私有化該類構造函數
*2、通過new在本類中創建一個本類對象
*3、定義一個公有的方法，將創建的對象返回
* @param
*/
public static void main(String[] args) {
System.out.println("Hello,World!");
Single ss = Single.getInstance();
System.out.println(ss);
}
}
class Single
{
//保證對象的唯一性
private static Single s = new Single();//類一加載，對象就已經存在
private Single(){}
public static Single getInstance()
{
return s;
}
}
class Single2
{
//類加載進來沒有對象，只有調用了getInstance方法時，纔會創建對象
private static Single2 s = null;
private Single2(){}
public static Single2 getInstance()
{
if(s==null)
s = new Single2();
return s;
}
}