十大排序-希爾排序

阿新 • • 發佈：2020-07-09

一、 static

static:靜態的，可以用來修飾屬性、方法、程式碼塊（或初始化塊）、內部類
static修飾屬性（類變數）:
- 由類建立的所有的物件，都共用這一個屬性
- 當其中一個物件對此屬性進行修改，會導致其他物件對此屬性的一個呼叫。vs 例項變數（非static修飾的屬性，各個物件各自擁有一套副本）
- 類變數隨著類的載入而載入的，而且獨一份
- 靜態的變數可以直接通過“類.類變數”的形式來呼叫
- 類變數的載入是要早於物件。所以當有物件以後，可以“物件.類變數”使用。但是"類.例項變數"是不行的。
- 類變數存在於靜態域中。
static修飾方法（類方法）:
- 隨著類的載入而載入，在記憶體中也是獨一份
- 可以直接通過“類.類方法”的方式呼叫
- 內部可以呼叫靜態的屬性或靜態的方法，而不能呼叫非靜態的屬性或方法。反之，非靜態的方法是可以呼叫靜態的屬性或靜態的方法
- 靜態的方法內是不可以有this或super關鍵字的！
- 靜態的結構(static的屬性、方法、程式碼塊、內部類)的生命週期要早於非靜態的結構，同時被回收也要晚於非靜態的結構
開發中，如何確定一個屬性是否要有宣告為static的？
- 屬性可以被多個物件共享的，不會隨著物件的不同而不同
開發中，如何確定一個方法是否要有宣告為static的？
- 操作靜態屬性的方法通常也是靜態的
- 工具類中對方法通常也為static的

public class TestCircle {
	public static void main(String[] args) {
		Circle c1 = new Circle();
		Circle c2 = new Circle(2.3);
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(Circle.getTotal());
	}
}
 
class Circle{
	private double radius;
	private static String info = "我是一個圓";
	private int id;//編號
	private static int init = 1001;//控制每個物件的id
	private static int total = 0;//記錄建立了多少個物件
	
	public Circle(){
		this.id = init++;
		total++;
	}
	public Circle(double radius){
		this.radius = radius;
		this.id = init++;
		total++;
	}
	
	
	
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public static String getInfo() {
		return info;
	}
	public static void setInfo(String info) {
		Circle.info = info;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public static int getTotal() {
		return total;
	}
	public static void setTotal(int total) {
		Circle.total = total;
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + ", id=" + id + "]";
	}
	public static void show(){
		System.out.println(Circle.info);
	}
	
	public void desc(){
		System.out.println(this.info);
	}

}

二、單例設計模式

解決的問題：如何只讓設計的類只能建立一個物件
如何實現：餓漢式 & 懶漢式

1. 餓漢式1

class Bank{
	//1.私有化構造器
	private Bank(){}
	//2.建立類的物件，同時設定為private的，通過公共的來呼叫，體現封裝性
	//4.要求此物件也為static的
	private static Bank instance = new Bank();
	//3.此公共的方法，必須為static 
	public static Bank getInstance(){
		return instance;	
	}
}

2. 餓漢式2

class Bank{
	//1.私有化構造器
	private Bank(){}
	//2.建立類的物件，同時設定為private的，通過公共的來呼叫，體現封裝性
	//4.要求此物件也為static的
	private static Bank instance = null;
	static{
		instance  = new Bank();	
	}
	//3.此公共的方法，必須為static  
	public static Bank getInstance(){
		return instance;	
	}
}

3. 懶漢式

class Bank{
	private Bank(){}
	
	private static Bank instance = null;
	
	public static Bank getInstance(){
		if(instance == null){//可能存線上程安全問題的！
			instance = new Bank();		
		}	
		return instance;
	}
}

三、main()方法

public static void main(String[] args){
     //方法體     
}

//1.main()是一個方法，是主方法，為程式的入口
//2.許可權修飾符：public protected 預設 private ---面向物件的封裝性
//3.對於方法來講：static final abstract 
//4.方法的返回值：void /  具體的返回值型別（基本的資料型別 & 引用資料型別），方法內部一定要有return
//5.方法名：命名的規則：xxxYyyZzz。給方法命名時，要見名之意
//6.形參列表：同一個方法名不同的形參列表的諸多個方法間構成過載。   形參 & 實參---方法的引數傳遞機制：值傳遞
//7.方法體：方法定義的是一種功能，具體的實現由方法體操作。

四、程式碼塊

程式碼塊：是類的第4個成員 { }
作用：用來初始化類的屬性
分類：只能用static來修飾。
靜態程式碼塊：
- 裡面可以有輸出語句
- 隨著類的載入而載入並且執行，而且只被載入一次
- 多個靜態程式碼塊之間按照順序結構執行
- 靜態程式碼塊的執行要早於非靜態程式碼塊的執行。
- 靜態的程式碼塊中只能執行靜態的結構(類屬性，類方法)
非靜態程式碼塊：
- 可以對類的屬性(靜態的 & 非靜態的)進行初始化操作，同時也可以呼叫本類宣告的方法(靜態的 & 非靜態的)
- 裡面可以有輸出語句
- 一個類中可以有多個非靜態的程式碼塊，多個程式碼塊之間按照順序結構執行
- 每建立一個類的物件，非靜態程式碼塊就載入一次。
- 非靜態程式碼塊的執行要早於構造器
關於屬性賦值的操作：
- 預設的初始化
- 顯式的初始化或程式碼塊初始化(此處兩個結構按照順序執行)
- 構造器中；
- 以上是物件的屬性初始化的過程------
- 通過方法對物件的相應屬性進行修改

1. 常見問題

總結：由父及子，靜態先行

class Root{
	static{
		System.out.println("Root的靜態初始化塊");
	}
	{
		System.out.println("Root的普通初始化塊");
	}
	public Root(){
		super();
		System.out.println("Root的無引數的構造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的靜態初始化塊");
	}
	{
		System.out.println("Mid的普通初始化塊");
	}
	public Mid(){
		super();
		System.out.println("Mid的無引數的構造器");
	}
	public Mid(String msg){
		//通過this呼叫同一類中過載的構造器
		this();
		System.out.println("Mid的帶引數構造器，其引數值："
			+ msg);
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的靜態初始化塊");
	}
	{
		System.out.println("Leaf的普通初始化塊");
	}	
	public Leaf(){
		//通過super呼叫父類中有一個字串引數的構造器
		super("尚矽谷");
		System.out.println("Leaf的構造器");
	}
}
public class LeafTest{
	public static void main(String[] args){
		new Leaf(); 
		System.out.println();
		new Leaf();
	}
}

package com.atguigu.java3;

class Father {
	static {
		System.out.println("11111111111");
	}
	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}
	{
		System.out.println("55555555555");
	}
	public Son() {
		System.out.println("66666666666");
	}


	public static void main(String[] args) { // 由父及子 靜態先行
		System.out.println("77777777777");
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Son();
		System.out.println("************************");
		new Father();
	}

}

五、final關鍵詞

final:最終的，可以用來修飾類、屬性、方法

final修飾類：這個類就不能被繼承。如：String類、StringBuffer類、System類
final修飾方法：不能被重寫。如：Object類的getClass()
final修飾屬性：此屬性就是一個常量，一旦初始化後，不可再被賦值。習慣上，常量用大寫字元表示
此常量在哪裡賦值：①此常量不能使用預設初始化 ②可以顯式的賦值、程式碼塊、構造器。
變數用static final修飾：全域性常量。比如：Math 類的PI

class D{
	final int I = 12;
	final double PI;
	final String NAME;

	public void m1(){
		System.out.println(I);
//		I = 10;

	}
	{
		PI = 3.14;
	}
	
	public D(){
		NAME = "DD";
	}
	public D(String name){
		this();
		//NAME = name;
	}
}

六、抽象 abstract

abstract：抽象的，用來修飾類、方法

abstract修飾類：抽象類
- 不可被例項化
- 抽象類有構造器 (凡是類都有構造器)，便於子類例項化時呼叫
- 抽象方法所在的類，一定是抽象類。
- 抽象類中可以沒有抽象方法。
- 當我們設計一個類，不需要建立此類的例項時候，就可以考慮將其設定為抽象的，由其子類實現這個類的抽象方法以後，就行例項化
abstract修飾方法：抽象方法
- 格式：沒有方法體，包括{}.如：public abstract void eat();
- 抽象方法只保留方法的功能，而具體的執行，交給繼承抽象類的子類，由子類重寫此抽象方法。
- 若子類繼承抽象類，沒有重寫所有的抽象方法，意味著此類中仍有抽象方法，則此類必須宣告為抽象的

1. 模板方法設計模式

//模板方法設計模式
public class TestTemplate {
	public static void main(String[] args) {
		new SubTemplate().spendTime();
	}
}

abstract class Template {

	public abstract void code();

	public void spendTime() {
		long start = System.currentTimeMillis();

		this.code();

		long end = System.currentTimeMillis();
		System.out.println("花費的時間為：" + (end - start));
	}
}

class SubTemplate extends Template {
	
	public void code() {
		boolean flag = false;
		for(int i = 2;i <= 10000;i++){
			for(int j = 2;j <= Math.sqrt(i);j++){
				if(i % j == 0){
					flag = true;
					break;
				} 
			}
			if(!flag){
				System.out.println(i);
			}
			flag = false;
		}
	}
}

2. 抽象類的應用

//抽象類的應用：模板方法的設計模式
public class TemplateMethodTest {

	public static void main(String[] args) {
		BankTemplateMethod btm = new DrawMoney();
		btm.process();

		BankTemplateMethod btm2 = new ManageMoney();
		btm2.process();
	}
}
abstract class BankTemplateMethod {
	// 具體方法
	public void takeNumber() {
		System.out.println("取號排隊");
	}

	public abstract void transact(); // 辦理具體的業務 //鉤子方法

	public void evaluate() {
		System.out.println("反饋評分");
	}

	// 模板方法，把基本操作組合到一起，子類一般不能重寫
	public final void process() {
		this.takeNumber();

		this.transact();// 像個鉤子，具體執行時，掛哪個子類，就執行哪個子類的實現程式碼

		this.evaluate();
	}
}

class DrawMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要取款！！！");
	}
}

class ManageMoney extends BankTemplateMethod {
	public void transact() {
		System.out.println("我要理財！我這裡有2000萬美元!!");
	}
}

七、介面 interface

介面（interface）是與類並行的一個概念

介面可以看做是一個特殊的抽象類。是常量(public static final 可以省略)與抽象方法的一個集合，不能包含變數、一般的方法。
介面是沒有構造器的
介面定義的就是一種功能。此功能可以被類所實現（implements）。
比如：class CC extends DD implements AA
實現介面的類，必須要重寫其中的所有的抽象方法，方可例項化。若沒有重寫所有的抽象方法，則此類仍為一個抽象類
類可以實現多個介面。----java 中的類的繼承是單繼承的
介面與介面之間也是繼承的關係，而且可以實現多繼承

5,6描述的是java中的繼承的特點。

介面與具體的實現類之間也存在多型性

1. 介面的使用

介面使用上也滿足多型性
介面，實際上就是定義了一種規範
面向介面程式設計

public class USBTest {
	public static void main(String[] args) {
		
		Computer com = new Computer();
		//1.建立了介面的非匿名實現類的非匿名物件
		Flash flash = new Flash();
		com.transferData(flash);
		
		//2. 建立了介面的非匿名實現類的匿名物件
		com.transferData(new Printer());
		
		//3. 建立了介面的匿名實現類的非匿名物件
		USB phone = new USB(){

			@Override
			public void start() {
				System.out.println("手機開始工作");
			}

			@Override
			public void stop() {
				System.out.println("手機結束工作");
			}
			
		};
		com.transferData(phone);
		
		
		//4. 建立了介面的匿名實現類的匿名物件
		
		com.transferData(new USB(){
			@Override
			public void start() {
				System.out.println("mp3開始工作");
			}

			@Override
			public void stop() {
				System.out.println("mp3結束工作");
			}
		});
	}
}

class Computer{
	
	public void transferData(USB usb){//USB usb = new Flash();
		usb.start();
		
		System.out.println("具體傳輸資料的細節");
		
		usb.stop();
	}
	
	
}

interface USB{
	//常量：定義了長、寬、最大最小的傳輸速度等
	
	void start();
	
	void stop();
	
}

class Flash implements USB{

	@Override
	public void start() {
		System.out.println("U盤開啟工作");
	}

	@Override
	public void stop() {
		System.out.println("U盤結束工作");
	}
	
}

class Printer implements USB{
	@Override
	public void start() {
		System.out.println("印表機開啟工作");
	}

	@Override
	public void stop() {
		System.out.println("印表機結束工作");
	}
	
}

2. 工廠方法的設計模板

//介面的應用：工廠方法的設計模式
public class TestFactoryMethod {
	public static void main(String[] args) {
		IWorkFactory i = new StudentWorkFactory();
		i.getWork().doWork();
		
		IWorkFactory i1 = new TeacherWorkFactory();
		i1.getWork().doWork();
	}
}

interface IWorkFactory{
	Work getWork();
}
class StudentWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new StudentWork();
	}
	
}
class TeacherWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new TeacherWork();
	}
	
}

interface Work{
	void doWork();
}

class StudentWork implements Work{

	@Override
	public void doWork() {
		System.out.println("學生寫作業");
	}
	
}
class TeacherWork implements Work{

	@Override
	public void doWork() {
		System.out.println("老師批改作業");
	}
}

3. 代理模式

//介面的應用：代理模式（靜態代理）
public class TestProxy {
	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();
	}
}

interface Object{
	void action();
}
//代理類
class ProxyObject implements Object{
	Object obj;
	
	public ProxyObject(){
		System.out.println("代理類建立成功");
		obj = new ObjctImpl();
	}
	
	public void action(){
		System.out.println("代理類開始執行");
		obj.action();
		System.out.println("代理類執行結束");
	}
}
//被代理類
class ObjctImpl implements Object{

	@Override
	public void action() {
		System.out.println("=====被代理類開始執行======");
		System.out.println("=====具體的操作======");
		System.out.println("=====被代理類執行完畢======");
		
	}
	
}

4. 問題

interface A {
	int x = 0;
}

class B {
	int x = 1;
}

class C extends B implements A {
	public void pX() {
		//編譯不通過。因為x是不明確的
		// System.out.println(x);
		System.out.println(super.x);//1
		System.out.println(A.x);//0
	}

	public static void main(String[] args) {
		new C().pX();
	}
}

5. Java8新特性

八、內部類

Java中允許將一類A宣告在類B中，則類A就是內部類

1. 成員內部類(靜態、非靜態)

作為一個類
- 類內可以定義屬性、方法、構造器
- 可以被final修飾，表示此類不能繼承，也就是不適用final，就可以被繼承
- 可以被abstract修飾
作為外部類的
- 呼叫外部類的結構
- 可以被static修飾
- 可以被4種不同的許可權修飾

區域性內部類(方法內、程式碼塊、構造器中)

public class InnerClassTest {
	public static void main(String[] args) {
		
		//建立Dog例項(靜態的成員內部類):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//建立Bird例項(非靜態的成員內部類):
//		Person.Bird bird = new Person.Bird();//錯誤的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黃鸝");
		
	}
}


class Person{
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃飯");
	}
	
	
	//靜態成員內部類
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是條狗");
//			eat();
		}
		
	}
	//非靜態成員內部類
	class Bird{
		String name = "杜鵑";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一隻小小鳥");
			Person.this.eat();//呼叫外部類的非靜態屬性
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形參
			System.out.println(this.name);//內部類的屬性
			System.out.println(Person.this.name);//外部類的屬性
		}
	}
	
	
	public void method(){
		//區域性內部類
		class AA{
			
		}
	}
	
	{
		//區域性內部類
		class BB{
			
		}
	}
	
	public Person(){
		//區域性內部類
		class CC{
			
		}
	}
	
}

2. 注意

package com.atguigu.java;

public class InnerClassTest {
	/*
	 * 在區域性內部類宣告的方法中（比如：show）如果呼叫區域性內部類所宣告的方法(比如：method)中的區域性變數(比如：num)的話,
	 * 要求此區域性變數宣告為final的。
	 * 
	 * jdk 7及之前版本：要求此區域性變數顯式的宣告為final的
	 * jdk 8及之後的版本：可以省略final的宣告
	 * 
	 */
	public void method(){
		//區域性變數
		int num = 10;
		
		class AA{	
			public void show(){
//				num = 20;
				System.out.println(num);
				
			}	
		}	
	}
}