JAVA初窺-DAY08

面向程序與面向物件

面向程序：注重的是某件事情程序中的每一個步驟的實作，
面向物件：把面向程序中的每一個步驟交給一個物件去管理，只需要去用這個物件即可，
類的語法：訪問限定修飾符+class+類名（大駝峰） 訪問限定修飾符可省略，一般面向物件不使用public來定義類，
類就相當于一個房子模板，通過這個模板可以建造很多的房子，而類（模板）可以產生很多物件（相當于物體），這個程序，就叫實體化，
每個類都由兩部分組成，分別為屬性和行為，
實作面向物件：開發的時候，找物件，創建物件，使用物件，
在main方法是static型別的，而在static型別中只能呼叫static型別的方法，如果要呼叫其他類的方法，則需要new一個物件，通過這個物件去呼叫方法，如：

public class Demo01{
	public static void main(String[] args){
		Person per = new Person();//實體化,現在Person中的lit是真正存在了  
		per.eat();//此時lit這個人呼叫eat方法，輸出lit吃飯
		per.sleep();
	}
}
class Person{//用class來定義類，Person為類名，此處建立一個叫Person的類
	//1.屬性  成員變數
	public String name = "lit";
	public int age = 18;
	public String sex = "男";
	//這里都是普通成員變數
	public static int qqq = 0;//qqq為靜態成員變數

	//2.行為  成員方法
	public void eat(){//此處為普通成員方法
		int aaa = 0;//區域變數
		System.out.println(name+"吃飯！");
	}
	public void sleep(){
		System.out.println(name+"睡覺！");
	}
	public static void zzz(){//此處為靜態成員方法
	}
}

實體化及呼叫普通方法和普通成員變數

當用Person定義變數且new Person()后，用Person型別定義的變數就為一個物件，就可以利用這個物件去呼叫Person類里的方法，如：per.eat()，但是上面的代碼每次new一個Person型別的變數時，屬性都不變，則需：

public class Demo01{
	public static void main(String[] args){
		Person per = new Person();//實體化，創建物件
		System.out.println(per.name);
		System.out.println(per.age);
		System.out.println(per.sex);
		per.name = "lit";//參考.成員變數
		per.age = 18;
		per.sex = "男";
		System.out.println(per.name);
		System.out.println(per.age);
		System.out.println(per.sex);
		per.show();
	}
}
class Person{
	public String name;
	public int age;
	public String sex;
	public void show(){
		System.out.println("姓名："+name+"，年齡："+age+"，性別："+sex);
	}
}

成員變數如果沒有初始化，那么它的值就為所對應型別的默認值，

靜態成員方法與靜態成員變數的呼叫

靜態成員方法與靜態成員變數需要用類名來呼叫，如：

public class Demo01{
	public static void main(String[] args){
		Person per = new Person();
		Person.qqq();//輸出qqq方法被呼叫了
		System.out.println(Person.count);//輸出1
		System.out.println(per.count);//合法，但不合理不推薦這么呼叫
	}
}
class Person{
	public static int count = 1;
	public static void qqq(){
		System.out.println("qqq方法被呼叫了");
	}
}

靜態成員變數及靜態成員方法不依賴與物件

public static void main(String[] args){
        Person per = null;
        Person.qqq();//輸出qqq方法被呼叫了
        per.qqq();
        System.out.println(per.age);
        //空指標例外  普通成員變數會依賴物件 每個物件都有自己的屬性和值 但是靜態成員變數中，變數是跟物件沒關系的，所以建議類名.靜態變數/方法
    }
}
class Person{
    public  int age = 10;
    public static void qqq(){
        System.out.println("qqq方法被呼叫了");
    }
}

在這里，類就相當于一個班級，而物件就相當于班級里的人，而獲獎可以理解為一個屬性或方法，如果班級獲獎了，那么獲獎這個屬性是班級的，也就是這個屬性是類的，也就是靜態成員屬性，我們說班級里的人獲獎了，可以是可以，合法不合理，但是如果班級里某人獲獎了，此時為普通成員變數，只跟某個成員有關，我們就不能說班級獲獎了，不合法也不合理，
同理，在靜態成員方法中可以修改靜態成員屬性的值，可以呼叫靜態成員方法，但是如果要呼叫普通成員方法，必須new一個物件，通過物件.方法/屬性才可已呼叫，在普通成員方法里可以直接呼叫靜態成員屬性/方法，

public int name ;//普通成員變數，物件的屬性，存盤在物件內，
public static int count;//類變數也叫靜態變數，屬于類本身
public final SIZE;//常量，也屬于物件，
public static final COUNT;//靜態常量，屬于類本身，

final修飾的常量一定要大寫，常量頂以后不能修改，

封裝

OOP思想：ObjectOrientedProgramming，就是面向物件的編程，OOD就是面向物件的設計，OOA就是面向物件的分析，
OOP的特征：繼承、封裝、多型，
什么是封裝：使用關鍵字private來修飾成員變數或者成員方法，然后同意提供對應的get、set方法，這樣做的好處是：類的呼叫者的使用類的成本大大降低，

public class Demo01{
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("lit");
        stu.setAge(18);
        stu.setSex("男");
        stu.eat();
        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu.getSex());
        stu.toString()
    }
}
class Student{
    private String name;
    private int age;
    private String sex;

    public void eat(){
        System.out.println(name+"eat");
    }
    public String getName() {//ALT + INS 快捷鍵選擇getter and setter
        return name;
    }
    public void setName(String name) {
    	//此處的區域變數若跟普通成員變數的變數名一樣的話，則寫為name=name;但是會被默認為兩個name都為區域變數，所以引入this工具
    	//這里this只能在方法的第一行使用表示的是當前物件，
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {// ALT+INS 快捷鍵選ToString
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

this的使用：this.data:訪問成員變數，this.func():呼叫成員方法，this():呼叫構造方法 ，this雖然可以訪問靜態成員變數/方法，但是還是建議用類名去訪問，而在靜態方法內部，不能用this

構造方法

構造方法就是沒有回傳值的一個方法，且方法名和類名相同，
每個類會有一個默認的不帶引數的構造方法，當一個類提供了其他的構造方法，那么編譯器將不會幫我們自動生成不帶有引數的構造方法，
實體化一個物件分為兩步，為物件分配記憶體、呼叫合適的構造方法，這就意味著構造方法不止一個，
構造方法完成之后，你才真正有了一個物件，
而this就代表當前物件的參考

public static void main(String[] args){
	Person per1 = new Person();//呼叫不帶有引數的構造方法
	Person per2 = new Person("lit");//呼叫帶有引數的構造方法 
    }
}
class Person{
	public String name = "lit";
    public int age = 10;
    public Person(){//不帶有引數的構造方法
    	this(caocao);//呼叫帶有一個引數的構造方法，同樣this只能放在第一行，
    }
    public Person(String name){//帶有引數的構造方法
    	this.name = name;//把傳過來的引數給普通成員變數
    }
}

代碼塊

本地代碼塊：
實體代碼塊：也叫構造代碼塊，一般初始化實體資料成員，每new一個物件就執行一次
靜態代碼塊：只能初始化靜態資料成員，只會執行一次
執行順序：先執行靜態的，再執行實體的，若有多個靜態或實體，則按順序來

public static void main(String[] args){
	Person per1 = new Person();
	System.out.println(per1.age);
	System.out.println(Person.count);
	System.out.println("--------------------------");
	Person per2 = new Person();
	System.out.println(per2.age);
	System.out.println(Person.count);
    }
}
class Person{
	{//實體代碼塊
    age = 20;
    System.out.println("11111111");
    }
    static {//靜態代碼塊
    count = 2;
    System.out.println("22222222");
    }
	public String name = "lit";
    public int age = 10;
    public static int count =1
    static {
    couynt = 3;
    System.out.println("33333333");
    }
    {
    age = 30;
    System.out.println("44444444");
    }
}

匿名物件

如果某個物件只需呼叫一次，則可以使用匿名物件，

new Person().eat();//之后找不到這個物件，因為沒有物件名，