面向物件2

static關鍵字詳解

final關鍵詞修飾的類，不能被繼承

package com.oop.demo07;
​
//static
public class Student {
​
  private static int age; //靜態的變數 多執行緒！
  private double score;  //非靜態的變數
​
  public void run(){
​
   }
​
  public static void go(){
​
   }
​
  public static void main(String[] args) {
    Student s1 = new Student();
​
    System.out.println(Student.age);
    System.out.println(s1.age);
    System.out.println(s1.score);
​
    s1.run();
    Student.go();
   }
}
​
 

package com.oop.demo07;
​
public final class Person {
​
  //2:賦初始值
   {
    //程式碼塊(匿名程式碼快)
    System.out.println("匿名程式碼塊");
   }
​
  //1:只執行一次
  static {
    //靜態程式碼塊
    System.out.println("靜態程式碼塊");
   }
​
  //3
  public Person() {
    System.out.println("構造方法");
   }
​
  public static void main(String[] args) {
    Person person = new Person();
    System.out.println("==========================");
    Person person1 = new Person();
​
   }
}
​
 

package com.oop.demo07;
​
//靜態匯入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
​
public class Test {
​
  public static void main(String[] args) {
    System.out.println(Math.random());
   }
}
​

抽象類

用abstract修飾

package com.oop.demo08;
​
//abstract 抽象類：類 extends: 單繼承 （介面可以多繼承）
public abstract class Action {
​
  //約束~有人幫我們實現~
  //abstract,抽象方法，只有方法名字，沒有方法的實現！
  public abstract void doSomething();
​
  //1. 不能new 這個抽象類，只能靠子類去實現它，它只是一個約束。
  //2. 抽象類中可以寫普通的方法。
  //3. 抽象方法必須在抽象類中。
  //抽象的抽象：約束！
​
  //思考題？ 不能new，它存在構造器嗎？ 存在構造器
      // 存在的意義 抽象出來~
}
​
 

package com.oop.demo08;
​
//抽象類的所有方法，繼承了它的子類，都必須要實現它的方法，除非子類也是abstract類
public class A extends Action{
  @Override
  public void doSomething() {
​
   }
}
​

package com.oop;
​
import com.oop.demo08.A;
import com.oop.demo08.Action;
​
​
//一個專案應該只存一個main方法
public class Application {
​
  public static void main(String[] args) {
    A a = new A();
    a.doSomething();
​
   }
​
}
​

介面的定義和實現

普通類：只有具體實現

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

介面：只有規範！自己無法寫方法~專業的約束！約束和實現分離：面向介面程式設計~

介面的本質是契約

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 但是隻能單繼承
// 類 可以實現介面 implements 介面，可以多繼承
// 實現了介面的類，就需要重寫介面中的方法！
​
//多繼承~利用介面實現多繼承
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. 定義一些方法，讓不同的人實現~ 10--》1
  3. public abstract
  4. public static final
  5. 介面不能被例項化~，介面中沒有構造方法~
  6. implements可以實現多個介面
  7. 必須要重寫介面中的方法~

N種內部類

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);
     }
   }
​
  //靜態內部類
  public static class InnerStatic{
    public void in(){
      System.out.println("這是內部類的方法");
     }
​
    //不能獲得外部類的私有屬性
    /*
    public void getID(){
      System.out.println(id);
    }
​
     */
   }
​
  //區域性內部類
  public void method(){
    class Inner{
​
     }
   }
}
​
//一個java類中可以有多個class類，但是隻能有一個public class
class A{
​
}
​

package com.oop;
​
​
import com.oop.demo10.Outer;
​
//一個專案應該只存一個main方法
public class Application {
​
  public static void main(String[] args) {
    //new
    Outer outer = new Outer();
​
    //通過這個外部類來例項化內部類！
    Outer.Inner inner = outer.new Inner();
    inner.in();
    inner.getID();
​
   }
​
}
​

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();
}
​