Java面向對象詳解-上

来源:https://www.cnblogs.com/mengd/archive/2020/07/08/13269507.html
-Advertisement-
Play Games

一、類及對象 1. 類的組成成分 屬性（成員變數，Field） 方法（成員方法，函數，Method） 2. 屬性 成員變數 vs 局部變數 相同點： 遵循變數聲明的格式： 數據類型 變數名 = 初始化值 都有作用域 不同點： 聲明的位置的不同 ：成員變數：聲明在類里，方法外， 局部變數：聲明在方法內 ...


一、類及對象

1. 類的組成成分

  • 屬性（成員變數，Field）
  • 方法（成員方法，函數，Method）

2. 屬性

成員變數 vs 局部變數

  • 相同點：
    • 遵循變數聲明的格式： 數據類型 變數名 = 初始化值
    • 都有作用域
  • 不同點：
    • 聲明的位置的不同 ：成員變數：聲明在類里，方法外， 局部變數：聲明在方法內，方法的形參部分，代碼塊內
    • 成員變數的修飾符有四個：public private protected 預設，局部變數沒有修飾符，與所在的方法修飾符相同
    • 初始化值：一定會有初始化值，成員變數:如果在聲明的時候，不顯式的賦值，那麼不同數據類型會有不同的預設初始化值。 局部變數：一定要顯式的賦值。（局部變數沒有預設初始化值）
      • byte short int long ==>0
      • float double ==>0.0
      • char ==>空格
      • boolean ==>false
      • 引用類型變數==>null
    • 二者在記憶體中存放的位置不同:成員變數存在於堆空間中；局部變數：棧空間中
  • 總結：
    • 按照數據類型的不同：基本數據類型（8種） & 引用數據類型
    • 按照聲明的位置的不同：成員變數 & 局部變數

3. 方法

提供某種功能的實現

    public void eat(){//方法體}
    public String getName(){}
    public void setName(String n){}
    //格式：許可權修飾符 返回值類型（void:無返回值/具體的返回值） 方法名(形參){}
  • 關於返回值類型
    • void：表明此方法不需要返回值
    • 有返回值的方法：在方法的最後一定有return + 返回值類型對應的變數
  • 方法內可以調用本類的其他方法或屬性，但是不能在方法內再定義方法！

4. 面向對象編程的思想的落地法則一：

  • 設計並創建類及類的成分
  • 實例化類的對象
  • 通過“對象.屬性”或"對象.方法"的形式完成某項功能

5. 類的初始化記憶體解析:記憶體劃分的結構

  • 棧(stack):局部變數 、對象的引用名、數組的引用名
  • 堆(heap):new 出來的“東西”（如：對象的實體，數組的實體），含成員變數
  • 方法區:含字元串常量
  • 靜態域：聲明為static的變數

6. 萬事萬物皆對象

  • 在Java語言範疇中，我們都能將功能、結構等封裝到類中，通過類的實體化，來調用具體的功能結構
    • Scanner、String
    • 文件：File
  • 設計到Java語言與前端Html、後端的資料庫交互時，都體現為類、對象

7. 例題

/*
 * 4. 對象數組題目：
定義類Student，包含三個屬性：學號number(int)，年級state(int)，成績score(int)。
 創建20個學生對象，學號為1到20，年級和成績都由隨機數確定。
問題一：列印出3年級(state值為3）的學生信息。
問題二：使用冒泡排序按學生成績排序，並遍歷所有學生信息

提示：
1) 生成隨機數：Math.random()，返回值類型double;  
2) 四捨五入取整：Math.round(double d)，返回值類型long。
 * 
 * 
 *  // 兩位數的，隨機數  10 - 99
  公式：【a,b】 :   Math.random()*(b-a+1)+a   再強轉數據類型。
 * 
 */
public class StudentTest {
	public static void main(String[] args) {

		// 聲明Student類型的數組
		Student[] stu = new Student[20];

		for (int i = 0; i < stu.length; i++) {
			// 給數組元素賦值
			stu[i] = new Student();
			stu[i].number = i + 1;
			// [1,6]
			stu[i].state = (int) (Math.random() * (6 - 1 + 1) + 1);
			// [0,100]
			stu[i].score = (int) (Math.random() * (100 - 0 + 1));
		}

		StudentTest test = new StudentTest();
		
		// 問題1
		test.searchState(stu,3);
		System.out.println("------------------------");
		//
		// 問題2
		test.sort(stu);
		test.print(stu);
		
	}

	
	// 遍歷學生數組
	public void print(Student[] stu) {
		for (int i = 0; i < stu.length; i++) {
			System.out.println(stu[i].info());
		}
	}

	/**
	 * 
	 * @Description  查找指定年紀的學生
	 * @author MD
	 * @date 2020年7月6日下午12:02:56
	 * @param stu 查找的數組
	 * @param state 指定的年紀
	 */
	public void searchState(Student[] stu, int state) {
		for (int i = 0; i < stu.length; i++) {
			if (stu[i].state == 3)
				System.out.println(stu[i].info());
		}
	}
	
	
	public void sort(Student[] stu) {
		for (int i = 0; i < stu.length - 1; i++) {
			for (int j = 0; j < stu.length - i - 1; j++) {
				if (stu[j].score <= stu[j + 1].score) {
					// 註意，這裡交換的不是成績而是對象
					Student temp = stu[j];
					stu[j] = stu[j + 1];
					stu[j + 1] = temp;
				}
			}
		}
	}

}

class Student {
	int number;
	int state;
	int score;

	public String info() {
		return "學號：" + number + " 年級：" + state + " 分數：" + score;
	}

}

二、方法的重載（overload）

要求：
* 同一個類中
* 方法名必須相同
* 方法的參數列表不同（①參數的個數不同②參數類型不同）
補充：方法的重載與方法的返回值類型沒有關係！

//如下的四個方法構成重載
//定義兩個int型變數的和
public int getSum(int i,int j){
    return i + j;
}
//定義三個int型變數的和
public int getSum(int i,int j,int k){
    return i + j + k;
}
//定義兩個double型數據的和
public double getSum(double d1,double d2){
    return d1 + d2;
}

//定義三個double型數組的和
public void getSum(double d1,double d2,double d3){
    System.out.println(d1 + d2 + d3);
}
//不能與如上的幾個方法構成重載
//  public int getSum1(int i,int j,int k){
//      return i + j + k;
//  }
//  public void getSum(int i,int j,int k){
//      System.out.println(i + j + k);
//  }


//以下的兩個方法構成重載。
public void method1(int i,String str){
    
}
public void method1(String str1,int j){
    
}

三、可變個數的形參的方法

  • .格式：對於方法的形參： 數據類型 ... 形參名
  • 可變個數的形參的方法與同名的方法之間構成重載
  • 可變個數的形參在調用時，個數從0開始，到無窮多個都可以
  • 使用可變多個形參的方法與方法的形參使用數組是一致
  • 若方法中存在可變個數的形參，那麼一定要聲明在方法形參的最後
  • 在一個方法中，最多聲明一個可變個數的形參
//如下四個方法構成重載
    //在類中一旦定義了重載的可變個數的形參的方法以後，如下的兩個方法可以省略
//  public void sayHello(){
//      System.out.println("hello world!");
//  }
//  public void sayHello(String str1){
//      System.out.println("hello " + str1);
//  }
    //可變個數的形參的方法
    public void sayHello(String ... args){
        for(int i = 0;i < args.length;i++){
            System.out.println(args[i] + "$");
        }
        //System.out.println("=====");
    }
    
    public void sayHello(int i,String ... args){
    //public void sayHello(String ... args,int i){
        System.out.println(i);
        
        for(int j = 0;j < args.length;j++){
            System.out.println(args[j] + "$");
        }
    }
    
    public void sayHello1(String[] args){
        for(int i = 0;i < args.length;i++){
            System.out.println(args[i]);
        }
    }

四、 Java的值傳遞

  • 方法的參數傳遞（重點、難點）
    • 形參：方法聲明時，方法小括弧內的參數
    • 實參：調用方法時，實際傳入的參數的值
  • java中的參數傳遞機制：值傳遞機制
    • 形參是基本數據類型的：將實參的值傳遞給形參的基本數據類型的變數
    • 形參是引用數據類型的：將實參的引用類型變數的值（對應的堆空間的對象實體的首地址值）傳遞給形參的引用類型變數
  • 關於變數的賦值
    • 如果變數是基本數據類型，此時賦值的是變數所保存的數據值
    • 如果變數是引用數據類型，此時賦值的變數是所保存的地址值

1. 例一

public static void main(String[] args) {
    TestArgsTransfer tt = new TestArgsTransfer();
    
    int i = 10;
    int j = 5;
    System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
    
//      //交換變數i與j的值
//      int temp = i;
//      i = j;
//      j = temp;
    tt.swap(i, j);//將i的值傳遞給m，j的值傳遞給n
    
    
    System.out.println("i:" + i + " j:" + j);//i : 10  j : 5
    
}
//定義一個方法，交換兩個變數的值
public void swap(int m,int n){
    int temp = m;
    m = n;
    n = temp;
    System.out.println("m:" + m + " n:" + n);

}

2. 例二

public class TestArgsTransfer1 {
    public static void main(String[] args) {
        TestArgsTransfer1 tt = new TestArgsTransfer1();
        DataSwap ds = new DataSwap();
        
        System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
        
        tt.swap(ds);
        System.out.println(ds);
        
        System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);
        
    }
    //交換元素的值
    public void swap(DataSwap d){
        int temp = d.i;
        d.i = d.j;
        d.j = temp;
        System.out.println(d);//列印引用變數d的值
    }
}

class DataSwap{
    int i = 10;
    int j = 5;
}

3. 例3

package com.atguigu.exer;

import java.io.PrintStream;

public class Test {

	public static void main(String[] args) {
		int a = 10;
		int b = 10;
		method(a,b);
		System.out.println("a="+a);
		System.out.println("b="+b);
	}
	
//	public static void method(int a , int b) {
//		a = a * 10;
//		b = b * 20;
//		System.out.println(a);
//		System.out.println(b);
//		System.exit(0);
//	}
	public static void method(int a, int b) {
		PrintStream ps = new PrintStream(System.out) {
			public void println(String x){
				if("a=10".equals(x)) {
					x = "a=100";
				}else if("b=10".equals(x)) {
					x = "b=200";
				}
				super.println(x);
			}
		};
		
		System.setOut(ps);
	}

	
}

4. 例4

輸出的什麼？

public class Test1 {

	public static void main(String[] args) {
		int[] arr = new int[] {1,2,3};
		System.out.println(arr); //地址值
		
		char[] arr1 = new char[] {'a','b','c'};
		System.out.println(arr1); //abc
	}
}

五、面向對象的特征一：封裝

  • 問題：當創建了類的對象以後，如果直接通過"對象.屬性"的方式對相應的對象屬性賦值的話，可能會出現不滿足實際情況的意外，我們考慮不讓對象來直接作用屬性，而是通過"對象.方法"的形式，來控制對象對屬性的訪問。實際情況中，對屬性的要求就可以通過方法來體現
  • 高內聚，低耦合
  • 面向對象思想的落地法則二：
    • 將類的屬性私有化
    • 提供公共的方法（setter & getter）來實現調用
  • 四種許可權修飾符
    • 許可權從大到小為：public protected 預設 private
    • 四種許可權都可以用來修飾屬性、方法、構造器
    • 修飾類的話：public 預設

  • 封裝性的體現
    • 將類的屬性私有化，提供公共的方法來調用
    • 不對外暴露的私有化方法
    • 單例模式

1. 構造器

構造器的作用：①創建對象 ②給創建的對象的屬性賦值

  • 設計類時，若不顯式聲明類的構造器的話，程式會預設提供一個空參的構造器
  • 一旦顯式的定義類的構造器，那麼預設的構造器就不再提供
  • 如何聲明類的構造器。格式：許可權修飾符 類名(形參){ }
  • 類的多個構造器之間構成重載
  • 類對象的屬性賦值的先後順序：
    • 屬性的預設初始化
    • 屬性的顯式初始化
    • 通過構造器給屬性初始化
    • 通過"對象.方法"的方式給屬性賦值
  • 一個類中至少會有一個構造器，一般都提供一個空參的構造器

2. this關鍵字

  • 使用在類中，可以用來修飾屬性、方法、構造器
  • 表示當前對象或者是當前正在創建的對象
  • 當形參與成員變數重名時，如果在方法內部需要使用成員變數，必須添加this來表明該變數時類成員
  • 在任意方法內，如果使用當前類的成員變數或成員方法可以在其前面添加this，增強程式的閱讀性
  • 在構造器中使用“this(形參列表)”顯式的調用本類中重載的其它的構造器，要求“this(形參列表)”要聲明在構造器的首行！
public class TestPerson {
    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println(p1.getName() + ":" + p1.getAge());
        
        Person p2 = new Person("BB",23);
        int temp = p2.compare(p1);
        System.out.println(temp);
    }
}
class Person{
    
    private String name;
    private int age;
    
    public Person(){
        this.name = "AA";
        this.age = 1;
    }
    
    public Person(String name){
        this(); // 先調用空參數的
        this.name = name;
    }
    public Person(String name,int age){
        this(name);
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println("eating");
    }
    public void sleep(){
        System.out.println("sleeping");
        this.eat();
    }
    //比較當前對象與形參的對象的age誰大。
    public int compare(Person p){
        if(this.age > p.age)
            return 1;
        else if(this.age < p.age)
            return -1;
        else
            return 0;
    }
    
}

3. package/import

package: 聲明源文件所在的包，寫在程式的第一行
import:

  • 顯式導入指定包下的類或介面
  • 寫在包的聲明和源文件之間
  • 如果需要引入多個類或介面，那麼就併列寫出
  • 如果導入的類是java.lang包下的，如：System String Math等，就不需要顯式的聲明
  • 理解.*的概念。比如java.util. *;
  • 導入java.lang.*只能導入lang包下的所有類或介面，不能導入lang的子包下的類或介面
  • import static 表示導入指定類的static的屬性或方法
/import java.util.Scanner;
//import java.util.Date;
//import java.util.List;
//import java.util.ArrayList;
import java.lang.reflect.Field;
import java.util.*;
import static java.lang.System.*;
public class TestPackageImport {
    public static void main(String[] args) {
        out.println("helloworld");
        Scanner s = new Scanner(System.in);
        s.next();
        
        Date d = new Date();
        List list = new ArrayList();
        
        java.sql.Date d1 = new java.sql.Date(522535114234L);
        
        Field f = null;
    }
}

六、面向對象的特征二：繼承

  1. 繼承的格式
    • 通過"class A extends B"類實現類的繼承
  2. 子類繼承父類以後，父類中聲明的屬性、方法，子類就可以獲取到
    • 當父類中有私有的屬性或方法時，子類同樣可以獲取得到，只是由於封裝性的設計，使得子類不可以直接調用罷了
    • 子類除了通過繼承，獲取父類的結構之外，還可以定義自己的特有的成分
  3. java中類的繼承性只支持單繼承：一個類只能繼承一個父類。反之，一個父類可以有多個子類
  4. 如果沒有顯示聲明一個類的父類的話，則此類繼承於java.lang.Object類

1. 方法的重寫（override orverwrite） vs 重載（overload）

  1. 重載：“兩同一不同”：同一個類，同一個方法名，不同的參數列表註：方法的重載與方法的返回值無關！構造器是可以重載的
  2. 重寫：（前提：在繼承的基礎之上，子類在獲取了父類的結構以後，可以對父類中同名的方法進行“重構”）方法的返回值，方法名，形參列表形同；許可權修飾符不小於父類的同名方法；子類方法的異常類型不大於父類的；兩個方法要同為static或同為非static
    • 註：不能重寫父類的私有的方法
    • 父類被重寫的返回值類型是A類型，那麼子類重寫方法的返回值類型可以是A類或者A類的子類
class Cirlce{
   //求圓的面積
    public double findArea(){
   
    } 

}

class Cylinder extends Circle{
      //求圓柱的錶面積
      public double findArea(){
      }
}

2. 關鍵字 super

  1. super，相較於關鍵字this，可以修飾屬性、方法、構造器
  2. super修飾屬性、方法：在子類的方法、構造器中，通過super.屬性或者super.方法的形式，顯式的調用父類的指定屬性或方法。尤其是，當子類與父類有同名的屬性、或方法時，調用父類中的結構的話，一定要用“super.”
  3. 通過“super(形參列表)”，顯式的在子類的構造器中，調用父類指定的構造器！
  4. 任何一個類(除Object類)的構造器的首行，要麼顯式的調用本類中重載的其它的構造器“this(形參列表)”或顯式的調用父類中指定的構造器“super(形參列表)”,要麼預設的調用父類空參的構造器"super()"，只能二選一
  5. 建議在設計類時，提供一個空參的構造器

3. 子類對象實例化的全過程

無論通過那個構造器創建子類對象，需要保證先初始化父類

目的：當子類繼承父類後，繼承父類中所有的屬性和方法，因此子類必須知道父類如何為對象進行初始化

public class TestDog {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.setAge(10);
        d.setName("小明");
        d.setHostName("花花");

        System.out.println("name:" + d.getName() + " age:" + d.getAge()
                + "hostName:" + d.getHostName());
        
        System.out.println(d.toString());
    }
}

// 生物
class Creator {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Creator() {
        super();
        System.out.println("this is Creator's constructor");
    }

}

// 動物類
class Animal extends Creator {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Animal() {
        super();
        System.out.println("this is Animal's constructor");
    }

}

// 狗
class Dog extends Animal {
    private String hostName;

    public String getHostName() {
        return hostName;
    }

    public void setHostName(String hostName) {
        this.hostName = hostName;
    }

    public Dog() {
        super();
        System.out.println("this is Dog's constructor");
    }
}

七、 面向對象的特征三：多態

1. 多態性的表現：

①方法的重載與重寫 ②子類對象的多態性

2. 使用的前提：

①要有繼承關係 ②要有方法的重寫

3. 格式

  • Person p = new Man();//向上轉型
  • 通過父類的引用指向子類的對象實體，當調用方法時，實際執行的是子類重寫父類的方法

編譯時，認為p是Person類型的，故只能執行Person里才有的結構，即Man里特有的結構不能夠調用，子類對象的多態性，並不使用於屬性。

調用方法：編譯看左邊，運行看右邊

屬性：編譯和運行都看左邊

package com.atguigu.java;

public class AnimalTest {

	public static void main(String[] args) {
		
		AnimalTest test = new AnimalTest();
		// 多態性的體現
		test.func(new Dag());
		test.func(new Cat());
	}

	public void func(Animal an) {  // Animal an = new Dag();
		an.eat();
		an.shot();
	}
	
	
//	public void func(Dag dag) {
//		dag.eat();
//		dag.shot();
//	}
	
}

class Animal{
	public void eat() {
		System.out.println("動物：吃食物");
	}
	
	public void shot() {
		System.out.println("動物：叫");
	}
}

class Dag extends Animal{
	public void eat() {
		System.out.println("狗吃肉");
	}
	
	public void shot() {
		System.out.println("汪！汪");
	}
}

class Cat extends Animal{
	public void eat() {
		System.out.println("貓吃魚");
	}
	
	public void shot() {
		System.out.println("喵！喵");
	}
}

4. 關於向下轉型

有了對象的多態性之後，記憶體中實際上是載入了子類特有的屬性和方法，但是由於變數聲明為父類類型，導致了編譯時只能調用父類中聲明的屬性和方法，子類中特有的屬性和方法調用不了，所以有了向下轉型

  • 向下轉型,使用強轉符：()
  • 為了保證不報ClassCastException，最好在向下轉型前，進行判斷： instanceof
if (p1 instanceof Woman) {
            System.out.println("hello!");
            Woman w1 = (Woman) p1;
            w1.shopping();
  }

   if (p1 instanceof Man) {
        Man m1 = (Man) p1;
         m1.entertainment();
  }

5. 多態是編譯性行為還是運行時行為

運行時行為

package com.atguigu.java5;


import java.util.Random;

//面試題：多態是編譯時行為還是運行時行為？
//證明如下：
class Animal  {
 
	protected void eat() {
		System.out.println("animal eat food");
	}
}

class Cat  extends Animal  {
 
	protected void eat() {
		System.out.println("cat eat fish");
	}
}

class Dog  extends Animal  {
 
	public void eat() {
		System.out.println("Dog eat bone");
	}
}

class Sheep  extends Animal  {

	public void eat() {
		System.out.println("Sheep eat grass");
	}
}

public class InterviewTest {

	public static Animal  getInstance(int key) {
		switch (key) {
		case 0:
			return new Cat ();
		case 1:
			return new Dog ();
		default:
			return new Sheep ();
		}
	}

	public static void main(String[] args) {
		int key = new Random().nextInt(3);

		System.out.println(key);

		Animal  animal = getInstance(key);
		
		animal.eat();
	}
}

6. 問題1

package com.atguigu.exer;
/*
 * 練習：
 * 1.若子類重寫了父類方法，就意味著子類里定義的方法徹底覆蓋了父類里的同名方法，
 * 系統將不可能把父類里的方法轉移到子類中：編譯看左邊，運行看右邊
 * 
 * 2.對於實例變數則不存在這樣的現象，即使子類里定義了與父類完全相同的實例變數，
 * 這個實例變數依然不可能覆蓋父類中定義的實例變數：編譯運行都看左邊
 */
class Base {
	int count = 10;

	public void display() {
		System.out.println(this.count);
	}
}

class Sub extends Base {
	int count = 20;

	public void display() {
		System.out.println(this.count);
	}
}

public class FieldMethodTest {
	public static void main(String[] args) {
		Sub s = new Sub();
		System.out.println(s.count);//20
		s.display();//20
		
		Base b = s;//多態性
		//==：對於引用數據類型來講，比較的是兩個引用數據類型變數的地址值是否相同
		System.out.println(b == s);//true
		System.out.println(b.count);//10
		b.display();//20
	}
}

7. 問題2

package com.atguigu.exer;

//考查多態的筆試題目：
public class InterviewTest1 {

	public static void main(String[] args) {
		Base1 base = new Sub1();
		base.add(1, 2, 3); //sub_1

		Sub1 s = (Sub1)base;
		s.add(1,2,3); //sub_2
	}
}

class Base1 {
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
}

class Sub1 extends Base1 {

	public void add(int a, int[] arr) {
		System.out.println("sub_1");
	}

	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}

}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Mybatis的sql映射
    Mybatis的sql映射 添加： boolean addUser(User user); <insert id="addUser" parameterType="User"> insert into Users(uname,upass) values(#{uname},#{upass}) </in ...
  • 源碼剖析@ApiImplicitParam對@RequestParam的required屬性的侵入性
    問題起源 使用SpringCloud構建項目時，使用Swagger生成相應的介面文檔是推薦的選項，Swagger能夠提供頁面訪問，直接在網頁上調試後端系統的介面， 非常方便。最近卻遇到了一個有點困惑的問題，演示介面示例如下（原有功能介面帶有業務實現邏輯，這裡簡化了介面）： /** * @descri ...
  • SpringBoot(一) 多線程與非同步
    多線程與非同步 非同步是目的，而多線程是實現這個目的的方法。 1 Java J.U.C線程調度 JDK 1.5新增的java.util.concurrent包，增加了併發編程的很多類。 Executor 定義了方法execute()，用來執行一個任務 public interface Executor ...
  • 廖雪峰爬蟲第一課
    1.http:(1)當⽤戶在地址輸⼊了⽹址 發送⽹絡請求的過程是什麼 (2)http的請求⽅式 get請求 (1)⽐較便捷 缺點:不安全:明⽂ 參數的⻓度有限制 post請求 (1)⽐較安全 (2)數據整體沒有限制 (3)上傳⽂件 put(不完全的) delete(刪除 ⼀ 些信息) head(請求 ...
  • Java連載128-UDP通信編程
    一、UDP編程 1.DatagramPacket特性以及構造方法 UDP是一個面向無連接的協議，因此，在通信時發送端和接收端不用建立連接。 Datagram類就相當於一個集裝箱用於封裝UDP通信中發送或者接收的數據。 構造方法： （1）DatagramPacket(byte[] buf,int le ...
  • SpringBoot 2.x 自定義攔截器並解決靜態資源訪問被攔截問題
    自定義攔截器 /** * UserSecurityInterceptor * Created with IntelliJ IDEA. * Author: yangyongkang * Date: 2018/8/22 * Time: 14:20 */ @Component public class U ...
  • springboot項目WEB-INF 目錄 jsp頁面報404
    我是跟著《深入淺出 Spring Boot 2.x》這本書學習的，在“初識Spring MVC”章節中，搭建項目，然後訪問jsp頁面時報錯：Path with "WEB-INF" or "META-INF": [WEB-INF/jsp/details.jsp 1、因為沒有書本中說的 WEB-INF  ...
  • 節的設置
    from docx import Document w=Document() w.add_section() w.add_section() w.paragraphs[0].add_run('第一個段落') w.paragraphs[1].add_run('第二個段落') w.save(r'D:\w ...
一周排行
    -Advertisement-
    Play Games
  • C#自增運算符詳解：++i與i++的區別及應用場景
    概述：在C#中，++i和i++都是自增運算符，其中++i先增加值再返回，而i++先返回值再增加。應用場景根據需求選擇，首碼適合先增後用，尾碼適合先用後增。詳細示例提供清晰的代碼演示這兩者的操作時機和實際應用。 在C#中，++i 和 i++ 都是自增運算符，但它們在操作上有細微的差異，主要體現在操作的 ...
  • Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET 版本
    上次發佈了：Taurus.MVC 性能壓力測試（ap 壓測 和 linux 下wrk 壓測）：.NET Core 版本，今天計劃準備壓測一下 .NET 版本，來測試並記錄一下 Taurus.MVC 框架在 .NET 版本的性能，以便後續持續優化改進。 為了方便對比，本文章的電腦環境和測試思路，儘量和... ...
  • 一文讀懂.NET WebAPI中FromRoute、FromQuery、FromBody的關鍵角色與用法
    .NET WebAPI作為一種構建RESTful服務的強大工具，為開發者提供了便捷的方式來定義、處理HTTP請求並返迴響應。在設計API介面時，正確地接收和解析客戶端發送的數據至關重要。.NET WebAPI提供了一系列特性，如[FromRoute]、[FromQuery]和[FromBody]，用 ...
  • WPF/C#實現圖像濾鏡優化方案：打造炫目視覺體驗！
    原因：我之所以想做這個項目，是因為在之前查找關於C#/WPF相關資料時，我發現講解圖像濾鏡的資源非常稀缺。此外，我註意到許多現有的開源庫主要基於CPU進行圖像渲染。這種方式在處理大量圖像時，會導致CPU的渲染負擔過重。因此，我將在下文中介紹如何通過GPU渲染來有效實現圖像的各種濾鏡效果。 生成的效果 ...
  • Bogus 實戰：使用 Bogus 和 EFCore 生成模擬數據和種子數據【完整教程】
    引言 上一章我們介紹了在xUnit單元測試中用xUnit.DependencyInject來使用依賴註入，上一章我們的Sample.Repository倉儲層有一個批量註入的介面沒有做單元測試，今天用這個示例來演示一下如何用Bogus創建模擬數據 ，和 EFCore 的種子數據生成 Bogus 的優 ...
  • WPF隨筆收錄-實時繪製心率曲線
    一、前言 在自己的項目中，涉及到實時心率曲線的繪製，項目上的曲線繪製，一般很難找到能直接用的第三方庫，而且有些還是定製化的功能，所以還是自己繪製比較方便。很多人一聽到自己畫就害怕，感覺很難，今天就分享一個完整的實時心率數據繪製心率曲線圖的例子；之前的博客也分享給DrawingVisual繪製曲線的方 ...
  • wpf程式修改啟動入口註意事項
    如果你在自定義的 Main 方法中直接使用 App 類並啟動應用程式，但發現 App.xaml 中定義的資源沒有被正確載入，那麼問題可能在於如何正確配置 App.xaml 與你的 App 類的交互。 確保 App.xaml 文件中的 x:Class 屬性正確指向你的 App 類。這樣，當你創建 Ap ...
  • 記一次 .NET某爐膛鍋爐檢測系統 崩潰分析
    一：背景 1. 講故事 上個月有個朋友在微信上找到我，說他們的軟體在客戶那邊隔幾天就要崩潰一次，一直都沒有找到原因，讓我幫忙看下怎麼回事，確實工控類的軟體環境複雜難搞，朋友手上有一個崩潰的dump，剛好丟給我來分析一下。 二：WinDbg分析 1. 程式為什麼會崩潰 windbg 有一個厲害之處在於 ...
  • 一個.NET內置依賴註入的小型強化版
    前言 .NET生態中有許多依賴註入容器。在大多數情況下，微軟提供的內置容器在易用性和性能方面都非常優秀。外加ASP.NET Core預設使用內置容器，使用很方便。 但是筆者在使用中一直有一個頭疼的問題：服務工廠無法提供請求的服務類型相關的信息。這在一般情況下並沒有影響，但是內置容器支持註冊開放泛型服 ...
  • WPF隨筆收錄-DataGrid固定右側列
    一、前言 在項目開發過程中，DataGrid是經常使用到的一個數據展示控制項，而通常表格的最後一列是作為操作列存在，比如會有編輯、刪除等功能按鈕。但WPF的原始DataGrid中，預設只支持固定左側列，這跟大家習慣性操作列放最後不符，今天就來介紹一種簡單的方式實現固定右側列。（這裡的實現方式參考的大佬 ...
所有分類