抽象類

• abstract修飾符可以用來修飾方法也可以修飾類，如果修飾方法，那麼該方法就是抽象方法；如果修飾類，那麼該類就是抽象類。
• 抽象類中可以沒有抽象方法，但是有抽象方法的類一定要宣告為抽象類。
• 抽象類，不能使用new關鍵字來建立物件，它是用來讓子類繼承的。
• 抽象方法，只有方法的宣告，沒有方法的實現，它是用來讓子類實現的。
• 子類繼承抽象類，那麼就必須要實現抽象類沒有實現的抽象方法，否則該子類也要宣告為抽象類。

package com.oop.demo08;

//abstract 抽象類：類 extends：   單繼承~     （介面可以多繼承）
public abstract class Action {

    //約束~有人幫我們實現~
    //abstract，抽象方法，只有方法名字，沒有方法的實現！
    public abstract void doSomething();

}
 

package com.oop.demo08;

//抽象類的所有方法，繼承了它的子類，都必須要實現它的方法~除非子類也抽象，再由子子類實現
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

1. 不能new這個抽象類，只能靠子類去實現它；約束！
2. 抽象類中可以寫普通的方法~
3. 抽象方法必須在抽象類中~

抽象的抽象：約束~

存在的意義：抽象出來，提高開發效率

介面

• 普通類：只有具體實現
• 抽象類：具體實現和規範（抽象方法）都有！
• 介面：只有規範！自己無法寫方法_{專業的約束！約束和實現分離：面向介面程式設計}
• 介面就是規範，定義的是一組規則，體現了現實世界中“如果你是...則必須能...”的思想。如果你是天使，則必須能飛。如果你是汽車，則必須能跑。如果你是好人，則必須幹掉壞人；如果你是壞人，則必須欺負好人。
• 介面的本質是契約，就像我們人間的法律一樣。制定好後大家都遵守。
• OO的精通，是對物件的抽象，最能體現這一點的就是介面。為什麼我們討論設計 模式都只針對具備了 抽象能力的語言（比如c++、java、c#等），就是因為設計模式所研究的，實際上就是如何合理的去抽象。

宣告類的關鍵字是class，宣告介面的關鍵字是interface

package com.oop.demo09;

//抽象的思維~Java

//interface 定義的關鍵字， 介面都需要有實現類
public interface UserService {

    //常量~public static final
    int AGE = 99;

    //介面中的所有定義其實都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
 

package com.oop.demo09;

public interface TimeService {
    void timer();
}

package com.oop.demo09;

//抽象類：extends~
//類  可以實現介面 implement  介面
//實現了介面的類，就需要重寫介面中的方法

//多繼承~利用介面實現多繼承~
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

作用(小結)：

1. 約束
2. 定義一些方法，讓不同的人實現~
3. public abstract
4. public static final
5. 介面不能被例項化_{，介面中沒有構造方法}
6. implement可以實現多個介面
7. 必須要重寫介面中的方法~

內部類

• 內部類就是在一個類的內部再定義一個類，比如，A類中定義一個B類，那麼B類相對A類來說就稱為內部類，而A類相對B類來說就是外部類了
• 1. 成員內部類

package com.oop.demo10;

public 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);
        }
    }
}

package com.oop;

import com.oop.demo10.Outer;

public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();
        //通過這個外部類來例項化內部類~
        Outer.Inner inner = outer.new Inner();
        inner.getId();
    }

}

• 2. 靜態內部類(加static)
• 3. 區域性內部類

  package com.oop.demo10;
  
  public class Outer {
      
      //區域性內部類
      public void method(){
          class Inner{
              public void in(){
                  
              }
          }
      }
  }
  

• 4. 匿名內部類

package com.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //沒有名字的初始化類，不用將例項儲存到變數中~
        new Apple().eat();

        UserService userService = new UserService(){
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

其他補充

//一個java類中可以有多個class類，但是隻能有一個public class
class A{
    public static void main(String[] args) {

    }
}

筆記出處——狂神老師