面向對象-高級篇

来源:https://www.cnblogs.com/Mr-shne/archive/2022/10/05/16698784.html
-Advertisement-
Play Games

類變數: 什麼是類變數? 一個可以被一個類所有對象共用的變數 類變數關鍵字? static 類變數語法? 訪問修飾符 static 數據類型 變數名; [推薦使用] static 訪問修飾符 數據類型 變數名; 入門案例: count被child1和child2共用,只要是Child類的對象都可以共 ...


類變數:

  • 什麼是類變數? 一個可以被一個類所有對象共用的變數
  • 類變數關鍵字? static
  • 類變數語法? 訪問修飾符 static 數據類型 變數名; [推薦使用]
  •                        static 訪問修飾符 數據類型 變數名;
  • 入門案例:
    • count被child1和child2共用,只要是Child類的對象都可以共用該變數  
  • public class Test {
        public static void main(String[] args) {
            Child child1 = new Child("jack");
            child1.join();
            Child.count++;
            Child child2 = new Child("king");
            child2.join();
            Child.count++;
        }
    }
    class Child{
        String name;
        public static int count = 0;
        public Child(String name) {
            this.name = name;
        }
         public void join(){
             System.out.println(name);
         }
    }
  • 類變數的記憶體發佈:

  • 類變數細節:

    • 類變數也叫靜態變數
    • 類變數可以通過 - 類名.類變數名 或 對象名.類變數,來訪問
    • 類變數是在類載入時初始化,就算沒有創建對象,只要類載入,就可以訪問類變數 - 重要
    • 類變數的生命周期是隨著類載入開始,類消亡而銷毀
    • public class Test {
          public static void main(String[] args) {
      //類變數,可以通過類名.類變數名稱,或對象名.類變數來訪問
      System.out.println(Child.count);
          }
      }
      class Child{
          static int count = 0;
      }

 類方法:

  • 什麼是類方法?和類變數一樣通過關鍵字static來實現共用
  • 類方法的語法?訪問修飾符 static 數據返回類型 方法名(); - 推薦使用
  •                  static 訪問修飾符 數據返回類型 方法名();
  • 類方法的使用場景?一般做為工具類來使用或者通用的方法(如:列印數組Arrays),來提高開發效率,通過類名去調用
  • 案例:
  • public class Test {
        public static void main(String[] args) {
            Child jack = new Child("jack");
            Child.payFee(1000);
            Child kind = new Child("kind");
            Child.payFee(2000);
            Child.showFee();//3000
        }
    }
    class Child{
        private String name;
        //累加學費
        public static double fee = 0;
    
        public Child(String name) {
            this.name = name;
        }
        //靜態方法
        public static void payFee(double fee){
            Child.fee += fee;
        }
        //靜態方法
        public static void showFee(){
            System.out.println(fee);
        }
    }
  • 類方法細節:

    • 類方法和普通方法都是隨著類的載入而載入,將結構存儲在方法區
    • 類方法中不能使用this和super
    • 類方法中只能訪問類變數或類方法  
    • 普通成員方法,即可以訪問非靜態成員,也可以訪問靜態成員
    • class Child{
          String name;
          //類方法中不能使用this和super
          public static void payFee(double fee){
              System.out.println(this.name); //錯誤
              System.out.println(super.clone());//錯誤
              //類方法中只能訪問類變數或類方法
              showFee();//錯誤
              System.out.println(name);//錯誤
          }
          public void showFee(){
              //普通成員方法,即可以訪問非靜態成員,也可以訪問靜態成員
              System.out.println(name);//正確
              payFee(11.1);//正確
          }
      }

main方法的理解:

  • main方法本虛擬機調用
  • java虛擬機需要調用類的main方法,使用main方法訪問許可權為public
  • java虛擬機在執行main方法時不必創建對象,所以是static
  • main方法的字元串類型數組參數,是在執行程式時傳遞
  • 細節:

    • main方法中,可以直接調用main方法所在類的的靜態方法和靜態屬性
    • 不能直接調用非靜態成員,必須創建一個實例底對象後才能調用
    • public class Test {
          private String name = "king";
          private static int age = 18;
          public static void show(){
              System.out.println("我可以被main調用");
          }
          public void show2(){
              System.out.println("我不是靜態方法");
          }
      
          public static void main(String[] args) {
              show();//直接調用
              System.out.println(age); //直接調用
              Test test = new Test();
              test.show2(); //創建對象調用
              System.out.println(test.name);//創建對象調用
      
          }
      }
    • 如果在idea給main方法傳參數

 

代碼塊: 

  • 什麼是代碼塊?可以把它看成一個方法,可以在代碼塊中寫邏輯語句,但它沒有返回體,沒有方法名,就在一個花括弧中
  • 基本語法?[ 修飾符 ]{ 代碼 }; - 分號可寫可不寫 
    • 修飾符:只能是static或者不寫(有static的叫靜態代碼塊,沒有的叫普通代碼塊)
  • 案例:
  • class A{
        //靜態代碼塊,隨著類的載入而載入,只執行一次
        static{
            System.out.println("我是代碼塊A"); //2
        };
        //普通代碼塊,隨著對象實例的創建而載入,創建一個對象,執行一次
        {
            System.out.println("我是代碼塊B"); //3
        };
    }
  • 細節(多看記住):

    • 靜態代碼塊隨著類的載入而執行,只會執行一次
    • 普通代碼塊在創建對象時而執行,創建一個對象執行一次
    • 類的載入情況:
      1. 創建對象實例(new)
      2. 創建子類對象實例,父類也會被載入(沒父哪來的子)
      3. 使用類的靜態成員
    • public class Test {
          public static void main(String[] args) {
      //        System.out.println(A.name); //輸出結果:1.把鍵盤敲爛 2.king
      //        A a = new A();//輸出結果 1.把鍵盤敲爛 2.king 3.普普通通
              B b = new B();//輸出結果:1.把鍵盤敲爛 2.B代碼塊 3.普普通通
          }
      }
      class A{
          public static String name = "king";
          //靜態代碼塊隨著類的載入而執行,只會執行一次
          static{
              System.out.println("把鍵盤敲爛");
          };
      
          {
              System.out.println("普普通通");
          };
      }
      //創建子類對象實例,父類也會被載入
      class B extends A{
          static{
              System.out.println("B代碼塊");
          }
      }
    • 創建對象時,類中的調用順序
      1. 先調用靜態代碼塊和靜態屬性的初始化
        1. 如果有多個靜態代碼塊和靜態屬性變數初始化,則按照定義順序執行,因為它們優先順序一樣
      2. 在調用普通代碼塊和普通屬性的初始化
        1. 如果有多個普通代碼塊和普通屬性初始化,則按照定義順序執行,因為它們優先順序一樣、
      3. 最後調用構造器方法
    • public class Test {
          public static void main(String[] args) {
              A a = new A();
          }
      }
      class A{
          public static String name = "show()"; //1
          public static int a = show(); //1
          public int b = show2(); //3
      
          public A(int b) {
              System.out.println("可憐的構造器被最後調用"); //5
          }
      
          static{
              System.out.println("把鍵盤敲爛"); //2
          };
      
          {
              System.out.println("普普通通"); //4
          };
      
          public static int show(){
              System.out.println("我是show");
              return 0;
          }
          public int show2(){
              System.out.println("我是show2");
              return 0;
          }
      }
    • 構造器中 在預設隱藏了super( )調用普通代碼塊 - 這是父子類都沒有靜態代碼塊或靜態屬性的執行流程
      • 理解:有繼承關係,就先執行完父類的才執行到自己的  
    • public class Test {
          public static void main(String[] args) {
              B b = new B();
          }
      }
      class A{
          {
              System.out.println("A代碼塊");//1
          }
          public A() {
              //super()
              //調用本類代碼塊
              System.out.println("A無參構造");//2
          }
      }
      class B extends A{   
          {
              System.out.println("B代碼塊");//3
          }
          public B() {
              //super()
              //調用本類代碼塊
              System.out.println("B無參構造");//4
          }
      }
    • 繼承關係:父類和子類都有靜態代碼和靜態屬性,普通代碼塊和普通屬性和構造器,類的執行流程是?:

      1. 執行父類的靜態代碼塊和靜態屬性(優先順序一樣,按順序執行)

      2. 執行子類的靜態代碼和靜態屬性(優先順序一樣,按順序執行)

      3. 執行父類的普通代碼塊和普通屬性(優先順序一樣,按順序執行)

      4. 執行父類的構造器方法
      5. 執行子類的普通代碼塊和普通屬性(優先順序一樣,按順序執行)

      6. 執行子類的構造器方法

    • public class Test {
          public static void main(String[] args) {
              new B02();//對象
          }
      }
      class A02 { //父類
          private static int n1 = getVal01();
          static {
              System.out.println("A02的一個靜態代碼塊..");//(2)
          }
          {
              System.out.println("A02的第一個普通代碼塊..");//(5) 
          }
          public int n3 = getVal02();//普通屬性的初始化
          public static int getVal01() {
              System.out.println("getVal01");//(1) 
              return 10;
          }
          public int getVal02() {
              System.out.println("getVal02");//(6) 
              return 10;
          }
          public A02() {//構造器
              //隱藏
              //super()
              //普通代碼和普通屬性的初始化......
              System.out.println("A02的構造器");//(7) 
          }
      }
      class B02 extends A02 { 
          private static int n3 = getVal03();
          static {
              System.out.println("B02的一個靜態代碼塊..");//(4) 
          }
          public int n5 = getVal04();
          {
              System.out.println("B02的第一個普通代碼塊..");//(9)
          }
          public static int getVal03() {
              System.out.println("getVal03");//(3) 
              return 10;
          }
          public int getVal04() {
              System.out.println("getVal04");//(8) 
              return 10;
          }
          public B02() {//構造器
              //隱藏了
              //super()
              //普通代碼塊和普通屬性的初始化...
              System.out.println("B02的構造器");//(10)
              // TODO Auto-generated constructor stub
          }
      }

單例設計模式:

  • 什麼是單例設計模式?    單個實例的意思,就是採取某些辦法讓類的實例對象只有一個(餓漢式-懶漢式,就是經典的單例模式)
    • 什麼是設計模式? 在大量的實踐中總結出的代碼結構,編程風格,已經解決問題的思考方式
  • 餓漢式:

    • 什麼是餓漢式? 類載入的時,就已經創建對象實例 - 十分著急
    • 餓漢式實現步驟:
      • 所有化構造器
      • 類的內部創建對象
      • 向外部暴露一個靜態的公共方法
    • public class Test {
          public static void main(String[] args) {
              King show = King.show();
              System.out.println(show);//com.Variable.King@1540e19d
              //類載入只載入一次
              King show2 = King.show();
              System.out.println(show);//com.Variable.King@1540e19d
          }
      }
      class King{
          private String name;
          private static King king = new King("jack");
      
          private King(String name) {
              System.out.println("構造器被調用");
              this.name = name;
          }
      
          public static King show(){
              return king;
          }
      }
  • 懶漢式:
    • 什麼是懶漢式? 需要到創建對象實例,才會創建 - 不著急
    • 懶漢是實現步驟,和餓漢是一樣,都是細節不一樣
    • public class Test {
          public static void main(String[] args) {
              Idler show = Idler.show();
              System.out.println(show);//com.Variable.Idler@1540e19d
              //類載入只載入一次
              Idler show2 = Idler.show();
              System.out.println(show);//com.Variable.Idler@1540e19d
          }
      }
      class Idler{
          private String name;
          private static Idler idler;
      
          private Idler(String name) {
              this.name = name;
          }
      
          public static Idler show(){
              if (idler == null){
                  idler = new Idler("jack");
              }
              return idler;
          }
      }
  • 餓漢式和懶漢式對比:

    • 兩種模式,都是為了對象的一個實例,只是創建時機不同
    • 餓漢式不存線上程安全問題,懶漢式存線上程安全問題
    • 餓漢式存在資源浪費問題,如果沒有使用到它但它創建對象實例了,就浪費了,懶漢式是使用時才創建,不存在該問題  

final關鍵字:

    • 什麼是final關鍵字? 表示最終的意思,可以用來修飾類、屬性、方法和局部變數
    • 使用場景? - 總結:不希望本類被子類繼承
      • 不希望本類被子類繼承
      • 當類的屬性不希望被修改時
      • 當局部變數不希望本修改時
      • 當類的方法不需希望本子類覆蓋/重寫時
    • final class AA{
      }
      //當類不希望被繼承時,可以使用final修飾
      class BB extends AA{}
      
      class CC{
      
          private final String Name = "jack";
          public final void show(){
              //當類的某個屬性不希望被修改時,可以用final修飾
              Name = "king";
      
          }
          public void show2(){
              //當局部變數不希望被修改時,可以使用final修飾符
              final int i = 10;
          }
      }
      
      class DD extends CC{
          //當父類的方法不想被子類覆蓋/重寫
          @Override
          public void show() {
              super.show();
          }
      }
  • 細節:

    • final修飾的屬性又叫常量,一般用什XX_XX_XX來命名
    • final修飾屬性時,必須賦值,標簽以後不能修改,賦值可以在下麵的其中一個:
      • 直接屬性賦值 如:public final int i = 10;
      • 構造器賦值
      • 代碼塊賦值 
    • final修飾屬性時,如果是靜態屬性,賦值可以在下麵其中一個:
      • 直接賦值
      • 靜態代碼塊
    • final不能被繼承,但可以本實例化
    • 類不是final類,但是含有final方法,則該方法雖然不能被覆蓋/重寫,但可以繼承
    • final不能修飾構造器
    • final和static搭配使用,效率更高,因為不會導致類的載入(底層編譯器做了優化)
    • 是final類了,就沒有必要將類中方法修飾為final方法(因為類不會本繼承,方法也不會被覆蓋/重寫)
    • 包裝類(Integer,Double,Float,Boolean等但是final),String也是final類 
    • public class Test {
          public static void main(String[] args) {
              //final類不能繼承但能實例化對象
              CC cc = new CC();
              //不是final類,但是是方法是final方法,不可以本覆蓋/重寫,但可以本繼承
              EE ee = new EE();
              ee.show(); //被繼承的表示
              //用了final和static,不會導致類載入
              System.out.println(GG.i);
          }
      }
      class GG{
          public static final int i = 10;
          static {
              System.out.println("用了final和static,不會導致類載入");
          }
      }
      
      class FF{
          //final不能修改構造器方法
          public final FF() {
          }
      }
      
      final class CC{}
      
      class DD{
          public final void show(){
              System.out.println("敲壞鍵盤");
          }
      }
      
      class EE extends DD{
      
      }
      //普通屬性賦值時
      class AA{
          //1.直接都有時賦值
          public final double TAX_RATE;
          //2.構造器賦值
          public AA(){
              TAX_RATE = 99.99;
          }
          //3.代碼塊賦值
          {
              TAX_RATE = 66.66;
          }
      }
      
      //靜態屬性賦值時
      class BB{
          //1.直接都有時賦值
          public static final double TAX_RATE = 88.88;
          //2.靜態代碼塊賦值
          static{
              TAX_RATE = 99.99;
          }
      }

 抽象類:

  • 什麼是抽象類?當父類的某些方法,需要聲明,但不確定方法用來做什麼的時候,就可以用抽象,那麼方法就叫抽象方法,類就是抽象類、
    • 例:就是我的父類有一個方法,不知道具體用來做什麼,但是要聲明這個方法,然後用子類去基礎並實現該方法  
  • 語法?方法:訪問修飾符 abstract 返回類型 方法保名(); - - 沒有方法體   類:abstract 類名{}; 
  • 抽象類的用途?抽象類的作用更多在於設計,設計者設計號後,讓子類繼承並實現。在框架和設計模式使用比較多
  • abstract class Employee{ //抽象類
        //抽象方法    
        public abstract void work();
    }
    class Manager extends Employee{
        //實現抽象方法
        @Override
        public void work() {
            System.out.println("經理/普通員工"+super.name+"工作中");
        }
    }
  • 細節:

    • 抽象類不能本實例化(類載入可以)
    • 抽象類庫可以不包含abstract方法,就是抽象類可以沒有抽象方法
    • 類中又了抽象方法,該類就必須聲明為抽象類
    • abstract只能修飾類和方法,不能修飾屬性和其它
    • 抽象類可以又任意成員(抽象類還是類)               
    • 抽象方法不能有主體
    • 一個類繼承了抽象類就必須實現抽象方法,否則就把自己也聲明為抽象方法就不用實現了
    • 抽象類不能使用,static、find、private來修飾,這些關鍵字和重寫想違背
  • 重新類最佳實際 - 模板設計
    • 什麼是模板設計?把公共的區域提取出來封裝到一起
    • public class Test {
          public static void main(String[] args) {
              BB bb = new BB(); //繼承理所應當的calculateTime方法也繼承
              bb.calculateTime(); 
      
              CC cc = new CC();
              cc.calculateTime();
          }
      }
      abstract class AA{
          public abstract void obj();
          public void calculateTime(){
              long start = System.currentTimeMillis();
              obj(); //但調用到該方法時,動態綁定機制就上場了,會去看子類有沒有,有就調用
              long end = System.currentTimeMillis();
              System.out.println("總共耗時:"+(end-start));
          }
      
      }
      class BB extends AA{
          public void obj(){
              long k = 0;
              for (int i = 1; i <= 900000; i++) {
                  k+=i;
              }
          }
      }
      class CC extends AA{
          public void obj(){
              long k = 0;
              for (int i = 1; i <= 900000; i++) {
                  k+=i;
              }
          }
      } 

介面:

  • 什麼是介面?1.介面是java單繼承的一種補充,2.介面規則了實現方法,實現介面的類必須實現方法
    • 例:1.小猴子只會爬樹-這是繼承老猴子的,小猴子學游泳是學魚的-這就是實現介面,單繼承補充
  • 語法:interface 介面名{....} -- 定義介面 ,class 類名 implements 介面名{....} -- 實現介面
  • 用途:定義規範例:我寫一個介面規則資料庫只能用統一的介面名實現,那麼不管連接什麼資料庫的方法名都得到了統一等等
  • 案例演示:

    • public interface Usb {
          int i = 10; //介面可以有屬性
          void show(); //抽象方法
      }
      class King implements Usb{
          int a = 20; //定義自己的屬性
          @Override
          public void show() { //實現介面中的抽象方法
              System.out.println(Usb.i); //獲取屬性
          }
          public void show2(){
              System.out.println("定義自己的方法");
          }
      }
  • jdk7.0和jdk8.0介面的改變:

    • jdk7.0以前介面在是不能有預設方法和靜態方法
    • jdk8.0以後介面在是可以有預設方法和靜態方法
      • 預設方法需要加上default關鍵字
    • public interface Usb {
          void show();
          default public void show3(){
              System.out.println("jdk8以後可以寫普通屬性");
          }
          public static void show4(){
              System.out.println("jdk8以後可以寫靜態方法");
          }
      }
  • 細節:

    • 介面不能實例化
    • 介面的寫的抽象方法是不用寫abstract關鍵字的
    • 介面中所有的方法是public方法,介面在抽象方法,可以不用abstract修飾
    • 普通類實現介面,必須將該介面的所有方法都實現
    • 抽象類實現介面,不用實現介面方法 - 因為介面的里的方法就是抽象方法
    • 一個類可以同時實現多個介面
    • 介面中的屬性只能是final的
    • //介面的修飾符只能是public和預設的,和了類的修飾符一樣
      public interface Usb {
          //介面中的屬性只能是find
          int i = 10; //等價於 int final static i = 10;
          //不用abstract來修飾方法為抽象方法
          void connect();
          //介面中的方法都是public方法
          //private void interrupt();
          default void interrupt(){
              //介面的訪問通過介面名.屬性名
              System.out.println(Usb.i);
          }
      }
      //介面不能繼承其它類,但是可以繼承多個別的介面
      interface Usb3 extends Usb{}
      //一個類同時實現多個介面
      class A_ implements Usb,Usb3{
          int a = 10;
          //一個普通類實現介面必須把介面方法都實現了
          //當然抽象類不用
          @Override
          public void connect() {
              System.out.println("連接Usb——A");
          }
          @Override
          public void interrupt() {
              System.out.println("連接Usb——A");
          }
      }
  • 實現介面VS繼承類:

    • 問題?介面是讓實現它的類去實現它的抽象方法,繼承是讓它的子類去繼承它的屬性方法(遵守訪問修飾符),感覺上是差不多,那實際是什麼樣
    • 繼承的價值:解決代碼的復用性和可維護性
    • 介面的價值:設計 - 設計好合作規範(方法)讓其它類去實現這些方法,比較靈活
    • 繼承需要滿足is-a的關係 - 就是小狗的繼承類必須是動物,是有保存聯繫的
    • 介面只需要滿足like-a的關係 - 就是小狗類但是我也可以去實現某個介面,如該介面中有游泳的方法,小狗就實現了游泳
  • 介面的多態:

    • 介面的多態和類的多態是一樣的父類可以接收所有子類,介面就是可以接收實現它的類
    • 	   
      
      
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Tracert 命令跟蹤路由原理是IP路由每經過一個路由節點TTL值會減一,假設TTL值=0時數據包還沒有到達目標主機,那麼該路由則會回覆給目標主機一個數據包不可達,由此我們就可以獲取到目標主機的IP地址,如下我們通過scapy構造一個路由追蹤工具並實現一次追蹤。 ...
  • Spring @Transactional註解isolation屬性 @Transactional註解通過isolation屬性設置事務隔離級別。如下: @Transactional(isolation=Isolation.DEFAULT) public void method(){} isolat ...
  • 有時候,我們明明在類或者方法上添加了@Transactional註解,卻發現方法並沒有按事務處理。其實,以下場景會導致事務失效。 1、事務方法所在的類沒有載入到Spring IOC容器中。 @Transactional是Spring的註解,未被Spring管理的類中的方法不受@Transaction ...
  • Spring事務(二)-事務傳播行為 在Spring里,一個事務方法被另外一個事務方法調用時,兩個方法的事務應該如何進行,說白話一點,就是說當出現異常需要回滾時,各個方法的數據操作是否要全部回滾,事務傳播行為就是決定了這樣的一個處理結果。A事務方法(外部方法)調用了B事務方法(內部方法,又叫被調用方 ...
  • java.util.concurrent包中的大多數同步器實現都是圍繞著共同的基礎行為,比如等待隊列、條件隊列、獨占獲取、共用獲取等,而這些行為的抽象就是基於AbstractQueuedSynchronizer(簡稱AQS)實現的,AQS是一個抽象同步框架,可以用來實現一個依賴狀態的同步器 ...
  • Lambda 表達式(lambda expression)是一個匿名函數,Lambda表達式基於數學中的λ演算得名,直接對應於其中的lambda抽象(lambda abstraction),即沒有函數名的函數。Lambda表達式可以表示閉包(註意和數學傳統意義上的不同)。 ...
  • 2022-10-05 得到cookie信息的實例聯繫: 在子應用中的“views.py”文件: from django.http import HttpResponse def get_cookie(request): cookies = request.COOKIES username = coo ...
  • echarts是百度推出的一款開源的基於`JavaScript`的可視化圖表庫,該開發庫目前發展非常不錯,且支持各類圖形的繪製可定製程度高,Echarts繪圖庫同樣可以與`Flask`結合,前臺使用`echart`繪圖庫進行圖形的生成與展示,後臺則是Flask通過`render_template`方... ...
一周排行
    -Advertisement-
    Play Games
  • C#.Net的BCL提供了豐富的類型,最基礎的是值類型、引用類型,而他們的共同(隱私)祖先是 System.Object(萬物之源),所以任何類型都可以轉換為Object。 ...
  • 最近有群友咨詢C#如何調用Python?小編嘗試Python.NET過程中遭遇的版本相容性和環境配置難題,小編決定尋找一個更為簡單、穩定且對初學者友好的解決方案。小編搜索一番,除了Python.NET之外,還有其他途徑能夠幫助我們輕鬆地在C#項目調用Python腳本,那就是通過命令行調用,使用 Sy ...
  • .NET中特性+反射 實現數據校驗 在.NET中,我們可以使用特性+反射來實現數據校驗。特性是一種用於為程式中的代碼添加元數據的機制。元數據是與程式中的代碼相關聯的數據,但不直接成為代碼的一部分。通過特性,我們可以為類、方法、屬性等添加額外的信息,這些信息可以在運行時通過反射獲取和使用。 對反射不太 ...
  • Biwen.Settings 是一個簡易的配置項管理模塊,主要的作用就是可以校驗並持久化配置項,比如將自己的配置存儲到資料庫中,JSON文件中等 使用上也是很簡單,只需要在服務中註入配置, 比如我們有一個GithubSetting的配置項,我們只需要定義好對象然後註入到Service中即可: [De ...
  • EDP是一套集組織架構,許可權框架【功能許可權,操作許可權,數據訪問許可權,WebApi許可權】,自動化日誌,動態Interface,WebApi管理等基礎功能於一體的,基於.net的企業應用開發框架。通過友好的編碼方式實現數據行、列許可權的管控。 ...
  • 前言 VB.NET,全名Visual Basic .NET,是Microsoft .NET框架的一部分,是一種面向對象的編程語言。它繼承了Visual Basic的易用性,同時增加了對面向對象編程的支持。VB.NET提供了大量的內置函數,使得開發者可以更容易地處理字元串、數學計算、文件和目錄訪問等任 ...
  • 自定義可移動點二維坐標軸控制項 目錄 路由參數 坐標軸控制項定義 Demo 路由參數 X_YResultCollection為當前X軸對應Y軸值存儲字典 public class ResultCollectionChangedEventArgs(RoutedEvent routedEvent, obje ...
  • 自定義分頁控制項 tip: 該控制項的樣式用的是materialDesign庫,需要下載Nuget包 Code Xaml <UserControl x:Class="TestTool.CustomControls.PagingControl" xmlns="http://schemas.microsof ...
  • 最近群里有個小伙伴把Dapper遷移SqlSugar幾個不能解決的問題進行一個彙總,我正好寫一篇文章來講解一下 一、sql where in傳參問題: SELECT * FROM users where id IN @ids 答: SqlSugar中應該是 var sql="SELECT * FRO ...
  • 安裝nuget包 Wesky.Net.OpenTools 1.0.8或以上版本。支持.net framework 4.6以上版本,以及所有.net core以及以上版本引用。 開發一個簡單的Winform界面,用來測試使用。如需該winform的demo,可以在公眾號【Dotnet Dancer】後 ...