java基礎筆記-面向物件2
8. static
8.1 概述
希望屬性or方法不歸具體的物件所有，而是屬於類，
隨著類的載入而載入
在記憶體池中，就存一份，在方法區的靜態域中
8.2 靜態屬性
static可以用來修飾： 屬性，方法，程式碼塊，內部類
class chinese{
private static String contory; //全記憶體就一份，所有物件共享
private String name;
}
8.3 靜態方法
呼叫關係，看生命週期
靜態方法中，不能使用this，super
8.4 單例模式
單例：單獨的一個例項，某個類只能建立一個物件
構造方法許可權為private，這樣不能在外部使用new來建立
在內部使用一個靜態方法來建立一個物件,同時，由於靜態方法只能訪問靜態成員變數，所以類的所有成員都得是靜態的
8.4.1建立單例模式的兩種方法
餓漢式 執行緒安全，但是物件載入時間過長
懶漢式 延遲物件的建立 執行緒不安全（兩個執行緒同時想建立單例物件，倆人判斷都是null，就各自會new一個）
//餓漢式 class Singleton1{ //私有構造方法 private Singleton1(){ pass; } //類內部建立物件 private static Bank ins = new Singleton1(); //提供共有方法返回類的物件 public static Singleton1 getInstance(){ return ins; } }
//懶漢式
class A{
private A(){
pass;
}
//聲明當前類物件，不初始化
private static A ins = null;
//提供共有方法返回類的物件
public static A getInsance（）{
if(ins==null){
ins = new A();
}
return ins;
}
}
8.4.2 使用場景
資料庫連線池，網站計數器，日誌處理，配置檔案類，windows工作管理員，回收站，Application
9. 程式碼塊 ( 初始化塊 )
{ 程式碼塊 } static{程式碼塊}
通常都是用來初始化類或者物件的，
只能用static修飾，或者不修飾
程式碼塊可以有多個，按著先後順序先後執行(沒必要寫倆靜態程式碼塊吧。)（甚至，沒必要寫程式碼塊）
9.1靜態程式碼塊
隨著類的載入而 執行！
就執行一次
9.2 非靜態程式碼塊
隨著物件的建立而執行
每建立一個物件都執行一次
作用：可以在物件建立時，對屬性進行初始化
10. final
final可以用來修飾 ：類（簡單的說，割了），方法（不可以被重寫，你爸爸給你用，但是不給你重寫），變數
10.1 final修飾方法和類
許可權 [final] class A{ }
[許可權] [final] [static] [final] 返回值 方法名()
被final修飾的類：String，System，StringBuffer
被final修飾的方法：Object的getClass()
10.2 final修飾變數和屬性
變數：變成常量了
屬性：賦值可以放在：顯式初始化位置，程式碼塊中，構造器中。 不能用在物件.屬性處
區域性變數: 方法內：變成常量
形參：方法體內就不能再修改了
10.3 static+final
static final 修飾屬性：全域性常量 常見於介面中
11. 抽象類，抽象方法
兒子太多，導致父類變成了一個公共東西的抽象，那麼實際使用對父類物件的使用就少了，那還要父類幹嘛，寫成抽象類，不做例項化了
abstract ： 用來修飾 類 ，方法
abstract class Person{
String name;
int age;
public Person（）{
}
}
class Sun{
}
11.1抽象類
一定要有構造方法，雖然自己不能用，但是可以給實現的子類來用
11.2 抽象方法
該類必須是抽象類
可以沒有抽象方法，可以有普通成員方法，這個成員方法還可以呼叫抽象方法
不能修飾構造方法，私有方法，靜態方法，final方法
11.3抽象類的匿名子類
真的很常見
抽象類的方法太多了就別用了！
abstract class Person{
public abstract void eat();
}
//方法宣告
public static void function(Person p){}
//呼叫
function(new Person{
@override
public void eat(){}
})
11,4 設計模式：模板方法
功能內部的一部分是現實確定的，一部分是現實不確定的，這時可以把不確定的部分暴露出去，留給子類來實現
12. interface
介面的最主要目的就是實現多繼承，次要目的就是單純的抽象多個類的公共特徵
implements 實現
實現類如果沒有implements介面中的所有方法，則該類是一個抽象類
12.1 介面的成員：
JDK7:
全域性常量： public static final
抽象方法：public abstract
JDK8+：
還可以定義：
靜態方法: 可以有方法體（介面越來越像類靠齊了）
但是有個介面A{ static func1()}，實現類B b，呼叫時 b.func1()
只能A.func1();
預設方法：預設方法使用default修飾，可以通多實現類物件呼叫 ，可以重寫，但是要去掉default
絕對不能定義構造方法
interface Flyable{
//全域性常量
public static final int MAX_SPEED =7900;
int MIN_SPEED =7900; //同上，省略了(包括省略了public)
//抽象方法
public abstract void fly();
void stop();//省略同上
//靜態方法
public static void method1(){
}
//預設方法
public default void method2(){} //default預設 得寫
default void method3(){} //省略
}
12.2介面的繼承性
java可以多實現介面，介面之間可以多繼承！！！
12.3 (多繼承)帶來的重名問題
父類和介面中有重名函式 ,規定，子類不重寫則預設用父類的 --類優先原則
class A extends B implements C{ }
倆接口裡面有重名函式，規定：
<1>如果定義的是預設方法，則實現類必須重寫(介面衝突)，如果想使用介面的預設方法，則B.super.func()
class A implements B，C{ }
12.3 介面的使用(多型)
interface USB{
void start();
void stop();
}
class Flash implements USB{
public void start(){}
public void stop(){}
}
class Computer{
public void transferData(USB sub){
usb.start();
...
usb.stop();
}
}
main(){
Computer com =new Computer();
//非匿名實現類的物件
Flash flash =new Flash();
com.transferData(flash)
//匿名實現類的匿名物件
comg.transferData(new USB{
public void start(){}
public void stop(){}
});
}
12.4設計模式：代理模式
使用較多
就是為其他物件提供一種代理以控制對這個物件的訪問
一個介面，被倆類實現，一個代理類，一個被代理類
interface NetWork{
public void browse();
}
//被代理類
class Server implements NetWork{
@oiverride
public void browse(){}
}
//代理類
class ProxyServer implements NetWork{
private NetWork work;
public ProxyServer(NetWork work){
this.work = work;
}
public void check(){
sout("聯網前的檢測");
}
@override
public void browse(){
check();
work.browse();
}
}
main(){
Server server = new Server();
ProxyServer proxyServer = new ProxyServer(server);
proxyServer.browse();
}
應用場景： 安全代理，遮蔽對真實角色的直接訪問
遠端代理：通過代理類處理遠端方法呼叫（RMI）
延遲載入：先載入輕量級的代理物件，真正需要再載入真是物件
12.5設計模式：工廠模式
13. 內部類
內部類 TM只出現在面試中吧。。。。
自己做開發沒事閒的扯什麼犢子寫這玩意。。。
活著不好麼？？？
分類：成員內部類(static成員內部類，和非static成員內部類)
區域性內部類(方法內，程式碼塊內，構造方法內)，匿名內部類
class Person{
public void method(){
class A{}//方法體內區域性innerclass
}
{
class B{}//程式碼塊內區域性innerclass
}
public Person(){
class C{}//構造方法內區域性innerclass
}
class Heat{//成員內部類
}
}
13.1成員內部類
作為類的成員：
>能呼叫外部類的東西，但是要注意靜態的關係
>innerclass裡面的this指的是內部類，想要呼叫外部類的屬性，A.this.func()
>可以被四種許可權修飾
作為一個類：
>類內可以定義的東西：當初普通類就行
>可以被繼承，可以被final修飾，可以抽象
class A{
class B{
int age;
public void show(){}
}
static class C{
int age
}
}
13.2內部類的例項化 及區分
class Person{
String name;
public void eat(){sout("人吃飯")}
static class Dog{
String name;
public void eat(){sout("狗吃飯")}
}
class Bird{
String name;
public void eat(){sout("鳥吃食")}
//區分同名屬性
public void display( String name){
sout(name);
sout(this.name);
sout(Person.this.name);
}
}
}
main(){
Person.Dog dog = new Person.Dog(); //建立靜態成員內部類
dog.eat();
Person p = new Person();
Person.Bird bird = p.new Bird();//建立 非靜態成員內部類
bird.eat();
}
13.3 區域性內部類
注意：方法體內的內部類，使用了方法體裡面的區域性變數，這個變數必須是final，哪怕你不宣告，它也會預設final，你敢改變數值，他就敢報錯
JDK6之前，不寫final也報錯
why:區域性變數的宣告週期，除了函式，就沒了，而類呢，哪怕是區域性類，他也是直到不用了才銷燬的，問題來了，類還在，變數沒了，咋辦？ 只能final
class Person{
//開發中巨少見
public void method(){
class A{}//方法體內區域性innerclass
}
//真實情況，返回一個實現了Comparable介面的類的物件
//方法1
public Comparable getComparable(){
class MyComparable implements Comparable{
...
}
return new MyComparable();
}
//方法2，不標準
public Comparable getComparable(){
return new Comparable(){
@override
...
};
}
{
class B{}//程式碼塊內區域性innerclass
}
public Person(){
class C{}//構造方法內區域性innerclass
}
}