java——三大特性

**chp6 三大特性
封裝 繼承 多態
1、封裝：**

對象的邊界對對象的內部起到保護的作用：
數據隱藏
public 公開的 不受邊界的約束
private 私有 只能在本類內部訪問 無法突破邊界
屬性私有 提供公開的setXXX/getXXX用來訪問屬性
方法私有 只給自己調用
方法公開：聲明公開 實現隱藏
實現的改變對架構的影響最小
數據左移一位與數據*2是一樣的
a*2 a<<1

package chp6;
public class TestEncapsulation{
  public static void main(String[] args){
     CreditCard card=new CreditCard();
     System.out.println(card.getPassword());
     //card.password="1234";
     card.setPassword("1234");
     //card.password="1234";
     //card.password="654321";
     System.out.println(card.getPassword());
  }
}
class CreditCard{
  private String password="123456";
  public String getPassword(){
       return password;
  }
  public void setPassword(String password){
      if(password.length()!=6)return;
      this.password=password;
  }
}

2、繼承
父類–子類 一般–特殊 父類：子類的共性抽象出來
動物 狗 貓
關鍵字 extends
創建子類對象要首先創建父類對象。
父類對象包含在子類對象當中。
所有的子類能夠訪問的父類屬性和方法，即是子類從父類中繼承的屬性和方法。
從嚴到寬
private 私有 本類內部 不能繼承
（default） 本類+同包 同包子類可以繼承
protected 受保護的 本類+同包+不同包的子類 可以繼承
public 公開 可以繼承

構造方法不能繼承

方法的覆蓋（Override）

子類用特殊的方法實現替換父類繼承給它的一般的方法實現。

返回值類型 方法名 參數表 訪問修飾符相同或更寬。

3、多態
多態：
子類的對象可以看作是父類的對象
子類對象可以放入父類引用

1）對象類型不變
2）只能對引用調用其引用類型中聲明的方法
3）運行時，根據對象實際類型找子類覆蓋之後的方法

子類引用賦值給父類引用 可以直接賦值
父類引用賦值給子類引用 必須強制類型轉換
運行時可能發生類型轉換異常
在做強制類型之前，可以用instanceof判斷， 避免類型轉換異常。

package chp6;
public class TestPolymorphism{
    public static void main(String[] args){
    Animal a=new Dog();
    System.out.println(a instanceof Dog);
    System.out.println(a instanceof Cat);
    System.out.println(a instanceof Animal);

    a.eat();
    a.sleep();
    if(a instanceof Dog){
    Dog d=(Dog)a;
    d.shot();
    }

    }
}
class Animal{
    public Animal(){}
    public void eat(){
        System.out.println("Animal.eat()");
    }
    public void sleep(){
    System.out.println("6 hours");
    }
}
class  Dog extends Animal{
    public Dog(){}
    public void eat(){
        System.out.println("Dog.eat()");
    }
    public void sleep(){
    System.out.println("8 hours");
    }
}
class Cat extends Animal{
    public Cat(){}
    public void eat(){
        System.out.println("Cat.eat()");
    }
    public void sleep(){
    System.out.println("8 hours");
    }
}

多態的作用：
將不同的子類對象統一看作父類對象，就屏弊了不同子類的差異

package chp6;
public class TestPloy2{
public static void main(String[] args){
    Animal[] a=new Animal[10];
    a[0]=new Dog();
    a[1]=new Cat();
    a[2]=new Tiger();
    a[3]=new Sheep();
    a[4]=new Wolf();
    a[5]=new Snake();
    a[6]=new Mouse();
    a[7]=new Cock();
    a[8]=new YellowMouseWolf();
    a[9]=new Monkey();
    for(int i=0;i<a.length;i++){
        a[i].eat();
    }
   /*Dog a0=new Dog();
   Cat a1=new Cat();
   Tiger a2=new Tiger();
   Sheep a3=new Sheep();
   Wolf a4=new Wolf();
   Mouse a5=new Mouse();
   Snake a6=new Snake();
   Monkey a7=new Monkey();
   Cock a8=new Cock();
   YellowMouseWolf a9=new YellowMouseWolf();
    a0.eat();
    a1.eat();
    a2.eat();
    a3.eat();
    a4.eat();
    a5.eat();
    a6.eat();
    a7.eat();
    a8.eat();
    a9.eat();*/
}
}
class Animal{
   public void eat(){
   }
}
class Dog extends Animal{
   public void eat(){
     System.out.println("Dog eat bone");
   }
}
class Cat extends Animal{
   public void eat(){
     System.out.println("Cat eat fish");
   }
}
class Tiger extends Animal{
   public void eat(){
     System.out.println("Tiger eat human");
   }
}
class Sheep extends Animal{
   public void eat(){
     System.out.println("Sheep eat grass");
   }
}
class Wolf extends Animal{
   public void eat(){
     System.out.println("Wolf eat Sheep");
   }
}
class Mouse extends Animal{
   public void eat(){
     System.out.println("Mouse eat rice");
   }
}
class Snake extends Animal{
   public void eat(){
     System.out.println("Snake eat mouse");
   }
}
class Monkey extends Animal{
   public void eat(){
     System.out.println("Monkey eat banner");
   }
}
class Cock extends Animal{
   public void eat(){
     System.out.println("Cock eat rice");
   }
}
class YellowMouseWolf extends Animal{
   public void eat(){
     System.out.println("YellowMouseWolf eat Cock");
   }
}

多態的常見用法
Animal a=new Dog();
1）多態用在方法參數上 形參可以是父類引用，實參可以傳子類對象
m（A a）:可以用A的任何子類對象作爲參數
2）多態用在方法的返回值上
A m():m方法完全可以返回A的某個子類對象

package chp6;
public class TestPoly3{
public static void main(String[] args){
   Dog d=new Dog();
   m1(d);
   Cat c=new Cat();
   m1(c);
   Animal a1=m2(10);

}
ststic void m1(Animal a){
}
ststic Animal m2(int k){
    if(k%2==0)return new Dog();
    else return new Cat();
}
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}