類：是一組相關(guān)的屬性和行為的集合
對象：是該類事物的具體體現(xiàn)

現(xiàn)實世界的事物
　　屬性 人的身高，體重等
　　行為 人可以學(xué)習(xí)橄仆，吃飯等
Java中用class描述事物也是如此
　　成員變量 就是事物的屬性
　　成員方法 就是事物的行為
定義類其實就是定義類的成員(成員變量和成員方法)
成員變量 和以前定義變量是一樣的剩膘，只不過位置發(fā)生了改變，在類中盆顾，方法外
成員方法 和以前定義方法是一樣的怠褐，只不過把static去掉

定義一個類
如何定義
按照事物到類的過程一步步分析

/*
    手機事物：
        屬性：品牌，價格您宪，顏色...
        行為：打電話惫搏，發(fā)短信，玩游戲...
        
    手機類：
        成員變量：品牌蚕涤，價格，顏色
        成員方法：打電話铣猩，發(fā)短信揖铜，玩游戲
*/
class Phone {
    //品牌
    String brand;
    //價格
    int price;
    //顏色
    String color;
    
    //打電話的方法
    public void call(String name) {
        System.out.println("給"+name+"打電話");
    }
    
    //發(fā)短信的方法
    public void sendMessage() {
        System.out.println("群發(fā)短信");
    }
    
    //玩游戲的方法
    public void playGame() {
        System.out.println("玩游戲");
    }
}

類的調(diào)用
創(chuàng)建對象：
格式：類名 對象名 = new 類名();
使用：
　　-對象名.成員變量
　　-對象名.成員方法

/*
    手機類的測試
*/
class Phone {
    //品牌
    String brand;
    //價格
    int price;
    //顏色
    String color;
    
    //打電話的方法
    public void call(String name) {
        System.out.println("給"+name+"打電話");
    }
    
    //發(fā)短信的方法
    public void sendMessage() {
        System.out.println("群發(fā)短信");
    }
    
    //玩游戲的方法
    public void playGame() {
        System.out.println("玩游戲");
    }
}

class PhoneDemo {
    public static void main(String[] args) {
        //創(chuàng)建手機對象
        //類名 對象名 = new 類名();
        Phone p = new Phone();
        
        //直接輸出成員變量值
        System.out.println(p.brand+"---"+p.price+"---"+p.color);
        
        //給成員變量賦值
        p.brand = "諾基亞";
        p.price = 100;
        p.color = "灰色";
        //再次輸出
        System.out.println(p.brand+"---"+p.price+"---"+p.color);
        
        //調(diào)用方法
        p.call("張三");
        p.sendMessage();
        p.playGame();
    }
}

對象的內(nèi)存圖

對象的內(nèi)存圖

學(xué)生類

/*
    在一個java文件中寫兩個類：一個基本的類，一個測試類
    注意：文件名稱和測試類名稱一致
    
    如何使用呢?
        創(chuàng)建對象使用
        
    如何創(chuàng)建對象
        格式：類名 對象名 = new 類名();
        
    如何使用成員變量
        對象名.變量名
    如何使用成員方法
        對象名.方法名(...)
*/
//這是學(xué)生類
class Student {
    //姓名
    String name; //默認值null
    //年齡
    int age; //默認值0
    //地址
    String address; //默認值null
    
    //學(xué)習(xí)
    public void study() {
        System.out.println("學(xué)生愛學(xué)習(xí)");
    }
    
    //吃飯
    public void eat() {
        System.out.println("學(xué)習(xí)餓了达皿，要吃飯");
    }
    
    //睡覺
    public void sleep() {
        System.out.println("學(xué)習(xí)累了天吓，要睡覺");
    }
}

//這是學(xué)生測試類
class StudentDemo {
    public static void main(String[] args) {
        //類名 對象名 = new 類名();
        Student s = new Student();
        
        //輸出成員變量值
        //System.out.println(s.name);
        //System.out.println(s.age);
        //System.out.println(s.address);
        //改進寫法
        System.out.println(s.name+"---"+s.age+"---"+s.address);
        
        
        //給成員變量賦值
        s.name = "張三";
        s.age = 18;
        s.address = "北京";
        //賦值后的輸出
        System.out.println(s.name+"---"+s.age+"---"+s.address);
        
        //調(diào)用方法
        s.study();
        s.eat();
        s.sleep();
    }
}

Day7

成員變量和局部變量的區(qū)別

在類中的位置不同
　　-成員變量：在類中方法外
　　-局部變量：在方法定義中或者方法聲明上
在內(nèi)存中的位置不同
　　-成員變量：在堆內(nèi)存
　　-局部變量：在棧內(nèi)存
生命周期不同
　　-成員變量：隨著對象的創(chuàng)建而存在贿肩，隨著對象的消失而消失
　　-局部變量：隨著方法的調(diào)用而存在，隨著方法的調(diào)用完畢而消失
初始化值不同
　　-成員變量：有默認初始化值
　　-局部變量：沒有默認初始化值龄寞，必須定義汰规，賦值，然后才能使用

注意事項：
　　局部變量名稱可以和成員變量名稱一樣物邑，在方法中使用的時候溜哮，采用的是就近原則
匿名對象
　　就是沒有名字的對象
匿名對象的應(yīng)用場景：
　　調(diào)用方法，僅僅只調(diào)用一次的時候
注意：調(diào)用多次的時候色解，不適合
好處：匿名對象調(diào)用完畢就是垃圾茂嗓。可以被垃圾回收器回收
匿名對象可以作為實際參數(shù)傳遞

private關(guān)鍵字
是一個權(quán)限修飾符
可以修飾成員變量和成員方法
被其修飾的成員只能在本類中被訪問

封裝：是指隱藏對象的屬性和實現(xiàn)細節(jié)科阎，僅對外提供公共訪問方式述吸。

class Demo {
    //用private修飾
    private int num = 10;
    
    public void show() {
        System.out.println(num);
    }
    
    private void method() {
        System.out.println("method");
    }
    
    public void function() {
        method();
    }
}

class PrivateDemo {
    public static void main(String[] args) {
        Demo d = new Demo();
        //不能訪問私有的成員變量
        //System.out.println(d.num);
        d.show();
        //不能訪問私有的成員方法
        //d.method();
        d.function();
    }
}

對數(shù)據(jù)進行限制

class Student {
    //姓名
    String name;
    //年齡
    private int age;  //對年齡進行限制
    
    //寫一個方法對數(shù)據(jù)進行限制
    public void setAge(int a) {
        if(a < 0 || a > 120) {
            System.out.println("你給的年齡有問題");
        }else {
            age = a;
        }
    }
    
    //show()方法,顯示所有成員變量值
    public void show() {
        System.out.println("姓名："+name);
        System.out.println("年齡："+age);
    }
}

class StudentDemo {  //測試類
    public static void main(String[] args) {
        //創(chuàng)建學(xué)生對象
        Student s = new Student();
        s.show();
        System.out.println("--------------");
        
        //給成員變量賦值
        s.name = "張三";
        //s.age = 27;  //私有，不可訪問
        s.setAge(27);
        s.show();
        System.out.println("--------------");
        
        //給age賦值
        //s.age = -27; //這個數(shù)據(jù)是不合理的
        //通過方法給值
        s.setAge(-27);
        s.show();
        System.out.println("--------------");
    }
}

封裝private最常見的應(yīng)用
　　-把成員變量用private修飾
　　-提供對應(yīng)的getXxx()/setXxx()方法 set賦值锣笨，用來輸入蝌矛，get獲取值，用來輸出

class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //姓名獲取值
    public String getName() {
        return name;
    }
    
    //姓名設(shè)置值
    public void setName(String n) {
        name = n;
    }
    
    //年齡獲取值
    public int getAge() {
        return age;
    }
    
    //年齡賦值
    public void setAge(int a) {
        age = a;
    }
}

//測試類
class StudentTest {
    public static void main(String[] args) {
        //創(chuàng)建學(xué)生對象
        Student s = new Student();
        
        //使用成員變量
        //錯誤：被私有修飾了错英，外界不能直接訪問了
        //System.out.println(s.name+"---"+s.age);
        System.out.println(s.getName()+"---"+s.getAge());
        
        //給成員變量賦值
        //s.name = "張三";
        //s.age = 27;
        //通過方法給賦值
        s.setName("張三");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

this關(guān)鍵字
this:是當(dāng)前類的對象引用入撒，簡單的記，它就代表當(dāng)前類的一個對象
注意：誰調(diào)用這個方法走趋，在該方法內(nèi)部的this就代表誰衅金。
this的場景：
　　解決局部變量隱藏成員變量

class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //姓名獲取值
    public String getName() {
        return name;
    }
    
    //姓名設(shè)置值,起名字要做到見名知意
    public void setName(String name) { //name = "張三";
        //name = name; //變量的使用規(guī)則：就近原則
        //這里是類名，目前還沒有說過類似的用法簿煌，所以這個是有問題的
        //這里的調(diào)用只能通過對象名
        //這個對象如果存在氮唯，它應(yīng)該代表的是Student的一個對象
        //那么，誰能夠代表當(dāng)前類的對象呢? java就提供了一個關(guān)鍵字 this
        //Student.name = name;
        this.name = name;
    }
    
    //年齡獲取值
    public int getAge() {
        return age;
    }
    
    //年齡賦值
    public void setAge(int age) {
        this.age = age;
    }
}

//測試類
class StudentTest {
    public static void main(String[] args) {
        //創(chuàng)建學(xué)生對象
        Student s = new Student();
        
        //給成員變量賦值
        s.setName("張三");
        s.setAge(27);
        //獲取數(shù)據(jù)
        System.out.println(s.getName()+"---"+s.getAge());
    }
}
/*
    標準的代碼改進版
    
    this:哪個對象調(diào)用那個方法姨伟，this就代表那個對象
*/
class Student {
    private String name;
    private int age;
    
    public String getName() {
        return name; //這里其實是隱含了this
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //創(chuàng)建一個對象
        Student s1 = new Student();
        s1.setName("張三");
        s1.setAge(27);
        System.out.println(s1.getName()+"---"+s1.getAge());
        
        //創(chuàng)建第二個對象
        Student s2 = new Student();
        s2.setName("李四");
        s2.setAge(30);
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}

構(gòu)造方法
構(gòu)造方法作用概述
　　給對象的數(shù)據(jù)進行初始化
構(gòu)造方法格式
　　方法名與類名相同
　　沒有返回值類型惩琉，連void都沒有
　　沒有具體的返回值

class Student {
    private String name; //null
    private int age; //0
    
    public Student() {  //創(chuàng)建了一個構(gòu)造方法
        System.out.println("這是構(gòu)造方法");
    }
}

class ConstructDemo {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Student s = new Student();
        System.out.println(s); //輸出這是構(gòu)造方法跟地址值，說明經(jīng)過了上邊的public Student
    }
}

構(gòu)造方法注意事項
　　如果你不提供構(gòu)造方法夺荒，系統(tǒng)會給出默認構(gòu)造方法
　　如果你提供了構(gòu)造方法瞒渠，系統(tǒng)將不再提供
　　構(gòu)造方法也是可以重載的

構(gòu)造方法賦值的形式

public class People {
    //姓名
    String name;
    //年齡
    int age;
    //住址
    String address;

    //構(gòu)造方法無參
    public  People(){ }

    //有參
    public  People(String name,int age){
        this.name = name;
        this.age = age;
    }

    //三個參數(shù)
    public  People(String name,int age,String address){
        this.age = age;
        this.name = name;
        this.address = address;
    }

    //show打印所有信息
    public void show(){
        System.out.println("姓名："+name+" 年齡："+age+" 住址："+address);
    }
}
class PeopleText{
    public static void main(String[] args) {
        //創(chuàng)建對象無參
        People p = new People();
        p.name = "張三";
        p.age = 18;
        p.address = "山東省";
        p.show();

        //兩個參數(shù)的
        People p1 = new People("李四",15);
        p1.address = "北京省";
        p1.show();

        //三個參數(shù)的
        People p2 = new People("王五",15,"山東省");
        p2.show();
    }
}

給成員變量賦值有兩種方式：
　　-setXxx()
　　-構(gòu)造方法
成員方法
　根據(jù)返回值：
　　-void類型
　　-非void類型
　形式參數(shù)：
　　-空參方法
　　-非空參方法
四種方式的調(diào)用：

class Student {
    public String getString() {
        return "helloworld";
    }

    public void show() {
        System.out.println("show");
    }
    
    public void method(String name) {
        System.out.println(name);
    }
    
    public String function(String s1,String s2) {
        return s1+s2;
    }
}

class StudentDemo {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Student s = new Student();
        
        //調(diào)用無參無返回值方法
        s.show();
        
        //調(diào)用無參有返回值方法
        String result = s.getString();
        System.out.println(result);
        
        //調(diào)用帶參無返回值的方法
        s.method("張三");
        
        //調(diào)用帶參帶返回值的方法
        String result2 = s.function("hello","world");
        System.out.println(result2);
    }
}

類分為成員變量,構(gòu)造方法,成員方法
　成員變量
　構(gòu)造方法
　　-無參構(gòu)造方法
　　-帶參構(gòu)造方法
　成員方法
　　-getXxx()
　　-setXxx()
類的標準寫法

/*
    學(xué)生類：
        成員變量：
            name，age
        構(gòu)造方法：
            無參技扼，帶兩個參
        成員方法：
            getXxx()/setXxx()
            show()：輸出該類的所有成員變量值
            
    給成員變量賦值：
        A:setXxx()方法
        B:構(gòu)造方法
        
    輸出成員變量值的方式：
        A:通過getXxx()分別獲取然后拼接
        B:通過調(diào)用show()方法搞定
*/
class Student {
    //姓名
    private String name;
    //年齡
    private int age;
    
    //構(gòu)造方法
    public Student() {
    }
    
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    //輸出所有的成員變量值
    public void show() {
        System.out.println(name+"---"+age);
    }
}

//測試類
class StudentTest {
    public static void main(String[] args) {
        //方式1給成員變量賦值
        //無參構(gòu)造+setXxx()
        Student s1 = new Student();
        s1.setName("張三");
        s1.setAge(27);
        //輸出值
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.show();
        System.out.println("----------------------------");
        
        //方式2給成員變量賦值
        Student s2 = new Student("李四",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
        s2.show();
    }
}

注意:
　-給成員變量賦值有兩種方式伍玖，可以只寫一種,推薦使用setXxx()方法,單個輸入更靈活
　-如果不單獨獲取數(shù)據(jù)，可以不寫getXxx()方法

類的初始化過程
Student s = new Student();在內(nèi)存中做了哪些事情
　-加載Student.class文件進內(nèi)存
　-在棧內(nèi)存為s開辟空間
　-在堆內(nèi)存為學(xué)生對象開辟空間
　-對學(xué)生對象的成員變量進行默認初始化
　-對學(xué)生對象的成員變量進行顯示初始化
　-通過構(gòu)造方法對學(xué)生對象的成員變量賦值
　-學(xué)生對象初始化完畢剿吻，把對象地址賦值給s變量

static關(guān)鍵字
　可以修飾成員變量和成員方法
static關(guān)鍵字特點
　　-隨著類的加載而加載
　　-優(yōu)先于對象存在
　　-被類的所有對象共享(這也是我們判斷是否使用靜態(tài)關(guān)鍵字的條件)
　　-可以通過類名調(diào)用
可以通過類名和對象名調(diào)用

class Student {
    //非靜態(tài)變量
    int num = 10;
    
    //靜態(tài)變量
    static int num2 = 20;
}

class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.num);
        
        System.out.println(Student.num2);  //可以通過類名調(diào)用
        System.out.println(s.num2); //可以通過對象調(diào)用
    }
}

/*
    定義一個人類
    
    姓名和年齡都是變化的窍箍，因為每個人的姓名和年齡是不同的。
    但是，我們想到的都是中國人椰棘，他們的國籍是一樣的纺棺。
    一樣的國籍，我每次創(chuàng)建對象邪狞，在堆內(nèi)存都要開辟這樣的空間祷蝌，很浪費
        針對多個對象有共同的這樣的成員變量值的時候，
        Java就提高了一個關(guān)鍵字來修飾：static帆卓。
*/
class Person {
    //姓名
    String name;
    //年齡
    int age;
    //國籍
    static String country;  //靜態(tài)修飾
    
    public Person(){}
    
    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }
    
    public Person(String name,int age,String country) {
        this.name = name;
        this.age = age;
        this.country = country;
    }
    
    public void show() {
        System.out.println("姓名："+name+",年齡："+age+",國籍："+country);
    }
}

class PersonDemo {
    public static void main(String[] args) {
        //創(chuàng)建對象1
        Person p1 = new Person("鄧麗君",16,"中國");
        p1.show();//輸出姓名:鄧麗君,年齡16,國籍中國
        
        //創(chuàng)建對象2
        Person p2 = new Person("楊冪",22);  //因為country是靜態(tài)static修飾的,相當(dāng)于默認值,所以這個不賦值也是中國
        p2.show();//輸出姓名:楊冪,年齡22,國籍中國
        
        //創(chuàng)建對象3
        Person p3 = new Person("鳳姐",20);
        p3.show(); //同上
        
        p3.country = "美國";
        p3.show();//輸出姓名:鳳姐,年齡20,國籍美國
        
        p1.show();//輸出姓名:鄧麗君,年齡16,國籍美國
        p2.show();//輸出姓名:楊冪,年齡22,國籍美國
            //p1  p2的國際為什么改變,因為用的同一個靜態(tài)修飾即默認值,在內(nèi)存中用的同一塊地址,所以會改變
    }
}

static關(guān)鍵字注意事項
　　-在靜態(tài)方法中是沒有this關(guān)鍵字的
　　-靜態(tài)方法只能訪問靜態(tài)的成員變量和靜態(tài)的成員方法

/*static關(guān)鍵字注意事項
    在靜態(tài)方法中是沒有this關(guān)鍵字的
    如何理解呢?
        靜態(tài)是隨著類的加載而加載巨朦，this是隨著對象的創(chuàng)建而存在。
        靜態(tài)比對象先存在鳞疲。
    靜態(tài)方法只能訪問靜態(tài)的成員變量和靜態(tài)的成員方法
        靜態(tài)方法：
            成員變量：只能訪問靜態(tài)變量
            成員方法：只能訪問靜態(tài)成員方法
        非靜態(tài)方法：
            成員變量：可以是靜態(tài)的罪郊，也可以是非靜態(tài)的
            成員方法：可是是靜態(tài)的成員方法，也可以是非靜態(tài)的成員方法尚洽。
    簡單記：
        靜態(tài)只能訪問靜態(tài)悔橄。
*/
class Teacher {
    public int num = 10;
    public static int num2 = 20;
    
    public void show() {
        System.out.println(num); //隱含的告訴你訪問的是成員變量
        System.out.println(this.num); //明確的告訴你訪問的是成員變量
        System.out.println(num2);
        
        //function();
        //function2();
    }
    
    public static void method() {
        //無法從靜態(tài)上下文中引用非靜態(tài) 變量 num
        //System.out.println(num);
        System.out.println(num2);
        
        //無法從靜態(tài)上下文中引用非靜態(tài) 方法 function()
        //function();
        function2();
    }
    
    public void function() {
    
    }
    
    public static void function2() {
    
    }
}

class TeacherDemo {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Teacher t = new Teacher();
        t.show();
        System.out.println("------------");
        t.method();
    }
}

靜態(tài)變量和成員變量的區(qū)別
　所屬不同
　　-靜態(tài)變量屬于類，所以也稱為為類變量
　　-成員變量屬于對象腺毫，所以也稱為實例變量(對象變量)
　內(nèi)存中位置不同
　　-靜態(tài)變量存儲于方法區(qū)的靜態(tài)區(qū)
　　-成員變量存儲于堆內(nèi)存
　內(nèi)存出現(xiàn)時間不同
　　-靜態(tài)變量隨著類的加載而加載癣疟，隨著類的消失而消失
　　-成員變量隨著對象的創(chuàng)建而存在，隨著對象的消失而消失
　調(diào)用不同
　　-靜態(tài)變量可以通過類名調(diào)用潮酒，也可以通過對象調(diào)用
　　-成員變量只能通過對象名調(diào)用
main方法詳解
main方法的格式講解：
public static void main(String[] args) {...}
　　public:公共的睛挚，訪問權(quán)限是最大的。由于main方法是被jvm調(diào)用急黎，所以權(quán)限要夠大
　　static:靜態(tài)的扎狱，不需要創(chuàng)建對象，通過類名就可以,方便jvm的調(diào)用
　　void:因為我們曾經(jīng)說過勃教，方法的返回值是返回給調(diào)用者淤击，而main方法是被jvm調(diào)用,你返回內(nèi)容給jvm沒有意義
　　main:是一個常見的方法入口。我見過的語言都是以main作為入口
　　String[] args:這是一個字符串?dāng)?shù)組,這個東西早期是為了接收鍵盤錄入的數(shù)據(jù)的
　　格式是：java MainDemo hello world java

Day8

制作一個代碼說明書

/*
    我想要對數(shù)組進行操作
    
    如何制作一個說明書呢
        寫一個工具類
        對這個類加入文檔注釋
            怎么加
            加些什么東西
        用工具解析文檔注釋
            javadoc工具
        格式
            javadoc -d 目錄 -author -version ArrayTool.java
            
            目錄：就可以寫一個文件夾的路徑
            
    制作幫助文檔出錯：
        找不到可以文檔化的公共或受保護的類：告訴我們類的權(quán)限不夠
*/
class ArrayDemo {
    public static void main(String[] args) {
        //定義數(shù)組
        int[] arr = {28,55,37,46,19};
        
        //遍歷
        ArrayTool.printArray(arr);

        //獲取最值
        int max = ArrayTool.getMax(arr);
        System.out.println("max:"+max);
        
        //獲取55的索引值
        int index = ArrayTool.getIndex(arr,55);
        System.out.println("index:"+index);
    }
}

/**
* 這是針對數(shù)組進行操作的工具類
* @author 張三
* @version V1.0
*/
public class ArrayTool {
    
    //把構(gòu)造方法私有故源，外界就不能在創(chuàng)建對象了
    /**
    * 這是私有構(gòu)造
    */
    private ArrayTool(){}

    /**
    * 這是遍歷數(shù)組的方法污抬，遍歷后的格式是：[元素1, 元素2, 元素3, ...]
    * @param arr 這是要被遍歷的數(shù)組
    */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.println(arr[x]+"]");
            }else {
                System.out.print(arr[x]+", ");
            }
        }
    }
    
    /**
    * 這是獲取數(shù)組中最大值的方法
    * @param  arr 這是要獲取最大值的數(shù)組
    * @return 返回數(shù)組中的最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];
        
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        
        return max;
    }
    
    /**
    * 獲取指定元素在數(shù)組中第一次出現(xiàn)的索引，如果元素不存在绳军，就返回-1
    * @param arr 被查找的數(shù)組 
    * @param value 要查找的元素
    * @return 返回元素在數(shù)組中的索引印机，如果不存在，返回-1
    */
    public static int getIndex(int[] arr,int value) {
        int index = -1;
        
        for(int x=0; x<arr.length; x++) {
            if(arr[x] == value) {
                index = x;
                break;
            }
        }
        
        return index;
    }
}

上列代碼生成的說明書

如何使用JDK的幫助文檔
1:打開幫助文檔
2:點擊顯示门驾，找到索引哎迄，看到輸入框
3:知道你要找誰?以Scanner舉例
4:在輸入框里面輸入Scanner憔涉，然后回車
5:看包
　　java.lang包下的類不需要導(dǎo)入堰燎，其他的全部需要導(dǎo)入会放。
　　要導(dǎo)入：java.util.Scanner
6:再簡單的看看類的解釋和說明顷蟆，別忘了看看該類的版本
7:看類的結(jié)構(gòu)
　　成員變量 字段摘要
　　構(gòu)造方法 構(gòu)造方法摘要
　　成員方法 方法摘要
8:學(xué)習(xí)構(gòu)造方法
　　有構(gòu)造方法 就創(chuàng)建對象
　　沒有構(gòu)造方法 成員可能都是靜態(tài)的
9:看成員方法
　左邊
　　是否靜態(tài)：如果靜態(tài)，可以通過類名調(diào)用
　　返回值類型：人家返回什么腐魂，你就用什么接收
　右邊
　　看方法名：方法名稱不要寫錯
　　參數(shù)列表：人家要什么，你就給什么逐纬；人家要幾個蛔屹，你就給幾個

Random方法
第一步先導(dǎo)包:import java.util.Random;
第二步創(chuàng)建對象：Random r = new Random(); //r 和 num 為變量名，可以改
第三步使用： int num = r.nextInt(20)+1; //20表示從0開始生成20個數(shù)據(jù)豁生，+1表示從1-20

猜數(shù)字小游戲

import java.util.Random;
import java.util.Scanner;

public class CaiNumber {
    //猜數(shù)字范圍（1-20）
    /*
    * 分析：系統(tǒng)生成一個隨機數(shù)
    *      用戶進行輸入一個數(shù)
    *      進行比較
    *          大了
    *          小了
    *          猜中了
    *       不確定多少次猜中兔毒，用while，猜中就break甸箱；
    * */
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println("系統(tǒng)生成隨機數(shù)");
        int goodNum = r.nextInt(20)+1;

        //System.out.println(goodNum);

        //定義死循環(huán)進行猜數(shù)字
        Scanner sc = new Scanner(System.in);
        while(true) {
            System.out.println("用戶輸入猜測的數(shù)");
            int num = sc.nextInt();
            if (num < goodNum){
                System.out.println("猜小了育叁，請繼續(xù)");
            }else if (num > goodNum){
                System.out.println("猜大了，請繼續(xù)");
            }else {
                System.out.println("猜中了");
                break;
            }
        }
    }
}

代碼塊
在Java中芍殖，使用{}括起來的代碼被稱為代碼塊豪嗽，根據(jù)其位置和聲明的不同，可以分為
　　-局部代碼塊
　　-構(gòu)造代碼塊
　　-靜態(tài)代碼塊
　　-同步代碼塊(多線程講解)
局部代碼塊
　　在方法中出現(xiàn)豌骏；限定變量生命周期龟梦，及早釋放，提高內(nèi)存利用率
構(gòu)造代碼塊
　　在類中方法外出現(xiàn)窃躲；多個構(gòu)造方法方法中相同的代碼存放到一起计贰，每次調(diào)用構(gòu)造都執(zhí)行，并且在構(gòu)造方法前執(zhí)行
靜態(tài)代碼塊 在類中方法外出現(xiàn)蒂窒，加了static修飾
　　在類中方法外出現(xiàn)躁倒，并加上static修飾；用于給類進行初始化洒琢，在加載的時候就執(zhí)行秧秉，并且值執(zhí)行一次
靜態(tài)代碼塊,構(gòu)造代碼塊,構(gòu)造方法的順序問題
　　靜態(tài)代碼塊 > 構(gòu)造代碼塊 > 構(gòu)造方法
靜態(tài)代碼塊：只執(zhí)行一次
構(gòu)造代碼塊：每次調(diào)用構(gòu)造方法都執(zhí)行

/*
    寫程序的執(zhí)行結(jié)果。
    輸出結(jié)果：
      main函數(shù)靜態(tài)方法    
      我是main方法
      Student 靜態(tài)代碼塊
      Student 構(gòu)造代碼塊
      Student 構(gòu)造方法
      Student 構(gòu)造代碼塊
      Student 構(gòu)造方法
先調(diào)用main方法中的靜態(tài)代碼塊纬凤，在調(diào)用main方法福贞，創(chuàng)建對象s1，執(zhí)行Student類中的方法停士，先執(zhí)行靜態(tài)挖帘，在執(zhí)行構(gòu)造代碼塊，最后執(zhí)行構(gòu)造方法恋技，在創(chuàng)建對象s2拇舀，執(zhí)行Student類中的方法，靜態(tài)只執(zhí)行一次蜻底，所以只執(zhí)行構(gòu)造代碼塊和構(gòu)造方法
*/
class Student {
    static {
        System.out.println("Student 靜態(tài)代碼塊");
    }
    
    {
        System.out.println("Student 構(gòu)造代碼塊");
    }
    
    public Student() {
        System.out.println("Student 構(gòu)造方法");
    }
}

class StudentDemo {
    static {
        System.out.println("main函數(shù)靜態(tài)方法");
    }
    
    public static void main(String[] args) {
        System.out.println("我是main方法");
        
        Student s1 = new Student();  //創(chuàng)建對象
        Student s2 = new Student();
    }
}

繼承
繼承概述：
　　把多個類中相同的內(nèi)容給提取出來定義到一個類中骄崩。
如何實現(xiàn)繼承呢?
　　Java提供了關(guān)鍵字：extends
格式：
　　class 子類名 extends 父類名 {}
好處：
　　-提高了代碼的復(fù)用性
　　-提高了代碼的維護性
　　-讓類與類之間產(chǎn)生了關(guān)系，是多態(tài)的前提
類與類產(chǎn)生了關(guān)系，其實也是繼承的一個弊端：
　　類的耦合性增強了要拂。
開發(fā)的原則：低耦合抠璃，高內(nèi)聚。
　　耦合：類與類的關(guān)系
　　內(nèi)聚：就是自己完成某件事情的能力

//使用繼承前
class Student {
    public void eat() {
        System.out.println("吃飯");
    }
    
    public void sleep() {
        System.out.println("睡覺");
    }
}

class Teacher {
    public void eat() {
        System.out.println("吃飯");
    }
    
    public void sleep() {
        System.out.println("睡覺");
    }
}


//使用繼承后
class Person {
    public void eat() {
        System.out.println("吃飯");
    }
    
    public void sleep() {
        System.out.println("睡覺");
    }
}

class Student extends Person {}  //繼承格式

class Teacher extends Person {}

class ExtendsDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.eat();
        s.sleep();
        System.out.println("-------------");
        
        Teacher t = new Teacher();
        t.eat();
        t.sleep();
    }
}

Java繼承的特點
　　-Java只支持單繼承脱惰，不支持多繼承
　　-Java支持多層繼承(繼承體系)

class Father {}
class Mother {}
class Son exnteds Father {} //正確的
class Son extends Father,Mother {} // 錯誤的,不可以多繼承
*/

class GrandFather {
    public void show() {
        System.out.println("我是爺爺");
    }
}

class Father extends GrandFather {  //老子繼承爺爺?shù)?    public void method(){
        System.out.println("我是老子");
    }
}

class Son extends Father {}  //兒子繼承老子的搏嗡，構(gòu)成多層繼承

class ExtendsDemo2 {
    public static void main(String[] args) {
        Son s = new Son();
        s.method(); //使用父親的
        s.show(); //使用爺爺?shù)?    }
}

Java繼承中的成員關(guān)系
成員變量
　子類的成員變量名稱和父類中的成員變量名稱不一樣，通過名稱訪問
　子類的成員變量名稱和父類中的成員變量名稱一樣
　　子類的方法訪問變量的查找順序：
　　　-在子類方法的局部范圍找拉一，有就使用
　　　-在子類的成員范圍找采盒，有就使用
　　　-在父類的成員范圍找，有就使用
　　　-找不到蔚润，就報錯
構(gòu)造方法
　子類的構(gòu)造方法默認會去訪問父類的無參構(gòu)造方法
　　是為了子類訪問父類數(shù)據(jù)的初始化
父類中如果沒有無參構(gòu)造方法磅氨，怎么辦
　　-子類通過super去明確調(diào)用帶參構(gòu)造
　　-子類通過this調(diào)用本身的其他構(gòu)造，但是一定會有一個去訪問了父類的構(gòu)造
　　-讓父類提供無參構(gòu)造
成員方法
　　子類的成員方法和父類中的成員方法名稱不一樣嫡纠，通過名稱
　　子類的成員方法和父類中的成員方法名稱一樣烦租，
　　　通過子類對象訪問一個方法的查找順序：
　　　　-在子類中找，有就使用
　　　　-在父類中找货徙，有就使用
　　　　-找不到左权，就報錯

繼承的注意事項
　　-子類只能繼承父類所有非私有的成員(成員方法和成員變量)
　　-子類不能繼承父類的構(gòu)造方法，但是可以通過super關(guān)鍵字去訪問父類構(gòu)造方法
　　-不要為了部分功能而去繼承

什么時候考慮用繼承
繼承其實體現(xiàn)的是一種關(guān)系："is a"痴颊。
　　Person　 //人
　　Student //學(xué)生
　　Teacher //老師
老師是人赏迟，學(xué)生也是人，就考慮繼承

水果
　　蘋果 //是水果的一種
　　香蕉 //是水果的一種
采用假設(shè)法
　　如果有兩個類A蠢棱，B锌杀，只有他們符合A是B的一種，或者B是A的一種泻仙，就可以考慮使用繼承

類的組成
　　-成員變量：
　　-構(gòu)造方法：
　　-成員方法：
在子類方法中訪問一個變量的查找順序：
　　-在子類方法的局部范圍找糕再，有就使用
　　-在子類的成員范圍找，有就使用
　　-在父類的成員范圍找玉转，有就使用
　　-如果還找不到突想，就報錯
super關(guān)鍵字
　　代表父類存儲空間的標識(可以理解為父類引用,可以操作父類的成員)
this 代表本類對應(yīng)的引用
用法：
　調(diào)用成員變量
　　this.成員變量 調(diào)用本類的成員變量
　　super.成員變量 調(diào)用父類的成員變量
　調(diào)用構(gòu)造方法
　　this(...) 調(diào)用本類的構(gòu)造方法
　　super(...) 調(diào)用父類的構(gòu)造方法
　調(diào)用成員方法
　　this.成員方法 調(diào)用本類的成員方法
　　super.成員方法 調(diào)用父類的成員方法

繼承中構(gòu)造方法的關(guān)系
　　子類中所有的構(gòu)造方法默認都會訪問父類中空參數(shù)的構(gòu)造方法
　　因為子類會繼承父類中的數(shù)據(jù)，可能還會使用父類的數(shù)據(jù)究抓，所以猾担，子類初始化之前，一定要先完成父類數(shù)據(jù)的初始化

注意：子類每一個構(gòu)造方法的第一條語句默認都是：super();

class Father {
    int age;

    public Father() {
        System.out.println("Father的無參構(gòu)造方法");
    }
    
    public Father(String name) {
        System.out.println("Father的帶參構(gòu)造方法");
    }
}

class Son extends Father {
    public Son() {
        //super();
        System.out.println("Son的無參構(gòu)造方法");
    }
    
    public Son(String name) {
        //super();
        System.out.println("Son的帶參構(gòu)造方法");
    }
}   

class ExtendsDemo6 {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Son s = new Son();
        System.out.println("------------");
        Son s2 = new Son("張三");  //不管子類是有參還是無參刺下，都走父類的無參構(gòu)造
    }
}

//運行結(jié)果
Father的無參構(gòu)造方法
Son的無參構(gòu)造方法
------------
Father的無參構(gòu)造方法
Son的帶參構(gòu)造方法

如果父類沒有無參構(gòu)造方法绑嘹，那么子類的構(gòu)造方法會報錯

如何解決
　　-在父類中加一個無參構(gòu)造方法
　　-通過使用super關(guān)鍵字去顯示的調(diào)用父類的帶參構(gòu)造方法
　　-子類通過this去調(diào)用本類的其他構(gòu)造方法
子類中一定要有一個去訪問了父類的構(gòu)造方法，否則父類數(shù)據(jù)就沒有初始化

注意事項：
　　this(...)或者super(...)必須出現(xiàn)在第一條語句上
如果不是放在第一條語句上橘茉，就可能對父類的數(shù)據(jù)進行了多次初始化工腋，所以必須放在第一條語句上

class Father {
    /*
    public Father() {
        System.out.println("Father的無參構(gòu)造方法");
    }
    */
    
    public Father(String name) {
        System.out.println("Father的帶參構(gòu)造方法");
    }
}

class Son extends Father {
    public Son() {
        super("隨便給");
        System.out.println("Son的無參構(gòu)造方法");
        //super("隨便給");
    }
    
    public Son(String name) {
        //super("隨便給");
        this();
        System.out.println("Son的帶參構(gòu)造方法");
    }
}

class ExtendsDemo7 {
    public static void main(String[] args) {
        Son s = new Son();  
        System.out.println("----------------");
        Son ss = new Son("張三");
    }
}
//結(jié)果
Father的帶參構(gòu)造方法
Son的無參構(gòu)造方法
----------------
Father的帶參構(gòu)造方法
Son的無參構(gòu)造方法
Son的帶參構(gòu)造方法

方法重寫
　方法重寫：子類中出現(xiàn)了和父類中方法聲明一模一樣的方法
　方法重載：本類中出現(xiàn)的方法名一樣姨丈，參數(shù)列表不同的方法，與返回值無關(guān)
　子類對象調(diào)用方法的時候：先找子類本身擅腰，再找父類
方法重寫的應(yīng)用：
　　當(dāng)子類需要父類的功能蟋恬，而功能主體子類有自己特有內(nèi)容時，可以重寫父類中的方法惕鼓，這樣筋现，即沿襲了父類的功能，又定義了子類特有的內(nèi)容

/*
  手機都有通話功能
  新手機通話完成后會顯示通話時間
*/
class Phone {
    public void call(String name) {
        System.out.println("給"+name+"打電話");
    }
}

class NewPhone extends Phone {
    public void call(String name) {
        //System.out.println("給"+name+"打電話");
        super.call(name);  //調(diào)用父類中的方法
        System.out.println("通話時長");
    }
}

class ExtendsDemo9 {
    public static void main(String[] args) {
        NewPhone np = new NewPhone();
        np.call("張三");  //結(jié)果：給張三打電話箱歧，通話時長
    }
}

方法重寫的注意事項
　-父類中私有方法不能被重寫
　　因為父類私有方法子類根本就無法繼承
　-子類重寫父類方法時，訪問權(quán)限不能更低
　　最好就一致
　-父類靜態(tài)方法一膨，子類也必須通過靜態(tài)方法進行重寫
子類重寫父類方法的時候呀邢，最好聲明一模一樣

練習(xí)
1：方法重寫和方法重載的區(qū)別?方法重載能改變返回值類型嗎?
方法重寫：
　　在子類中，出現(xiàn)和父類中一模一樣的方法聲明的現(xiàn)象豹绪。
方法重載：
　　同一個類中价淌，出現(xiàn)的方法名相同，參數(shù)列表不同的現(xiàn)象瞒津。
方法重載能改變返回值類型蝉衣，因為它和返回值類型無關(guān)。
Override：方法重寫
Overload：方法重載

2：this關(guān)鍵字和super關(guān)鍵字分別代表什么?以及他們各自的使用場景和作用巷蚪。

this:代表當(dāng)前類的對象引用
super:代表父類存儲空間的標識病毡。(可以理解為父類的引用，通過這個東西可以訪問父類的成員)

場景：
　成員變量：
　　this.成員變量
　　super.成員變量
　構(gòu)造方法：
　　this(...)
　　super(...)
　成員方法：
　　this.成員方法
　　super.成員方法
繼承版貓狗案例

/*
* 貓狗案例
* 分析：
* 貓類：
*   成員變量：
*       姓名屁柏，年齡啦膜，顏色
*   構(gòu)造方法：
*       有參跟無參
*   成員方法：
*       吃飯，睡覺淌喻，捉老鼠（貓?zhí)赜校?* 狗類：
*   成員變量：
*       姓名僧家，年齡，顏色
*   構(gòu)造方法：
*       有參跟無參
*   成員方法：
*       吃飯裸删，睡覺八拱，看門（狗特有）
*
* 把公共部門定義成一個類
* 動物類：
* 成員變量：
*       姓名，年齡涯塔，顏色
*   構(gòu)造方法：
*       有參跟無參
*   成員方法：
*       吃飯肌稻，睡覺
* */
class Animal {
   //姓名
   private String name;
   // 年齡
   private int age;
   // 顏色
   private String color;

   //構(gòu)造方法
   public Animal() {
   } //無參

   public Animal(String name, int age, String color) {  //有參
       this.name = name;
       this.age = age;
       this.color = color;
   }

   //成員方法：get,sat,吃飯，睡覺
   //姓名
   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   //年齡
   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       this.age = age;
   }

   //顏色
   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   //吃飯
   public void eat() {
       System.out.println(name + "吃飯");
   }

   //睡覺
   public void sleep() {
       System.out.println(name + "睡覺");
   }
}

   //貓類
class Cat extends Animal{
       //無參構(gòu)造
       public Cat(){}

       //有參構(gòu)造
       public Cat(String name,int age,String color){
           super(name, age, color);
       }
       public void playGame(){
           System.out.println(super.getName()+"捉老鼠");  //調(diào)用父類的成員方法伤塌，輸出姓名
       }
}

   //狗類
class Dog extends Animal{
       //無參構(gòu)造
       public Dog(){}

       //有參構(gòu)造
       public Dog(String name,int age,String color){
           super(name, age, color);
      }

       public void lookDoor(){
           System.out.println(super.getName()+"看門");
       }
}
class Text{  //測試類
   public static void main(String[] args) {
       //貓無參
       Cat cat = new Cat();
       cat.setName("小花");
       cat.setColor("花色");
       cat.setAge(18);
       cat.eat();
       cat.playGame();
       System.out.println(cat.getName()+cat.getAge()+cat.getColor());

       System.out.println("----------");
       //貓有參
       Cat cat1 = new Cat("甜甜",15,"藍色");
       cat1.playGame();
       cat.sleep();
       System.out.println(cat1.getName()+cat1.getAge()+cat1.getColor());

       System.out.println("----------");
       //狗無參
       Dog dog = new Dog();
       dog.setName("小黑");
       dog.setAge(17);
       dog.setColor("黑色");
       dog.eat();
       dog.lookDoor();
       System.out.println(dog.getName()+dog.getAge()+dog.getColor());

       System.out.println("----------");
       //狗類有參
       Dog dog1 = new Dog("小白",13,"白色");
       dog1.eat();
       dog1.lookDoor();
       System.out.println(dog1.getName()+dog1.getAge()+dog1.getColor());
   }
}
/*
結(jié)果：
小花吃飯
小花捉老鼠
小花18花色
----------
甜甜捉老鼠
小花睡覺
甜甜15藍色
----------
小黑吃飯
小黑看門
小黑17黑色
----------
小白吃飯
小白看門
小白13白色
*/

Day9

final關(guān)鍵字
繼承的代碼體現(xiàn)
由于繼承中方法有一個現(xiàn)象：方法重寫
所以灯萍，父類的功能，就會被子類給覆蓋掉,有些時候每聪，我們不想讓子類去覆蓋掉父類的功能旦棉，只能讓他使用,這個時候齿风，針對這種情況，Java就提供了一個關(guān)鍵字：final
final:最終的意思,常見的是它可以修飾類绑洛，方法救斑，變量

class Fu {
    //public void show() {  將show改為用final修飾
      public final void show {
        System.out.println("這里是絕密資源,任何人都不能修改");
    }
}

class Zi extends Fu {
      //Zi中的show就無法覆蓋Fu中的show
    public void show() {
        System.out.println("這是一堆垃圾");
    }
}

class ZiDemo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

final可以修飾類,方法,變量
特點:
final修飾類,該類不可以被繼承
final修飾方法,該方法不能被重寫
final修飾變量,該變量不能被重新賦值

final也可以修飾局部變量
　　基本數(shù)據(jù)類型的值不可以改變
　　引用數(shù)據(jù)類型的地址值不可以改變,但是該對象堆內(nèi)存的值可以改變

final修飾變量初始化時機
　　被final修飾的變量只能被賦值一次
　　在構(gòu)造方法完成前（非靜態(tài)的常量）

多態(tài)
是指同一個事物（對象），在不同時刻表現(xiàn)出來的不同的狀態(tài)真屯、
例：貓是貓脸候，貓也是動物
多態(tài)的前提：
　要有繼承關(guān)系
　要有方法重寫
　要有父類引用指向子類對象
　　父類 fu = new 子類();
用代碼體現(xiàn)一下多態(tài)

class Fu{
  public void show(){
    System,out.println("這是父類的show");
  }
}
class Zi extends Fu{  //要有繼承關(guān)系
  public void show(){
    System,out.println("這是子類的show");  //要有方法重寫
  }
}
class DuiTai{
  public static void main(String[] args){
    Fu fu = new Zi();  //要有父類引用指向子類對象
  }
}

多態(tài)中的成員訪問特點
　成員變量
　　編譯看左邊，運行看左邊
　構(gòu)造方法
　　創(chuàng)建子類對象的時候绑蔫，訪問父類的構(gòu)造方法运沦，對父類的數(shù)據(jù)進行初始化
　成員方法
　　編譯看左邊，運行看右邊
　靜態(tài)方法
　　編譯看左邊配深，運行看左邊
　　(靜態(tài)和類相關(guān)携添，算不上重寫，所以篓叶，訪問還是左邊的)
由于成員方法存在方法重寫烈掠，所以它運行看右邊

class Fu {
    public int num = 100;

    public void show() {
        System.out.println("show Fu");
    }
    
    public static void function() {  //靜態(tài)
        System.out.println("function Fu");
    }
}

class Zi extends Fu {
    public int num = 1000;
    public int num2 = 200;

    public void show() {
        System.out.println("show Zi");
    }
    
    public void method() {
        System.out.println("method zi");
    }
    
    public static void function() {  //靜態(tài)
        System.out.println("function Zi");
    }
}

class DuoTaiDemo {
    public static void main(String[] args) {
        //要有父類引用指向子類對象。
        //父 f =  new 子();
        Fu f = new Zi();
        System.out.println(f.num);  //輸出100缸托，成員變量運行看左邊
        //找不到符號左敌，成員變量編譯看左邊
        //System.out.println(f.num2);
        
        f.show();  //輸出showZi，成員方法運行看右邊俐镐，因為有方法重寫
        //找不到符號矫限，成員方法編譯看左邊，父類中沒有京革，所以找不到
        //f.method();
        f.function();  //輸出funcyion  Fu奇唤，靜態(tài)方法編譯看左邊，輸出看左邊
    }
}

多態(tài)的好處
提高了代碼的維護性（由繼承保證）
提高了代碼的擴展性（由多態(tài)保證）

class Animal {
    public void eat(){
        System.out.println("eat");
    }
    
    public void sleep(){
        System.out.println("sleep");
    }
}

class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃肉");
    }
    
    public void sleep(){
        System.out.println("狗站著睡覺");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("貓吃魚");
    }
    
    public void sleep() {
        System.out.println("貓趴著睡覺");
    }
}

class Pig extends Animal {
    public void eat() {
        System.out.println("豬吃白菜");
    }
    
    public void sleep() {
        System.out.println("豬側(cè)著睡");
    }
}

//針對動物操作的工具類
class AnimalTool {   
    private AnimalTool(){}

    /*
    //調(diào)用貓的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //調(diào)用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    
    //調(diào)用豬的功能
    public static void usePig(Pig p) {
        p.eat();
        p.sleep();
    }
    */
    public static void useAnimal(Animal a) {  //因為每添加一個動物類就要改工具類匹摇，所以直接改成動物類
        a.eat();
        a.sleep();
    }
    
}

class DuoTaiDemo2 {
    public static void main(String[] args) {
        //我喜歡貓咬扇，就養(yǎng)了一只
        Cat c = new Cat();
        c.eat();
        c.sleep();
        
        //我很喜歡貓，所以廊勃，又養(yǎng)了一只
        Cat c2 = new Cat();
        c2.eat();
        c2.sleep();
        
        //我特別喜歡貓懈贺，又養(yǎng)了一只
        Cat c3 = new Cat();
        c3.eat();
        c3.sleep();
        //...
        System.out.println("--------------");
        //問題來了,我養(yǎng)了很多只貓，每次創(chuàng)建對象是可以接受的
        //但是呢?調(diào)用方法坡垫，你不覺得很相似嗎?僅僅是對象名不一樣梭灿。
        //我們準備用方法改進
        //調(diào)用方式改進版本
        //useCat(c);
        //useCat(c2);
        //useCat(c3);
        
        //AnimalTool.useCat(c);
        //AnimalTool.useCat(c2);
        //AnimalTool.useCat(c3);
        
        AnimalTool.useAnimal(c);
        AnimalTool.useAnimal(c2);
        AnimalTool.useAnimal(c3);
        System.out.println("--------------");
        
        //我喜歡狗
        Dog d = new Dog();
        Dog d2 = new Dog();
        Dog d3 = new Dog();
        //AnimalTool.useDog(d);
        //AnimalTool.useDog(d2);
        //AnimalTool.useDog(d3);
        AnimalTool.useAnimal(d);
        AnimalTool.useAnimal(d2);
        AnimalTool.useAnimal(d3);
        System.out.println("--------------");
        
        //我喜歡寵物豬
        //定義一個豬類，它要繼承自動物冰悠，提供兩個方法堡妒，并且還得在工具類中添加該類方法調(diào)用
        Pig p = new Pig();
        Pig p2 = new Pig();
        Pig p3 = new Pig();
        //AnimalTool.usePig(p);
        //AnimalTool.usePig(p2);
        //AnimalTool.usePig(p3);
        AnimalTool.useAnimal(p);
        AnimalTool.useAnimal(p2);
        AnimalTool.useAnimal(p3);
        System.out.println("--------------");
        
        //我喜歡寵物狼，老虎溉卓，豹子...
        //定義對應(yīng)的類皮迟，繼承自動物搬泥，提供對應(yīng)的方法重寫，并在工具類添加方法調(diào)用
        //前面幾個必須寫伏尼，我是沒有意見的
        //但是忿檩，工具類每次都改，麻煩不
        //我就想爆阶，你能不能不改了
        //太簡單：把所有的動物都寫上燥透。問題是名字是什么呢?到底哪些需要被加入呢?
        //改用另一種解決方案。
        
    }
    
    /*
    //調(diào)用貓的功能
    public static void useCat(Cat c) {
        c.eat();
        c.sleep();
    }
    
    //調(diào)用狗的功能
    public static void useDog(Dog d) {
        d.eat();
        d.sleep();
    }
    */
}

多態(tài)的弊端
不能使用子類特有的功能

class Fu{
  public void show(){
    System.out.println(show 父類);
  }
}
class Zi extends Fu{
  public void show(){
    System.out.println(show 子類);
  }
  public void eat(){
    System.out.println("吃飯");
  }
}
class DuoTai{
  public static void main(String[] args){
    Fu fu = new Zi();
    fu.show();  //可以執(zhí)行
    fu.eat();  //不可以執(zhí)行辨图，父類不能訪問子類特有的功能
   }
}

如何解決多態(tài)的弊端：
　　-可以新建一個子類對象調(diào)用子類特有的方法
　　-向下轉(zhuǎn)型
　　　Zi z = (Zi) f; //要求該f必須能轉(zhuǎn)化成Zi的

對象間的轉(zhuǎn)型問題
向上轉(zhuǎn)型：
　　Fu f = new Zi();
向下轉(zhuǎn)型：
　　Zi z = (Zi)f; //要求該f必須是能夠轉(zhuǎn)換為Zi的

錯誤提示：ClassCastException:類型轉(zhuǎn)換異常班套，一般在多態(tài)的向下轉(zhuǎn)型中容易出現(xiàn)

多態(tài)版貓狗案例

class DongWu{  //動物類
    //吃飯
    public void eat(){
        System.out.println("吃飯");
    }

    //睡覺
    public void sleep(){
        System.out.println("睡覺");
    }
}
class Mao extends DongWu{  //定義貓類繼承動物類
    //吃飯
    public void eat(){
        System.out.println("貓吃魚");
    }

    //睡覺
    public void sleep(){
        System.out.println("貓趴著睡覺");
    }

    //貓玩游戲
    public void playGame(){
        System.out.println("貓玩捉迷藏");
    }
}
class Gou extends DongWu{  //定義狗類繼承動物類
    //吃飯
    public void eat(){
        System.out.println("狗吃肉");
    }

    //睡覺
    public void sleep(){
        System.out.println("狗站著睡覺");
    }

    //看門
    public void lookDoor(){
        System.out.println("狗看門");
    }
}
public class DuoTaiTest {
    /*
    * 用多態(tài)實現(xiàn)貓狗案例
    * 分析：
    *   多態(tài)要有繼承
    *   多態(tài)要有父類指向子類對象
    *   要有方法重寫
    * */
    public static void main(String[] args) {
        //將動物定義為狗
        DongWu dw = new Gou();
        dw.eat();
        dw.sleep();
        //無法執(zhí)行dw.lookDoor
        //還原為狗
        Gou g = (Gou)dw;
        g.lookDoor();
        System.out.println("--------");
        dw = new Mao();
        dw.sleep();
        dw.eat();
        Mao m = (Mao)dw;
        m.playGame();

    }

}

練習(xí)

/*
    看程序?qū)懡Y(jié)果:先判斷有沒有問題，如果沒有故河，寫出結(jié)果
*/
class Fu {
    public void show() {
        System.out.println("fu show");
    }
}

class Zi extends Fu {
    public void show() {
        System.out.println("zi show");
    }

    public void method() {
        System.out.println("zi method");
    }
}

class DuoTaiTest3 {
    public static void main(String[] args) {
        Fu f = new Zi();
        //找不到符號
        //f.method();  //有問題孽尽，多態(tài)中成員方法編譯看左邊，父類中沒有method方法忧勿，所以報錯，找不到符號
        f.show();  //可以運行瞻讽，編譯看左邊鸳吸，父類中有show方法，運行看右邊速勇，輸出右邊的子類show晌砾，子類重寫父類
    }
}

多態(tài)的成員訪問特點：
　　方法：編譯看左邊，運行看右邊
繼承的時候：
　　子類中有和父類中一樣的方法烦磁，叫重寫
　　子類中沒有父親中出現(xiàn)過的方法养匈，方法就被繼承過來了

/*
    看程序?qū)懡Y(jié)果:先判斷有沒有問題，如果沒有都伪，寫出結(jié)果

*/
class A {
    public void show() {
        show2();
    }
    public void show2() {
        System.out.println("我");
    }
}
class B extends A {
    /*
    public void show() {  //被繼承呕乎，相當(dāng)于有
        show2();
    }
    */

    public void show2() {
        System.out.println("愛");
    }
}
class C extends B {
    public void show() {
        super.show();
    }
    public void show2() {
        System.out.println("你");
    }
}
public class DuoTaiTest4 {
    public static void main(String[] args) {
        A a = new B();
        a.show();  //打印愛
        
        B b = new C();
        b.show();  //打印你
    }
}

抽象類
抽象類得聲明格式：用abstract修飾
例：abstract class Person

抽象類的概述：
　　動物不應(yīng)該定義為具體的東西，而且動物中的吃陨晶，睡等也不應(yīng)該是具體的猬仁，我們把一個不是具體的功能稱為抽象的功能，而一個類中如果有抽象的功能先誉，該類必須得是抽象類
抽象類的特點：
　　抽象類和抽象方法必須用abstract關(guān)鍵字修飾
　　抽象類中不一定有抽象方法,但是有抽象方法的類必須定義為抽象類
　　抽象類不能實例化湿刽，因為他不是具體的
　　抽象類有構(gòu)造方法，用于子類訪問父類數(shù)據(jù)的初始化
抽象的子類
　　抽象類褐耳，可以不重寫父類的抽象方法
　　具體類诈闺，必須重寫父類所有的抽象方法
抽象類的實例化其實是靠具體的子類實現(xiàn)的。是多態(tài)的方式
　　Animal a = new Cat();

//abstract class Animal //抽象類的聲明格式
abstract class Animal {
    //抽象方法
    //public abstract void eat(){} //空方法體,這個會報錯铃芦。抽象方法不能有主體
    public abstract void eat();  //空方法體
    
    public Animal(){}
}

//子類是抽象類
abstract class Dog extends Animal {}

//子類是具體類
class Cat extends Animal {
    public void eat() {
        System.out.println("貓吃魚"); //就需要重寫父類的所有抽象方法
    }
}

class AbstractDemo {
    public static void main(String[] args) {
        //創(chuàng)建對象
        //Animal是抽象的; 無法實例化
        //Animal a = new Animal();
        //可以通過多態(tài)的方式實現(xiàn)抽象類的實例化
        Animal a = new Cat();
        a.eat();
    }
}

抽象類的成員特點：
　　成員變量：既可以是變量雅镊，也可以是常量
　　構(gòu)造方法：有襟雷，用于子類訪問父類數(shù)據(jù)的初始化
　　成員方法：既可以是抽象的，也可以是非抽象的
抽象類的成員方法特性：
　　抽象方法 強制要求子類做的事情
　　非抽象方法 子類繼承的事情漓穿，提高代碼復(fù)用性

抽象類貓狗案例

貓狗案例
    具體事物：貓嗤军，狗
    共性：姓名，年齡晃危，吃飯

分析：從具體到抽象
    貓:
        成員變量：姓名叙赚，年齡
        構(gòu)造方法：無參，帶參
        成員方法：吃飯(貓吃魚)
        
    狗:
        成員變量：姓名僚饭，年齡
        構(gòu)造方法：無參震叮，帶參
        成員方法：吃飯(狗吃肉)
        
    因為有共性的內(nèi)容，所以就提取了一個父類鳍鸵。動物苇瓣。
    但是又由于吃飯的內(nèi)容不一樣，所以吃飯的方法是抽象的偿乖，
    而方法是抽象的類击罪，類就必須定義為抽象類。
    
    抽象動物類：
        成員變量：姓名贪薪，年齡
        構(gòu)造方法：無參媳禁，帶參
        成員方法：吃飯();

實現(xiàn)：從抽象到具體
    動物類:
        成員變量：姓名，年齡
        構(gòu)造方法：無參画切，帶參
        成員方法：吃飯();
        
    狗類：
        繼承自動物類
        重寫吃飯();
        
    貓類：
        繼承自動物類
        重寫吃飯();

代碼實現(xiàn)

/*
* 抽象類實現(xiàn)貓狗案例
*
* */
abstract class Animal {  //創(chuàng)建抽象類動物
    //姓名
   private String name;
    //年齡
   private int age;

   //構(gòu)造方法竣稽，無參，有參
    public Animal(){}

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }

    //成員方法霍弹，get和sat
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }

    //抽象方法
    abstract  void eat();
}

//定義具體類貓
class Cat extends Animal{
    //成員變量繼承

    //構(gòu)造方法
    public Cat(){}

    public Cat(String name,int age){
        super(name, age);
    }

    //成員方法
    public void eat(){
        System.out.println(super.getName()+"吃魚");
    }
}

//定義具體類狗
class Dog extends Animal{
    //成員變量繼承

    //構(gòu)造方法
    public Dog(){}

    public Dog(String name,int age){
        super(name, age);
    }

    //成員方法
    public void eat(){
        System.out.println(super.getName()+"狗吃肉");
    }
}

//測試類
class ChouXiangTest{
    public static void main(String[] args) {
        //創(chuàng)建對象
        //無參
        Cat c = new Cat();
        c.setName("小花");
        c.setAge(3);
        c.eat();
        System.out.println(c.getName()+"---"+c.getAge());

        //有參
        Cat c2 = new Cat("小白",5);
        c2.eat();
        System.out.println(c2.getName()+"---"+c2.getAge());

        //多態(tài)
        Animal a = new Dog();
        a.setName("小黑");
        a.setAge(5);
        a.eat();
        System.out.println(a.getName()+"----"+a.getAge());
    }
}

接口
特點：
　接口用關(guān)鍵字interface表示
　　interface 接口名 {}
　類實現(xiàn)接口用implements表示
　　class 類名 implements 接口名 {}
　接口不能實例化毫别，按照多態(tài)的方式來實例化
接口的子類
　可以是抽象類，但是意義不大
　可以是具體類典格，要重寫接口中的所有抽象方法(推薦方案)
由此可見：
A:具體類多態(tài)(幾乎沒有)
B:抽象類多態(tài)(常用)
C:接口多態(tài)(最常用)

//定義動物培訓(xùn)接口
interface AnimalTrain {
    public abstract void jump();
}

//抽象類實現(xiàn)接口
abstract class Dog implements AnimalTrain {
}

//具體類實現(xiàn)接口
class Cat implements AnimalTrain {
    public void jump() {
        System.out.println("貓可以跳高了");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        //AnimalTrain是抽象的; 無法實例化
        //AnimalTrain at = new AnimalTrain();
        //at.jump();
        
        AnimalTrain at = new Cat();
        at.jump();  //根據(jù)方法重寫的要求岛宦，執(zhí)行看右邊，所以輸出貓的jump钝计，貓可以跳高了
    }
}

接口成員特點
　　成員變量：只能是常量恋博，并且是靜態(tài)的
　　默認修飾符：public static final //自己寫出默認修飾符
　構(gòu)造方法：接口沒有構(gòu)造方法，因為接口主要是擴展功能私恬，沒有具體存在债沮，初始化靠父類Object
　成員方法：只能是抽象方法
　　默認修飾符：public abstract //自己寫出默認修飾符
所有的類都默認繼承自一個類：Object
類 Object 是類層次結(jié)構(gòu)的根類,每個類都使用 Object 作為超類
接口名+Impl這種格式是接口的實現(xiàn)類格式

interface Inter {
    public int num = 10;
    public final int num2 = 20;  //不寫全會默認給出
    public static final int num3 = 30;  //最終格式
    
    //錯誤: 需要<標識符>
    //public Inter() {}  //接口沒有構(gòu)造方法
    
    //接口方法不能帶有主體
    //public void show() {}  //說明是抽象的

    //abstract void show(); //默認public
    public void show(); //默認abstract
}

//接口名+Impl這種格式是接口的實現(xiàn)類格式
/*
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
}
*/

class InterImpl extends Object implements Inter {  //繼承自O(shè)bject
    public InterImpl() {
        super();
    }
    
    public void show() {}
}

//測試類
class InterfaceDemo2 {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Inter i = new InterImpl();
        System.out.println(i.num);
        System.out.println(i.num2);
        //i.num = 100;
        //i.num2 = 200;
        //System.out.println(i.num); //無法為最終變量num分配值,說明是final修飾
        //System.out.println(i.num2);//無法為最終變量num2分配值
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
        System.out.println("--------------");
    }
}

接口成員特點
　成員變量；只能是常量本鸣，并且是靜態(tài)的
　　默認修飾符：public static final 自己手動給出
　構(gòu)造方法：接口沒有構(gòu)造方法
　成員方法：只能是抽象方法
　　默認修飾符：public abstract　　自己手動給出
所有的類都默認繼承自一個類：Object
類 Object 是類層次結(jié)構(gòu)的根類疫衩。每個類都使用 Object 作為超類
接口名+Impl這種格式是接口的實現(xiàn)類格式

interface Inter {
    public int num = 10;
    public final int num2 = 20;  //沒寫的默認給出
    public static final int num3 = 30;  //最終格式
    
    //錯誤: 需要<標識符> 沒有構(gòu)造方法
    //public Inter() {}
    
    //接口方法不能帶有主體
    //public void show() {}

    //abstract void show(); //默認public
    public void show(); //默認abstract
}

//接口名+Impl這種格式是接口的實現(xiàn)類格式
/*
class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
}
*/

class InterImpl extends Object implements Inter {  //默認繼承自O(shè)bject類
    public InterImpl() {
        super();
    }
    
    public void show() {}
}

//測試類
class InterfaceDemo2 {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Inter i = new InterImpl();
        System.out.println(i.num);
        System.out.println(i.num2);
        //i.num = 100;
        //i.num2 = 200;
        //System.out.println(i.num); //無法為最終變量num分配值是final修飾默認
        //System.out.println(i.num2);//無法為最終變量num2分配值
        System.out.println(Inter.num);
        System.out.println(Inter.num2);
        System.out.println("--------------");
    }
}

類，接口之間的關(guān)系
類與類：
　　繼承關(guān)系,只能單繼承,可以多層繼承
類與接口：
　　實現(xiàn)關(guān)系,可以單實現(xiàn),也可以多實現(xiàn)荣德，并且還可以在繼承一個類的同時實現(xiàn)多個接口
接口與接口：
　　繼承關(guān)系,可以單繼承,也可以多繼承
一個類實現(xiàn)多繼承接口時闷煤，要重寫接口多繼承中的所有方法

interface Father {
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}

interface Sister extends Father,Mother {  //接口可以多繼承

}

//class Son implements Father,Mother //多實現(xiàn)
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }
    
    public void show2() {
        System.out.println("show2 son");
    }
}

class InterfaceDemo3 {
    public static void main(String[] args) {
        //創(chuàng)建對象
        Father f = new Son();
        f.show();
        //f.show2(); //報錯,方法看左邊童芹，左邊沒有show2
    
        Mother m = new Son();
        //m.show(); //報錯,方法看左邊，左邊沒有show
        m.show2();
    }
}

抽象類和接口的區(qū)別
成員區(qū)別
　抽象類：
　　成員變量：可以變量鲤拿，也可以常量
　　構(gòu)造方法：有
　　成員方法：可以抽象假褪，也可以非抽象
　接口：
　　成員變量：只可以常量
　　構(gòu)造方法：沒有
　　成員方法：只可以抽象

關(guān)系區(qū)別
　類與類
　　繼承，單繼承
　類與接口
　　實現(xiàn)近顷，單實現(xiàn)生音，多實現(xiàn)
　接口與接口
　　繼承，單繼承窒升，多繼承

設(shè)計理念區(qū)別
　抽象類 被繼承體現(xiàn)的是：”is a”的關(guān)系缀遍，抽象類中定義的是該繼承體系的共性功能
　接口 被實現(xiàn)體現(xiàn)的是：”like a”的關(guān)系，接口中定義的是該繼承體系的擴展功能(特有功能)

接口版貓狗案例

/*
* 需求：利用接口實現(xiàn)貓狗案例跳高功能
* 分析：從具體到抽象
*      貓：
*        成員變量：姓名饱须，年齡
*        構(gòu)造方法：有參無參
*        成員方法：睡覺域醇，吃飯
*      狗：
 *       成員變量：姓名，年齡
 *       構(gòu)造方法：有參無參
 *       成員方法：睡覺蓉媳，吃飯
 *     動物：
 *       成員變量：姓名譬挚，年齡
 *       構(gòu)造方法：有參無參
 *       成員方法：睡覺(){}，吃飯()抽象類酪呻，貓狗吃的不一樣
 *     調(diào)高功能：
 *        接口
* */
//實現(xiàn)：從抽象到具體
//調(diào)高功能
interface Jump{
    //跳高功能
    public abstract void jump();  //接口中只能用抽象的方法
}
//定義抽象動物類
abstract class Animal{
    //成員變量
    //姓名
    private String name;
    //年齡
    private int age;

    //構(gòu)造方法
    public Animal(){}  //無參
    public Animal(String name,int age){ //有參
        this.name =name;
        this.age = age;
    }

    //成員方法
    //get和sat
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    //睡覺
    public void sleep(){
        System.out.println("睡覺");
    }

    //吃飯定義為抽象類
    abstract void eat();
}

//定義具體類貓
class Cat extends Animal{
    //成員變量繼承
    //構(gòu)造方法
    public Cat(){}
    public Cat(String name,int age){
        super(name, age);
    }

    //成員方法殴瘦，繼承睡覺
    //重寫吃飯
    public void eat(){
        System.out.println("貓吃魚");
    }
}

//定義具體類狗
class Dog extends Animal{
    //成員變量繼承
    //構(gòu)造方法
    public Dog(){}
    public Dog(String name,int age){
        super(name, age);
    }

    //成員方法，繼承睡覺
    //重寫吃飯
    public void eat(){
        System.out.println("狗吃肉");
    }
}

//貓類實現(xiàn)跳高
class JumpImplCat extends Cat implements Jump{
    //成員變量繼承
    //構(gòu)造方法
    public JumpImplCat(){}
    public JumpImplCat(String name,int age){
        super(name, age);
    }

    //成員方法繼承睡覺吃飯
    //跳高
    public void jump(){
        System.out.println("貓?zhí)?);
    }
}

//狗類實現(xiàn)跳高
class JumpImplDog extends Cat implements Jump{
    //成員變量繼承
    //構(gòu)造方法
    public JumpImplDog(){}
    public JumpImplDog(String name,int age){
        super(name, age);
    }

    //成員方法繼承睡覺吃飯
    //跳高
    public void jump(){
        System.out.println("狗跳高");
    }
}
public class JiekouText {
    public static void main(String[] args) {
        //測試無參構(gòu)造貓
        JumpImplCat cat = new JumpImplCat();
        cat.setName("哆啦A夢");
        cat.setAge(3);
        cat.eat();
        cat.sleep();
        cat.jump();
        System.out.println(cat.getName()+"----"+cat.getAge());

        //測試有參構(gòu)造狗
        JumpImplDog dog = new JumpImplDog("小白",3);
        dog.eat();
        dog.sleep();
        dog.jump();
        System.out.println(dog.getName()+"-----"+dog.getAge());
    }
}

Day10

引用類型作為方法的形參
　　類名:(匿名對象的時候其實我們已經(jīng)講過了)需要的是該類的對象
　　抽象類:需要的是該抽象的類子類對象
　　接口:需要的是該接口的實現(xiàn)類對象

//類名作為方法的形式參數(shù)
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public void method(Student s) { //ss; ss = new Student();  Student s = new Student();
    s.study();
    }
}

class StudentTest {
    public static void main(String[] args) {
        //需求：我要測試Student類的study()方法
        Student s = new Student();  //創(chuàng)建對象
        s.study();  //調(diào)用方法
        System.out.println("----------------");
        
        //需求2：我要測試StudentDemo類中的method()方法
        StudentDemo sd = new StudentDemo();
        Student ss = new Student();
        sd.method(ss);
        System.out.println("----------------");
        
        //匿名對象用法
        new StudentDemo().method(new Student());
    }
}

//抽象類作為方法的形式參數(shù)
abstract class Person {
    public abstract void study();
}

class PersonDemo {
    public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多態(tài)
        p.study();
    }
}

//定義一個具體的學(xué)生類
//抽象類作為方法的形式參數(shù)
class Student extends Person {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest {
    public static void main(String[] args) {
        //目前是沒有辦法的使用的
        //因為抽象類沒有對應(yīng)的具體類
        //那么号杠，我們就應(yīng)該先定義一個具體類
        //需求：我要使用PersonDemo類中的method()方法
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
    }
}

//接口作為方法的形式參數(shù)
interface Love {
    public abstract void love();
}

class LoveDemo {
    public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多態(tài)
        l.love();
    }
}

//定義具體類實現(xiàn)接口
class Teacher implements Love {
    public void love() {
        System.out.println("老師愛學(xué)生,愛Java");
    }
}

class TeacherTest {
    public static void main(String[] args) {
        //需求：我要測試LoveDemo類中的love()方法
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

引用類型作為返回值
　　類:返回的是該類的對象
　　抽象類:返回的是該抽象類的子類對象
　　接口:返回的是該接口的實現(xiàn)類的對象

//類最為返回值
class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        //Student s = new Student();
        //Student ss = s;
        
        //Student s = new Student();
        //return s;
        return new Student();
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //需求：我要使用Student類中的study()方法
        //但是，這一次我的要求是丰歌，不要直接創(chuàng)建Student的對象
        //讓你使用StudentDemo幫你創(chuàng)建對象
        StudentDemo sd = new StudentDemo();
        Student s = sd.getStudent(); //new Student(); Student s = new Student();
        s.study();
    }
}

//抽象類作為返回值
abstract class Person {
    public abstract void study();
}

class PersonDemo {
    public Person getPerson() {
        //Person p = new Student();
        //return p;
        
        return new Student();
    }
}

class Student extends Person {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest2 {
    public static void main(String[] args) {
        //需求：我要測試Person類中的study()方法
        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多態(tài)
        p.study();
    }
}

//接口作為返回值
interface Love {
    public abstract void love();
}

class LoveDemo {
    public Love getLove() {
        //Love l = new Teacher();
        //return l;
        
        return new Teacher();
    }
}

//定義具體類實現(xiàn)接口
class Teacher implements Love {
    public void love() {
        System.out.println("老師愛學(xué)生,愛Java");
    }
}

class TeacherTest2 {
    public static void main(String[] args) {
        //如何測試呢?
        LoveDemo ld = new LoveDemo();
        Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多態(tài)
        l.love();
    }
}

鏈式編程
每次調(diào)用完畢后返回的是一個對象（只有對象才能繼續(xù)調(diào)方法）

class Student {
    public void study() {
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo {
    public Student getStudent() {
        return new Student();
    }
}

class StudentTest3 {
    public static void main(String[] args) {
        //如何調(diào)用的呢?
        StudentDemo sd = new StudentDemo();
        //Student s = sd.getStudent();
        //s.study();
                //相當(dāng)于下邊的
        sd.getStudent().study();
    }
}

包
　其實就是文件夾
作用
　把相同的類名放到不同的包中
　對類進行分類管理
　舉例：
　　學(xué)生：增加姨蟋，刪除，修改立帖，查詢
　　老師：增加眼溶，刪除，修改晓勇，查詢
　　...

方案1：按照功能分
　cn.itcast.add
　AddStudent
　AddTeacher

cn.itcast.delete
　DeleteStudent
　DeleteTeacher

cn.itcast.update
　UpdateStudent
　UpdateTeacher

cn.itcast.find
　FindStudent
　FindTeacher

方案2：按照模塊分
　cn.itcast.teacher
　AddTeacher
　DeleteTeacher
　UpdateTeacher
　FindTeacher

cn.itcast.student
　AddStudent
　DeleteStudent
　UpdateStudent
　FindStudent
包的定義
　package 包名;
　　多級包用.分開即可

注意事項:
　package語句必須是程序的第一條可執(zhí)行的代碼
　package語句在一個java文件中只能有一個
　如果沒有package堂飞，默認表示無包名

帶包的編譯和運行：
　手動式
　　編寫一個帶包的java文件
　　通過javac命令編譯該java文件
　　手動創(chuàng)建包名
　　把b步驟的class文件放到c步驟的最底層包
　　回到和包根目錄在同一目錄的地方，然后運行
　　帶包運行

自動式
　　編寫一個帶包的java文件
　　javac編譯的時候帶上-d即可
　　javac -d . HelloWorld.java
　　回到和包根目錄在同一目錄的地方绑咱，然后運行
　　帶包運行

導(dǎo)包
　格式：import 包名;
　這種方式導(dǎo)入是到類的名稱,注意：我們用誰就導(dǎo)誰
　例:import cn.itcast.Demo //Demo為類名

package,import,class的順序關(guān)系
　package > import > class
　　Package:只能有一個
　　import:可以有多個
　　class:可以有多個绰筛，以后建議是一個

權(quán)限修飾符的訪問
　　　　　本類 　同一個包下(子類和無關(guān)類) 　不同包下(子類) 不同包下(無關(guān)類)
private 　　Y
默認 　　　Y　　　　　Y
protected　Y　　　　　Y　　　　　　　　　　　　Y
public 　 　Y　　　　 　Y　　　　　　　　　　 　 Y　　　　　　　Y