面向對象基礎學習

2017.01.28

1) 面向對象(面向對象思想概述)(了解)

2) 面向對象(類與對象概述)(掌握)

３) 面向對象(學生類的使用)(掌握)

４) 面向對象(成員變量和局部變量的區別)(掌握)

D:初始化值不同

注意事項：

５) 面向對象(方法的形式參數是類名的時候如何調用)(掌握)

６) 面向對象(匿名對象的概述和應用)(掌握)

７) 面向對象(封裝的概述)(掌握)

A:封裝概述

B:封裝好處

８) 面向對象(private關鍵字的概述和特點)(掌握)

９) 面向對象(this關鍵字的概述和應用)(掌握)

2017.01.29

1）面向對象(構造方法Constructor概述和格式)(掌握)

2）面向對象(構造方法的重載及注意事項)(掌握)

3）面向對象(給成員變量賦值的兩種方式的區別)

B:構造方法

這兩種方式使用setXXX更加方便，因為比較靈活

4） 面向對象(static關鍵字的特點)(掌握)

A:static關鍵字的特點

d:可以通過類名調用

class Demo_Person {    public static void main(String[] args) {        Person.country = "日本";        ...    }}class Person {    static String country;    ... }
e、共性用靜態，單個個性用動態
5） 面向對象(static的注意事項)(掌握)
A:static的注意事項 a:在靜態方法中是沒有this關鍵字的 如何理解呢? 靜態是隨著類的加載而加載，this是隨著對象的創建而存在。靜態比對象先存在。b:靜態方法只能訪問靜態的成員變量和靜態的成員方法 靜態方法：  成員變量：只能訪問靜態變量成員方法：只能訪問靜態成員方法非靜態方法： 成員變量：可以是靜態的，也可以是非靜態的成員方法：可是是靜態的成員方法，也可以是非靜態的成員方法。簡單記： 靜態只能訪問靜態。
6）　面向對象(靜態變量和成員變量的區別)(掌握)
靜態變量也叫類變量  成員變量也叫對象變量A:所屬不同 靜態變量屬于類，所以也稱為為類變量成員變量屬于對象，所以也稱為實例變量(對象變量)B:內存中位置不同 靜態變量存儲于方法區的靜態區成員變量存儲于堆內存C:內存出現時間不同 靜態變量隨著類的加載而加載，隨著類的消失而消失成員變量隨著對象的創建而存在，隨著對象的消失而消失D:調用不同 靜態變量可以通過類名調用，也可以通過對象調用成員變量只能通過對 象名調用
７) 面向對象(main方法的格式詳細解釋)(了解)
A:格式 public static void main(String[] args) {}B:針對格式的解釋 public 被jvm調用，訪問權限足夠大。static 被jvm調用，不用創建對象，直接類名訪問void被jvm調用，不需要給jvm返回值main 一個通用的名稱，雖然不是關鍵字，但是被jvm識別String[] args 以前用于接收鍵盤錄入的
8) 面向對象(工具類中使用靜態)(了解)
A:制作一個工具類 ArrayTool1,獲取最大值2,數組的遍歷3,數組的反轉4,如果一個類中所有的方法都是靜態的，需要多做一步，私有構造方法 private ArryTool() {}目的是不讓其他類創建本類對象，直接用類名.調用即可
9) 面向對象(說明書的制作過程)(了解)
A:對工具類加入文檔注釋B:通過javadoc命令生成說明書 @author(提取作者內容)@version(提取版本內容)javadoc -d 指定的文件目錄 -author -version ArrayTool.java@param 參數名稱//形式參數的變量名稱@return 函數運行完返回的數據
10) 面向對象(如何使用JDK提供的幫助文檔)(了解)
A:找到文檔，打開文檔B:點擊顯示，找到索引，出現輸入框C:你應該知道你找誰?舉例：ScannerD:看這個類的結構(需不需要導包) 成員變量  字段構造方法  構造方法成員方法  方法
11) 面向對象(學習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; 
2017.01.30
1） 面向對象(代碼塊的概述和分類)(了解)
A:代碼塊概述 在Java中，使用{}括起來的代碼被稱為代碼塊。B:代碼塊分類 根據其位置和聲明的不同，可以分為局部代碼塊，構造代碼塊，靜態代碼塊，同步代碼塊(多線程講解)。C:常見代碼塊的應用 a:局部代碼塊  在方法中出現；限定變量生命周期，及早釋放，提高內存利用率b:構造代碼塊 (初始化塊) 在類中方法外出現；多個構造方法方法中相同的代碼存放到一起，每次調用構造都執行，并且在構造方法前執行，即優先執行構造代碼塊！c:靜態代碼塊  隨著類的加載而加載，只執行一次在類中方法外出現，并加上static修飾；用于給類進行初始化，在加載的時候就執行，并且只執行一次。一般用于加載驅動靜態代碼塊優先于主方法執行！
2） 面向對象(繼承案例演示)(掌握)
A:繼承(extends) 讓類與類之間產生關系,子父類關系 B:繼承案例演示： 動物類,貓類,狗類定義兩個屬性(顏色,腿的個數)兩個功能(吃飯，睡覺)C:案例
class Demo1_Extends {    public static void main(String[] args) {        Cat c = new Cat();        c.color = "花";        c.leg = 4;        c.eat();        c.sleep();        System.out.println("color = " + c.color + " , leg = " + c.leg);    }}class animal {    String color;    int leg;    public void eat() {        System.out.println("eating...");    }    public void sleep() {        System.out.println("sleeping...");    }}class Cat extends animal {}
3） 面向對象(繼承的好處和弊端)(掌握)
A:繼承的好處 a:提高了代碼的復用性b:提高了代碼的維護性c:讓類與類之間產生了關系，是多態的前提
B:繼承的弊端
類的耦合性增強了。
開發的原則：高內聚，低耦合。
耦合：類與類的關系內聚：就是自己完成某件事情的能力
4） 面向對象(Java中類的繼承特點)(掌握)
A:Java中類的繼承特點 a:Java只支持單繼承，不支持多繼承。(一個兒子只能有一個爹) 有些語言是支持多繼承，格式：extends 類1,類2,…b:Java支持多層繼承(繼承體系)B:案例演示 Java中類的繼承特點 如果想用這個體系的所有功能用最底層的類創建對象如果想看這個體系的共性功能,看最頂層的類 
5） 面向對象(繼承的注意事項和什么時候使用繼承)(掌握)
A:繼承的注意事項 a:子類只能繼承父類所有非私有的成員（public）(成員方法和成員變量)b:子類不能繼承父類的構造方法，但是可以通過super(馬上講)關鍵字去訪問父類構造方法。c:不要為了部分功能而去繼承項目經理 姓名 工號 工資 獎金程序員   姓名 工號 工資
B:什么時候使用繼承
繼承其實體現的是一種關系：”is a”。
Person StudentTeacher水果 蘋果香蕉橘子
采用假設法。
如果有兩個類A,B。只有他們符合A是B的一種，或者B是A的一種，就可以考慮使用繼承。
6） 面向對象(繼承中成員變量的關系)(掌握)
A:案例演示 a:不同名的變量b:同名的變量 子類父類在開發中是不允許出現同名變量的，子類繼承父類就是為了使用父類的成員
7） 面向對象(this和super的區別和應用)(掌握)
A:this和super都代表什么 this:代表當前對象的引用,誰來調用我,我就代表誰super:代表當前對象父類的引用B:this和super的使用區別 a:調用成員變量 this.成員變量 調用本類的成員變量,也可以調用父類的成員變量super.成員變量 調用父類的成員變量b:調用構造方法 this(…) 調用本類的構造方法super(…)    調用父類的構造方法c:調用成員方法 this.成員方法 調用本類的成員方法,也可以調用父類的方法super.成員方法 調用父類的成員方法
8） 面向對象(繼承中構造方法的關系)(掌握)
A:案例演示
子類中所有的構造方法默認都會訪問父類中空參數的構造方法 
 class Demo4_Extends { public static void main(String[] args) {     Son s = new Son(); } }class Father {    public Father() {        System.out.println(“Father 構造方法…”);    }}class Son extends Father {    public Son() {                      //相當于在此處加了super();        System.out.println(“Son 構造方法…”);    }}相當于在子類空參構造中加上 super(); ，就算不寫，系統也會默認加上！ 
B:為什么呢?
因為子類會繼承父類中的數據，可能還會使用父類的數據。
所以，子類初始化之前，一定要先完成父類數據的初始化。
其實：
每一個構造方法的第一條語句默認都是：super() Object類最頂層的父類。
9) 面向對象(繼承中構造方法的注意事項)(掌握)
A:案例演示 父類沒有無參構造方法,子類怎么辦?super解決this解決 
 class Son extends Father { public Son() {     //super(null,0);            //使用super解決     this(null,0);               //使用this解決     System.out.println("Son 空參構造"); } ... } B:注意事項 super(…)或者*this(….)必須出現在構造方法的第一條語句上*
10) 面向對象(繼承中成員方法關系)(掌握)
A:案例演示 a:不同名的方法b:同名的方法
B:解決方法 
super可以調用父類的成員屬性和方法 
 class Demo6_Extends { public static void main(String[] args) {     Son s = new Son();     s.print();     s.method(); } }class Father {    public void print() {        System.out.println(“Fu print”);    }}class Son extends Father {    public void print() {        super.print();                  //super可以調用父類的成員屬性和方法        System.out.println(“Zi print”);    }public void method() {    System.out.println("Zi method");}}
11） 面向對象(方法重寫概述及其應用)(掌握)
A:什么是方法重寫 重寫:子父類出現了一模一樣的方法(注意:返回值類型可以是子父類,這個我們學完面向對象講) B:方法重寫的應用： 當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法。這樣，即沿襲了父類的功能，又定義了子類特有的內容。
C:案例演示 
a:定義一個手機類。 
 class Demo7_Phone { public static void main(String[] args) {     Ios8 i = new Ios8();     i.siri();           //增加ios8的說中文和ios7的Speak English     i.call();           //調用ios7的call的功能 } }class Ios7 {    public void call() {        System.out.println(“Calling…”);    }public void siri() {    System.out.println("Speak English...");}}class Ios8 extends Ios7 {    public void siri() {        super.siri();        System.out.println(“說中文…”);    }}
12) 面向對象(方法重寫的注意事項)(掌握)
A:方法重寫注意事項
a:父類中私有方法不能被重寫 因為父類私有方法子類根本就無法繼承b:子類重寫父類方法時，訪問權限不能更低 最好就一致
c:父類靜態方法，子類也必須通過靜態方法進行重寫
其實這個算不上方法重寫，但是現象確實如此，至于為什么算不上方法重寫，多態中我會講解(靜態只能覆蓋靜態)
子類重寫父類方法的時候，最好聲明一模一樣。
B:案例演示 方法重寫注意事項
13) 面向對象(方法重寫的面試題)(掌握)
A:方法重寫的面試題
Override(重寫)和Overload（重載）的區別?Overload能改變返回值類型嗎?
overload可以改變返回值類型,只看參數列表
方法重寫：子類中出現了和父類中方法聲明一模一樣的方法。與返回值類型有關,返回值是一致(或者是子父類)的
方法重載：本類中出現的方法名一樣，參數列表不同的方法。與返回值類型無關。
子類對象調用方法的時候：
先找子類本身，再找父類。
14） 面向對象(使用繼承前和使用繼承后的學生和老師案例)(掌握)
A:案例演示 使用繼承前的學生和老師案例屬性:姓名,年齡行為:吃飯老師有特有的方法:講課學生有特有的方法:學習B:案例演示 使用繼承后的學生和老師案例
15） 面向對象(final關鍵字修飾類,方法以及變量的特點)(掌握)
A:final概述B:final修飾特點 修飾類，類不能被繼承修飾變量，變量就變成了常量，只能被賦值一次修飾方法，方法不能被重寫C:final修飾特點 final 修飾常量一般會與 public static 相修飾，組成public static final int NUM = …，這樣做的好處是可以直接通過類調用。
16） 面向對象(final關鍵字修飾局部變量)(掌握)
基本類型，是值不能被改變
引用類型，是地址值不能被改變,對象中的屬性可以改變
class Demo10_Final {    public static void main(String[] args) {        final int NUM = 10;        //NUM = 20;        System.out.println("NUM = " + NUM);    final Person p = new Person("張三",34);    //p = new Person("李四",44);          //不能再次創建對象    p.setName("李四");                    //可以對已創建的對象的屬性進行賦值    p.setAge(55);    System.out.println("name : " + p.getName() + " , age : " + p.getAge());    method(20);    method(45);}public static void method(final int x) {        //將x改變為final類型    System.out.println(x);}}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 this.name;}public void setAge(int age) {    this.age = age;}public int getAge() {    return this.age;}}
17） 面向對象(final修飾變量的初始化時機)(掌握)
A:final修飾變量的初始化時機 顯示初始化 在對象構造完畢前即可
17.02.01
1）面向對象(package關鍵字的概述及作用)(了解)
A:為什么要有包 將字節碼(.class)進行分類存放 包其實就是文件夾B:包的概述
舉例：     學生：增加，刪除，修改，查詢     老師：增加，刪除，修改，查詢     …
方案1：按照功能分    com.heima.add        AddStudent        AddTeacher    com.heima.delete        DeleteStudent        DeleteTeacher    com.heima.update        UpdateStudent        UpdateTeacher    com.heima.find        FindStudent        FindTeacher方案2：按照模塊分    com.heima.teacher        AddTeacher        DeleteTeacher        UpdateTeacher        FindTeacher    com.heima.student        AddStudent        DeleteStudent        UpdateStudent        FindStudent
2） 面向對象(包的定義及注意事項)(掌握)
A:定義包的格式 package 包名;多級包用.分開即可B:定義包的注意事項 A:package語句必須是程序的第一條可執行的代碼B:package語句在一個java文件中只能有一個C:如果沒有package，默認表示無包名C:案例演示 包的定義及注意事項
3） 面向對象(帶包的類編譯和運行)(掌握)
A:如何編譯運行帶包的類 a:javac編譯的時候帶上-d即可 javac -d . HelloWorld.java(不要忘記有一個點！)b:通過java命令執行。 java 包名.HellWord
4）面向對象(import關鍵字的概述和使用)(掌握)
A:案例演示 為什么要有import 其實就是讓有包的類對調用者可見,不用寫全類名了 B:導包格式 import 包名;注意：這種方式導入是到類的名稱。雖然可以最后寫*，但是不建議。C:package,import,class有順序關系
5）面向對象(四種權限修飾符的測試)(掌握)
A:案例演示 四種權限修飾符B:結論（訪問范圍）
  
本類
  
同一個包下(子類和無關類)
  
不同包下(子類)
  
不同包下(無關類)
  
private
  
Y
  
  
  
默認
  
Y
  
Y
  
  
protected
  
Y
  
Y
  
Y
  
public
  
Y
  
Y
  
Y
6）面向對象(類及其組成所使用的常見修飾符)(掌握)
A:修飾符： 權限修飾符：private，默認的，protected，public狀態修飾符：static，final抽象修飾符：abstract
B:類：
權限修飾符：默認修飾符，public狀態修飾符：final
抽象修飾符：abstract
用的最多的就是：public
C:成員變量：
權限修飾符：private，默認的，protected，public
狀態修飾符：static，final
用的最多的就是：private
D:構造方法：
權限修飾符：private，默認的，protected，public
用的最多的就是：public
E:成員方法：
權限修飾符：private，默認的，protected，public狀態修飾符：static，final
抽象修飾符：abstract
用的最多的就是：public
F:除此以外的組合規則：
成員變量：public static final成員方法： public static public abstractpublic final
7） 面向對象(內部類概述和訪問特點)(了解)
A:內部類概述B:內部類訪問特點 a:內部類可以直接訪問外部類的成員，包括私有。b:外部類要訪問內部類的成員，必須創建對象。外部類名.內部類名 對象名 = 外部類對象.內部類對象;C:案例演示 內部類極其訪問特點
8） 面向對象(靜態成員內部類)(了解)
staticB:成員內部類被靜態修飾后的訪問方式是: 外部類名.內部類名 對象名 = 外部類名.內部類對象;
9）面向對象(成員內部類的面試題)(掌握)
A:面試題要求：使用已知的變量，在控制臺輸出30，20，10。class Outer {    public int num = 10;    class Inner {        public int num = 20;        public void show() {            int num = 30;            System.out.println(?);            System.out.println(??);            System.out.println(???);        }    }}class InnerClassTest {    public static void main(String[] args) {        Outer.Inner oi = new Outer().new Inner();        oi.show();    }   }？：num？？：this.num？？？：Outer.this.num（內部類之所以能獲取到外部類的成員，這是因為它能獲取到外部類的引用：外部類.this）
10）面向對象(局部內部類訪問局部變量的問題)(掌握)
A:案例演示
局部內部類訪問局部變量必須用final修飾
局部內部類在訪問他所在方法中的局部變量必須用final修飾,為什么? 因為當調用這個方法時,局部變量如果沒有用final修飾,他的生命周期和方法的生命周期是一樣的,當方法彈棧,這個局部變量也會消失,那么如果局部內部類對象還沒有馬上消失想用這個局部變量,就沒有了,如果用final修飾會在類加載的時候進入常量池,即使方法彈棧,常量池的常量還在,也可以繼續使用
但是jdk1.8取消了這個事情,所以我認為這是個bug
11）面向對象(匿名內部類的格式和理解)
A:匿名內部類 就是內部類的簡化寫法。B:前提：存在一個類或者接口 這里的類可以是具體類也可以是抽象類。C:格式：     new 類名或者接口名(){         重寫方法;     }D:本質是什么呢? 是一個繼承了該類或者實現了該接口的子類匿名對象。匿名內部類適用于只重寫一個方法的時候使用
12）面向對象(匿名內部類在開發中的應用)
A:代碼如下//這里寫抽象類，接口都行abstract class Person {    public abstract void show();}class PersonDemo {    public void method(Person p) {        p.show();    }}class PersonTest {    public static void main(String[] args) {        //如何調用PersonDemo中的method方法呢?        PersonDemo pd = new PersonDemo ();    }}