面向物件

1.面向物件

關注物件能完成哪些功能

• 優點：耦合低，擴充套件力強，更易解決複雜業務邏輯，元件可複用
• 缺點：前期投入產成本高，需要進行獨立體的抽取，大量的系統分析與設計
• 三大特性：封裝、繼承、多型

2.面向過程

關注現實的具體過程，因果關係

• 優點：對業務邏輯簡單的程式可以快速開發，前期投入低
• 缺點：對複雜業務邏輯不易解決，耦合度高，一個環節出錯整個系統受影響，擴充套件力差，沒有獨立體的概念，無法元件複用

3.構造器

• 和類名相同
• 無返回值
• dea快捷生成構造器alt+insert

public 類名（）{
    //無參構造
}
public 類名（）{
    this.name="zhangsan";
    //有參構造
}
 

一個類即使什麼也不寫也會存在一個無參構造（不顯示），若生成了有參構造器，則預設的無參構造丟失，必須手動加上

4.封裝

屬性私有，加上priavte關鍵字，使用get和set方法去訪問

class Person{
  	 private String name;//屬性私有
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
 }

快捷生成get和set方法：alt+insert

在set方法中設定屬性合法控制，如年齡在0~150以內

5.繼承

• Java中只有單繼承沒有多繼承，但一個父類可以有多個子類

• 類和類之間的關係

• java中所有類預設繼承Object類

• 使用關鍵字extends

• 子類繼承了父類就會擁有父類的全部方法

• 父類中私有的方法屬性無法被繼承

• super 用於在子類中呼叫父類的方法屬性

• 呼叫子類的無參構造時會預設先呼叫父類的無參構造

 class Person{
    String name;
     public Person(){
          System.out.println("老師");
     }
}
 class Student extends Person{
    String no;
    public Student(){
        super();//預設存在，且只能在第一行
        System.out.println("學生");
    }
} 

//結果先列印老師再列印學生！！！！！！！！！！！！！！！
 

6.重寫

• 只針對方法，方法名相同，引數列表相同

• 修飾符：範圍可以擴大但不能縮小

  • public>Protected>Default（空）>private

• 丟擲的異常：範圍可以被說笑，但不能擴大

• 子類中可以重新父類中的非靜態方法（例項方法）且是public！！

  class Person{
      public void say(){
          System.out.println("hello");
      }
  }
  class Student extends Person{
       public void say(){
          System.out.println("你好");
      }
  }
  public void test(){
      Student s=new Student();
   	s.say();   
  }
  //列印你好！！！！
  

• 重寫後再呼叫以子類為準

• 快捷鍵：alt+insert--->override

7.多型

• 方法的多型，與屬性無關

• 父類引用可以指向子類

• 父型別引用不能呼叫子類獨有方法

  public void test(){
      Person zhangsan=new Student();//父類引用指向子類物件
      zhangsan.say();//呼叫重寫後的方法，列印你好！！
      zhangsan.study();//編譯報錯，Person型別沒有此方法，儘管實際物件是Student！！！
      ((Student)zhangsan).study();//通過，強制轉換
  }
  class Person{//父類
      pubilc void say(){}
  }
  class Student extends Person{//子類
      public void say(){
          System.out.println("你好");//重寫
      }
      public void study(){}//子類獨有方法
  }
  

• 型別轉換異常 ClassCastException

​ instanceof

class Person{}
class Student extends Person{} 
class Teacher extends Person{}
public void test(){
  Person p=new Student();
  Student s=new Student();
  p instanceof Person;//true
  p instanceof Student;//true
  p instanceof Teacher;//false，編譯通過，Person與Teacher有父子關係，但p指向Student而非Teacher，所以false
  s instanceof Teacher;//編譯不通過，Student與Teacher沒有父子關係
}

向上轉型：子類轉化為父類，可以直接轉換

​ 可能失去一些子類獨有的方法

class Person{}
class Student extends Person{} 
public void test(){
 Student s=new Student();
 Person  p=s;//直接轉化
}

向下轉型：父類轉化為子類，用強制轉化

class Person{}
class Student extends Person{} 
public void test(){
 Person  p=new Student();
 Student s=(Student)p;
}

8.static

import static java.lang.Math.random;//靜態匯入包，後面就可以直接使用random();方法public class Person{    {//匿名程式碼塊，在靜態程式碼塊之後執行，可用於賦初值}    static{        //靜態程式碼塊        //在類載入時執行，只執行一次    }          private static int age;//靜態變數，通過類名.age訪問	public static void max(int a,int b){        //靜態方法，類名.max(a,b);呼叫        //多是功能方法，如求最大值    }     }

9.抽象類

• 在宣告類或方法時加abstract關鍵字
• 抽象類的抽象方法必須由子類來實現，否則會編譯報錯
• 不能new出抽象類，只能被繼承
• 抽象類裡可以有普通方法，但抽象方法只能寫在抽象類中
• 抽象類有構造方法，供子類使用

public abstract class Action{    public abstract void dosomethong();    //抽象方法，只有方法名，沒有方法的實現}

10.介面

普通類：只有具體實現

抽象類：具體實現與規範（抽象方法）都有

介面：只有規範！！！

宣告介面的關鍵字：interface

• 介面不能例項化，沒有構造方法

• 接口裡的方法預設抽象：public abstract

• 接口裡的屬性都預設常量：public static final

• 介面都需要實現類，實現類類名以Impl結尾

• 介面可以多繼承！！！繼承的多個介面以逗號分開

public interface Service{    void run();//前面預設有public abstract}public interface add{}public class UserServiceImpl implements Service,add{    public void run(){        //必須重寫（實現）    }}

11.內部類

1.成員內部類

public class Demo05 {    public static void main(String[] args) {        Outer o=new Outer();        Outer.Inner in=o.new Inner();//!!!!!!!!!!!!!!!!!        o.out();        in.in();        in.getId();        in.getOut();    }}class Outer{    private int id=10;    public void out(){        System.out.println("外部類方法");    }    public class Inner{//內部類        public void in(){            System.out.println("內部類方法");        }        public void getId(){//內部類讀外部類私有屬性            System.out.println(id);        }        public void getOut(){//內部類訪問外部類方法            out();        }    }}

2.靜態內部類

public class Demo05 {    public static void main(String[] args) {        Outer o=new Outer();         }}class Outer{    private int id=10;    public void out(){        System.out.println("外部類方法");    }    public static class Inner{//靜態內部類        public void in(){            System.out.println("內部類方法");        }       //靜態內部類裡無法訪問外部類的屬性和方法！！！！！！！！！！！！    }}

3.區域性內部類

在方法中定義的類

public class M{
    public void m(){
        class Inner{//區域性內部類
            public void in(){
                
            }      
        }
    }
}

4.匿名內部類

public class Test{
    public static void main(String[] args) {
    new Apple().eat();//匿名內部類，不用將例項儲存到引用裡  
    UserService u=new UserService();//???
           
    }
}
class Apple{
    public void eat(){}
}
interface UserService{
    
}