package com.oop.demo07;

public class Person {
    //1 賦初值
    {
       System.out.println("匿名程式碼塊"); //程式碼塊（匿名程式碼塊）

    }
    //2 static程式碼塊只執行一次
    static {
        System.out.println("靜態程式碼塊");//程式碼塊（靜態程式碼塊）
    }
    //3
    public Person() {
        System.out.println("構造方法");
    }

    public static void main(String[] args) {
      Person person1=  new Person();
      System.out.println("===========================");
      Person person2=  new Person();
    }
}

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.score);
       System.out.println(s1.age);
       Student.go();
       new Student().run();
    }
}

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

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

    }
}

package com.oop.demo08;
//abstract 抽象類：類 單繼承 多繼承（介面）
public abstract class Action {
    //約束  有人幫我們實現
    //abstract 抽象方法只有方法的名字，沒有方法的實現（方法體）
    public abstract void doSomething();
        //1、不能new這個抽象類，只能靠子類去實現它：約束！
        //2、抽象類可以寫普通方法
        //3、抽象方法必須在抽象類中
        //抽象的抽象：約束
        //思考題？抽象類是否存在構造器
        //存在構造器
        //抽象類存在的意義：節省程式碼，提升開發效率

}

//介面

package com.oop.demo09;

public interface TimeService {
    void timer();

}

package com.oop.demo09;
//抽象的思維
//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;
//抽象類: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、定義一些方法，讓不同的人實現
    3、方法都是 public abstract
    4、常量都為：public static final
    5、介面不能被例項化，介面中沒有構造方法
    6、implements可以實現多個介面
    7、必須要重寫介面中的方法
    8、總結部落格


//內部類

package com.oop.demo10;

public class Outer {
    private  int id=10;
    public void out(){
        System.out.println("這是外部類的方法");
    }
    //內部類可以獲得外部類的私有方法以及私有屬性
   public  class Inter{
        public void in(){
            System.out.println("這是內部類的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}

package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        //型別直接的轉換：基本型別轉換 父  子
        //高                低
        Person s1=new Student();
        //student這個物件轉換成Student型別,我們就可以使用Student型別的方法
       Student student= (Student)s1;//高轉低強制轉換
        //子類轉換成父類可能會丟失一些方法
        Student s2=new Student();
        s2.go();
        Person person=student;

        //內部類主函式
        //new
        Outer outer=new Outer();
        //通過這個外部類來例項化內部類
        Outer.Inter inter=outer.new Inter();
        inter.in();
        inter.getID();
    }
}
/*
1、父類引用指向子類物件
2、把子類轉換成父類，向上轉型
3、把父類轉換成子類，向下轉型，需強制轉換
4、方便方法的呼叫，減少重複的程式碼
 */