2. 程式人生 > >抽象類、介面、內部類

抽象類、介面、內部類

阿新 • • 發佈：2018-12-03

抽象類

抽象方法和抽象類

抽象方法和抽象類必須使用abstract修飾符來定義，有抽象方法的類只能被定義為抽象類，抽象類裡可以沒有抽象方法；

規則如下：

  • 抽象類與抽象方法必須使用abstract修飾符來修飾，抽象方法不能有方法體；
  • 抽象類不能被例項化。即使抽象類裡不包含抽象方法，這個抽象類也不能建立例項；
  • 抽象類可以包含成員變數、方法（普通方法和抽象方法都可以）、構造器、初始化塊、內部類（介面、列舉）5種成分。抽象類的構造器不能用於建立例項，主要用於被其子類呼叫；
  • 含有抽象方法的類（包括直接定義了一個抽象方法、繼承了一個抽象父類，但沒有完全實現父類包含的抽象方法、實現了一個介面，但沒有完全實現介面包含的抽象方法三種情況）只能被定義為抽象類；
public abstract class Shape
{
	{
		System.out.println("執行Shape的初始化塊...");
	}

	private String color;
	
	//定義一個計算周長的抽象方法
	public abstract double calPerimeter();
	//定義一個返回形狀的抽象方法
	public abstract String getType();

	//定義Shape的構造器，該構造器並不是用於建立Shape物件，而是用於被子類呼叫
	public Shape(){}
	public Shape(String color)
 

	{
		System.out.println("執行Shape的構造器...");
		this.color = color;
	}

	public void setColor(String color)
	{
		this.color = color;
	}
	public String getColor()
	{
		 return this.color;
	}
}

抽象類不能用於建立例項，只能當作父類被其他子類繼承：

public class Triangle extends Shape
{
	//定義三角形的三邊
	private double a;
	private double
 
 b;
	private double c;

	public Triangle(String color , double a , double b , double c)
	{
		super(color);
		this.setSides(a , b , c);
	}

	public void setSides(double a , double b , double c)
	{
		if (a >= b + c || b >= a + c || c >= a + b)
		{
			System.out.println("三角形兩邊之和必須大於第三邊");
			return;
		}
		this.a = a;
		this.b = b;
		this.c = c;
	}
	//重寫Shape類的的計算周長的抽象方法
	public double calPerimeter()
	{
		return a + b + c;
	}
	//重寫Shape類的的返回形狀的抽象方法
	public String getType()
	{
		return getColor() + "三角形";
	}
}

當使用 abstract 修飾類時，表明這個類只能被繼承；當使用 abstract 修飾方法時，表明這個方法必須由子類提供實現（即重寫）。而 final 修飾的類不能被繼承，final 修飾的方法不能被重寫。因此， final 和 abstract 永遠不能同時使用；

除此之外，當使用 static 修飾一個方法時，表明這個方法屬於該類本身，即通過類就可以呼叫該方法，但如果該方法被定義為抽象方法，則將導致通過該類來呼叫該方法時出現錯誤（呼叫了一個沒有方法體的方法肯定會引起錯誤）。因此 static 和 abstract 不能同時修飾某個方法，即沒有所謂的類抽象方法；

注意：static 和 abstract 並不是絕對互斥的，static 和 abstract 雖然不能同時修飾某個方法，但它們可以同時修飾內部類；

注意：abstract 關鍵字修飾的方法必須被其子類重寫才有意義，否則這個方法將永遠不會再有方法體，因此abstract 方法不能被定義為 private 訪問許可權，即 private 和 abstract 不能同時修飾方法；

Java8的介面(interface)

簡介

接口裡不能包含普通方法，接口裡的所有方法都是抽象方法。Java8對介面進行了改進，允許在介面中定義預設方法，預設方法可以提供方法實現；

介面的定義

  • 修飾符可以是 public 或者省略，如果省略了 public 訪問控制符，則預設採用包許可權訪問控制符，即只有在相同包結構下才可以訪問該介面；
  • 介面名與類名採用相同的命名規則；
  • 一個介面可以有多個直接父介面，但介面只能繼承介面，不能繼承類；

接口裡不能包含構造器和初始化塊定義。接口裡可以包含成員變數（只能是靜態常量）、方法（只能是抽象方法例項、類方法或預設方法）、內部類（包括內部介面、列舉）定義；

接口裡的所有成員，包括常量、方法、內部類和內部列舉都是 public 訪問許可權。定義介面成員時，可以省略訪問控制修飾符，如果指定訪問控制修飾符，則只能使用 public 訪問控制修飾符；

對於接口裡定義的靜態常量而言，系統會自動為這些成員變數增加 static 和 final 兩個修飾符。也就是說，在介面中定義成員變數時，不管是否使用 public static final 修飾符，接口裡的成員變數總是使用這三個修飾符來修飾。而且接口裡沒有構造器和初始化塊，因此接口裡定義的成員變數只能在定義時指定預設值；

//系統自動為接口裡定義的成員變數增加 public static final 修飾符
int MAX_SIZE = 50;
public static final int MAX_SIZE = 50;

接口裡定義的方法只能是抽象方法、類方法、預設方法，因此如果不是定義預設方法，系統將自動為普通方法增加 abstract 修飾符；定義接口裡的普通方法不管是否使用 public abstract 修飾符，接口裡的普通方法總是使用 public abstract 來修飾。接口裡的普通方法不能有方法實現（方法體）；但類方法、預設方法都必須有方法實現（方法體）；

public interface Output
{
	//接口裡定義的屬性只能是常量
	int MAX_CACHE_LINE = 50;
	//接口裡定義的只能是public的抽象例項方法
	void out();
	void getData(String msg);
    
    //在介面中定義預設方法，需要使用 default 修飾，預設方法總是使用 public 修飾---沒有指定，系統會自動新增；
	default void print(String...msgs)
	{
		for(String msg : msgs)
		{
			System.out.println(msg);
		}
	}

	//在介面中定義預設方法，需要使用 default 修飾
	default void test()
	{
		System.out.println("預設的 test() 方法");
	}

	//在接口裡定義類方法，需要使用 static 修飾，類方法總是使用 public 修飾---沒有指定，系統會自動新增；
	static String staticTest()
	{
		return "接口裡的類方法";
	}
}

介面的繼承

介面的繼承和類繼承不一樣，介面完全支援多繼承，即一個介面可以有多個介面父介面；

interface interfaceA
{
	int PROP_A = 5;
	void testA();
}
interface interfaceB
{
	int PROP_B = 6;
	void testB();
}
interface interfaceC extends interfaceA, interfaceB    
{
	int PROP_C = 7;
	void testC();
}
public class TestInterfaceExtends 
{
	public static void main(String[] args)
	{
		System.out.println(interfaceC.PROP_A);
		System.out.println(interfaceC.PROP_B);
		System.out.println(interfaceC.PROP_C);
	}
}

使用介面

一個類可以實現一個或多個介面，實現使用 implements 關鍵字；

一個類實現了一個或多個介面之後，這個類必須完全實現這些接口裡所定義的全部抽象方法（也就是重寫這些抽象方法）；否則，該類將保留從父介面那裡繼承到的抽象方法，該類也必須定義成抽象類；

介面和抽象類

介面和抽象類很像，它們具有如下特徵：

  • 介面和抽象類都不能被例項化，它們都位於繼承樹的頂端，用於被其他類實現和繼承；
  • 介面和抽象類都可以包含抽象方法，實現介面或繼承抽象類的普通子類必須實現這些抽象方法；

介面和抽象類在用法上存在如下差別：

  • 接口裡只能包含抽象方法、靜態方法和類方法；抽象類則完全可以包含普通方法；
  • 接口裡只能定義靜態常量，不能定義普通成員變數；抽象類則既可以定義普通成員變數，也可以定義靜態常量；
  • 接口裡不包含構造器；抽象類則可以包含構造器，抽象類裡的構造器不是用於建立物件，而是讓其子類呼叫這些構造器來完成屬於抽象類的初始化操作；
  • 接口裡不能包含初始化塊；但抽象類則完全可以包含初始化塊；
  • 一個類最多隻能有一個直接父類，包括抽象類；但一個類可以直接實現多個介面；

內部類

把一個類放在另一個類的內部定義，這個定義在其他類內部的類就被稱為內部類，包含內部類的類也被稱為外部類；

定義內部類與定義外部類存在如下兩點差別：

  1. 內部類比外部類可以多使用三個修飾符：private、protected、static-----外部類不可以使用這三個修飾符；
  2. 非靜態內部類不能擁有靜態成員；

非靜態內部類

大部分時候，內部類都被作為成員內部類定義，而不是作為區域性內部類（方法裡定義的內部類被稱為區域性內部類）。成員內部類是一種與成員變數、方法、構造器和初始化塊相似的類成員；區域性內部類和匿名內部類則不是類成員；

成員內部類分為兩種：

  1. 靜態內部類：使用 static 修飾的成員內部類是靜態內部類；
  2. 非靜態內部類：沒有使用 static 修飾的成員內部類是非靜態內部類；
public class Cow
{
	private double weight;
	//外部類的兩個過載的構造器
	public Cow(){}
	public Cow(double weight)
	{
		this.weight = weight;
	}
	//定義一個內部類
	private class CowLeg
	{
		//內部類的兩個屬性
		private double length;
		private String color;
		//內部類的兩個過載的構造器
		public CowLeg(){}
		public CowLeg(double length , String color)
		{
			this.length = length;
			this.color = color;
		}
		public void setLength(double length)
		{
			this.length = length;
		}
		public double getLength()
		{
			 return this.length;
		}
		public void setColor(String color)
		{
			this.color = color;
		}
		public String getColor()
		{
			 return this.color;
		}
		//內部類方法
		public void info()
		{
			System.out.println("當前牛腿顏色是：" + color + ", 高：" + length);
			//直接訪問外部類的private屬性：weight
			System.out.println("本牛腿所在奶牛重：" + weight);
		}
	}
	public void test()
	{
		CowLeg cl = new CowLeg(1.12 , "黑白相間");
		cl.info();
	}
	public static void main(String[] args)
	{
		Cow cow = new Cow(378.9);
		cow.test();
	}
}

在外部類裡使用非靜態內部類時，與平常使用普通類並沒有太大的區別；

編譯上面程式，看到在檔案所在路徑生成了兩個 class 檔案，一個是 Cow.class，另一個是 Cow $ CowLeg.class，前者是外部類 Cow 的 class 檔案，後者是內部類 CowLeg 的 class 檔案，即成員內部類（包括靜態內部類、非靜態內部類）的 class 檔案總是這種形式：OuterClass$InnerClass.class;

在非靜態內部類裡可以直接訪問外部類的 private 成員。這是因為在非靜態內部類物件裡，儲存了一個它所寄生的外部類物件的引用；
在這裡插入圖片描述

當在非靜態內部類的方法內訪問某個變數時。系統優先在該方法內查詢是否存在該名字的區域性變數，如果存在就使用該變數；如果不存在，則到該方法所在的內部類中查詢是否存在該名字的成員變數，如果存在則使用該成員變數；如果不存在，則到該內部類所在的外部類中查詢是否存在該名字的成員變數，如果存在則使用該成員變數；如果依然不存在，系統將出現編譯錯誤：提示找不到該變數；

因此，如果外部類成員變數、內部類成員變數與內部類裡方法的區域性變數同名，則可通過使用 this、外部類類名.this 作為限定來區分：

public class DiscernVariable
{
	private String prop = "外部類屬性";
	private class InClass
	{
		private String prop = "內部類屬性";
		public void info()
		{
			String prop = "區域性變數";
			//通過 外部類類名.this.varName 訪問外部類例項屬性
			System.out.println("外部類的屬性值：" + DiscernVariable.this.prop);
			//通過 this.varName 訪問外內部類例項的屬性
			System.out.println("內部類的屬性值：" + this.prop);
			//直接訪問區域性變數
			System.out.println("區域性變數的屬性值：" + prop);
		}
	}
	public void test()
	{
		InClass in = new InClass();
		in.info();
	}
	public static void main(String[] args) 
	{
		new DiscernVariable().test();
	}
}

非靜態內部類的成員可以訪問外部類的 private 成員，但反過來就不成立了。如果外部類需要訪問非靜態內部類的成員，必須顯式建立非靜態內部類物件來呼叫訪問其例項成員：

public class Outer
{
	private int outProp = 9;
	class Inner
	{
		private int inProp = 5;
		public void acessOuterProp()
		{
			//內部類可以直接訪問外部類的成員
			System.out.println("外部類的outProp屬性值:" + outProp);
		}
	}
	public void accessInnerProp()
	{
		//外部類不能直接訪問內部類屬性,下面程式碼出現編譯錯誤
		//System.out.println("內部類的inProp屬性值:" + inProp);
		//如需訪問內部類成員，必須顯式建立內部類物件
		System.out.println("內部類的inProp屬性值:" + new Inner().inProp);

	}
	public static void main(String[] args)
	{
		//執行下面程式碼，只建立了外部類物件，還未建立內部類物件
		Outer out = new Outer();
	}
}

在這裡插入圖片描述

Java不允許在非靜態內部類裡定義靜態成員：

public class InnerNoStatic
{
	private class InnerClass
	{
		/*
		下面三個靜態宣告都將引發如下編譯錯誤:
		非靜態內部類不能有靜態宣告
		*/
		static
		{
			System.out.println("==========");
		}
		private static int inProp;
		private static void test(){};
	}
}

非靜態內部類裡不能有靜態方法、靜態成員變數、靜態初始化塊；

靜態內部類

使用 static 修飾的內部類稱為靜態內部類；

靜態內部類可以包含靜態成員，也可以包含非靜態成員。

根據靜態成員不能訪問非靜態成員的規則，靜態內部類不能訪問外部類的例項成員，只能訪問外部類的類成員。即使是靜態內部類的例項方法也不能訪問外部類的例項成員，只能訪問外部類的靜態成員；

public class TestStaticInnerClass
{
	private int prop1 = 5;
	private static int prop2 = 9;
	static class StaticInnerClass
	{
		private static int age;
		public void accessOuterProp()
		{
			//下面程式碼出現錯誤：靜態內部類無法訪問外部類的例項成員
			System.out.println(prop1);
			//下面程式碼正常
			System.out.println(prop2);
		}
	}
}

外部類依然不能直接訪問靜態內部類的成員，但可以使用靜態內部類的類名作為呼叫者來訪問靜態內部類的類成員，也可以使用靜態內部類物件作為呼叫者來訪問靜態內部類的例項成員：

public class AccessStaticInnerClass
{
	static class StaticInnerClass
	{
		private static int prop1 = 5;
		private int prop2 = 9;
	}
	public void accessInnerProp()
	{
		//System.out.println(prop1);
		//上面程式碼出現錯誤，應改為如下形式：通過類名訪問靜態內部類的類成員
		System.out.println(StaticInnerClass.prop1);
		//System.out.println(prop2);
		//上面程式碼出現錯誤，應改為如下形式：通過例項訪問靜態內部類的例項成員
		System.out.println(new StaticInnerClass().prop2);
	}
}

Java允許在接口裡定義內部類，接口裡定義的內部類預設使用 public static 修飾，也就是說，介面內部類只能是靜態內部類；

如果為介面內部類指定訪問控制符，則只能指定 public 訪問控制符；如果定義介面內部類時省略訪問控制符，則該內部類預設是 public 訪問控制權限；

使用內部類

1：在外部類內部使用內部類
通過 new 呼叫內部類構造器來建立例項；

唯一存在的一個區別是：不要在外部類的靜態成員（包括靜態方法和靜態初始化塊）中使用非靜態內部類，因為靜態成員不能訪問非靜態成員；

2：在外部類以外使用非靜態內部類
在外部類以外的地方訪問內部類（包括靜態和非靜態兩種），則內部類不能使用 private 訪問控制權限， private 修飾的內部類只能在外部類內部使用。對於其他訪問修飾符修飾的內部類，則能在訪問控制符對應的訪問許可權內使用；

  • 省略訪問控制符的內部類：只能被與外部類處於同一包中的其他類所訪問；
  • protected 修飾的內部類：可被與外部類處於同一包中的其他類和外部類的子類所訪問；
  • public 修飾的內部類：可以在任何地方被訪問；

在外部類以外的地方使用內部類時，內部類完整的類名應該是：OuterClass.InnerClass；

由於非靜態內部類的物件必須寄生在外部類的物件裡，因此建立非靜態內部類物件之前，必須先建立其外部類物件。在外部類以外的地方建立非靜態內部類例項的語法：

OuterInstance.new InnerConstructor()

class Out
{
	//定義一個非靜態內部類，不使用訪問控制符，即同一個包中其他類可訪問該內部類
	class In
	{
		public In(String msg)
		{
			System.out.println(msg);
		}
	}
}
public class CreateInnerInstance
{
	public static void main(String[] args) 
	{
		Out.In in = new Out().new In("測試資訊");
		/*
		上面程式碼可改為如下三行程式碼：
		使用OutterClass.InnerClass的形式定義內部類變數
		Out.In in;
		建立外部類例項，非靜態內部類例項將寄存在該例項中
		Out out = new Out();
		通過外部類例項和new來呼叫內部類構造器建立非靜態內部類例項
		in = out.new In("測試資訊");
		*/
	}
}

3：在外部類以外使用靜態內部類
因為靜態內部類是外部類類相關的，因此建立靜態內部類物件時無須建立外部類物件；

new OuterClass.InnerConstructor()

class StaticOut
{
	//定義一個靜態內部類，不使用訪問控制符，即同一個包中其他類可訪問該內部類
	static class StaticIn
	{
		public StaticIn()
		{
			System.out.println("靜態內部類的構造器");
		}
	}
}
public class CreateStaticInnerInstance
{
	public static void main(String[] args) 
	{
		StaticOut.StaticIn in = new StaticOut.StaticIn();
		/*
		上面程式碼可改為如下兩行程式碼：
		使用OutterClass.InnerClass的形式定義內部類變數
		StaticOut.StaticIn in;
		通過new來呼叫內部類構造器建立靜態內部類例項
		in = new StaticOut.StaticIn();
		*/
	}
}

區域性內部類

方法裡定義的內部類稱為區域性內部類。區域性內部類也不能使用訪問控制符和 static 修飾符修飾；

public class LocalInnerClass
{
	public static void main(String[] args) 
	{
		//定義區域性內部類
		class InnerBase
		{
			int a;
		}
		//定義區域性內部類的子類
		class InnerSub extends InnerBase
		{
			int b;
		}
		//建立區域性內部類的物件
		InnerSub is = new InnerSub();
		is.a = 5;
		is.b = 8;
		System.out.println("InnerSub物件的a和b屬性是：" + is.a + "," + is.b);
	}
}

在這裡插入圖片描述

匿名內部類

匿名內部類適合建立那種只需要一次使用的類；

匿名內部類必須繼承一個父類，或實現一個介面，但最多隻能繼承一個父類，或實現一個介面；

匿名內部類有如下兩條規則：

  1. 匿名內部類不能是抽象類；
  2. 匿名內部類不能定義構造器。由於匿名內部類沒有類名，所以無法定義構造器，但匿名內部類可以定義初始化塊，可以通過例項初始化塊來完成構造器需要完成的事情；
interface Product
{
	public double getPrice();
	public String getName();
}
public class TestAnonymous
{
	public void test(Product p)
	{
		System.out.println("購買了一個" + p.getName() + "，花掉了" + p.getPrice());
	}
	public static void main(String[] args) 
	{
		TestAnonymous ta = new TestAnonymous();
		//呼叫test方法時，需要傳入一個Product引數，此處傳入其匿名實現類的例項
		ta.test(new Product()
		{
			public double getPrice()
			{
				return 567.8;
			}
			public String getName()
			{
				return "AGP顯示卡";
			}
		});
	}
}

對於上面建立Product實現類物件的程式碼，可以拆分成如下程式碼：

class AnonymousProduct implements Product
{
	public double getPrice()
	{
		return 567.8;
	}
	public String getName()
	{
		return "AGP顯示卡";
	}
}
ta.test(new AnonymousProduct());

通過繼承父類來建立匿名內部類時，匿名內部類將擁有和父類相似的構造器（擁有相同的形參列表）；

Java8之前，Java要求被區域性內部類、匿名內部類訪問的區域性變數必須使用 final 修飾，從Java8開始這個限制被取消

相關推薦

JAVA基礎之類抽象類，介面，內部類

1.抽象類 抽象類往往用來表達對問題的抽象。 定義抽象類應該注意： （1）abstract是定義抽象類的關鍵字，放在class的前面。 （2）abstract在方法中宣告，則該方法則是抽象的方法，抽象方法是沒有方法體的，即為實現。 （3）一個抽象類可以可以包含多個抽象方法，也

C++解析(24)：抽象類和介面、多重繼承

0.目錄 1.抽象類和介面 1.1 抽象類 1.2 純虛擬函式 1.3 介面 2.被遺棄的多重繼承 2.1 C++中的多重繼承 2.2 多重繼承的問題一 2.3 多重繼承的問題二 2.4 多重繼承的問題三 2.5 正確的使用多重繼承 3.小結 1.抽象類

Java物件和例項的關係、Java資料封裝、Java繼承和多型、Java抽象類和介面、Java靜態欄位和方法、Java包和作用域、Java的classpath和jar、Java核心類

Java物件和例項的關係： 面向物件程式設計（Object-Oriented Programming），是對現實世界建立計算機模型的一種方法。 class是物件的模板，它定義瞭如何建立例項，class的名字就是資料型別。一個class裡可以有多個欄位（field），欄位用

抽象類、介面、內部類

抽象類 抽象方法和抽象類 抽象方法和抽象類必須使用abstract修飾符來定義，有抽象方法的類只能被定義為抽象類，抽象類裡可以沒有抽象方法； 規則如下： 抽象類與抽象方法必須使用abstract修飾符來修飾，抽象方法不能有方法體； 抽象類不能被例項化。即使抽象類

java第九天---多型、抽象類、介面、各種修飾符的作用及應用場景、內部類

1   什麼叫多型     某一個事物，在不同時刻表現出來的不同狀態。貓可以是貓的型別。貓 m = new 貓();  同時貓也是動物的一種，也可以把貓稱為動物。動物 d = new 貓(); 2   多型的前提    

12.類、抽象類、匿名類、內部類、繼承、介面、泛型

類、抽象類、匿名類、內部類、繼承、介面、泛型1.獲得一個類的類物件有哪些方式2.過載（Overload）和重寫（Override）的區別。過載的方法能否根據返回型別進行區分？3.說出幾條 Java 中方法過載的最佳實踐4.抽象類和介面的區別5.抽象類中是否可以有靜態的main

Java基礎--->抽象類、介面、內部類、異常等

/* 畢老師用電腦上課。 開始思考上課中出現的問題。 比如問題是 電腦藍屏。 電腦冒煙。 要對問題進行描述，封裝成物件。 可是當冒煙發生後，出現講課進度無法繼續。 出現了講師的問題：課時計劃無法完成。 */ class LanPingException extends Exceptio

重新開始學Java——抽象類、介面、內部類

抽象類 為什麼要定義抽象方法：如果定義某個方法時不能確定該方法的具體實現細節； 比如定義 Person 類的 eat 方法時， 不

java介面、介面、類、抽象類的區別

1、定義           Java介面是一系列方法的宣告，是一些方法特徵的集合，一個介面只有方法的特徵沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現，而這些實現可以具有不同的行為（功能）。 2、Java介面與介面區別

八、抽象類的介面的區別

一，基本區別 1.抽象類允許有具體成語方法的實現，而介面必須方法都是抽象的，不能有實現。 2.一個類只可以繼承一個抽象類，但是卻可以實現多個介面。 3.抽象類允許有各種型別的成員變數，而介面的成員變數是public static final的。 4.抽象類中允許有靜態程式碼塊和靜態方

JAVA基礎複習（三）繼承、多型、抽象類和介面

1、超類也稱為父類或者基類，次類又稱為子類或者拓展類、派生類。子類從它的父類中繼承可訪問的資料域和方法，還可以新增新資料域和新方法。 2、繼承：子類並不是父類的一個子集，子類比它的父類包含更多的資訊和方法；父類中的私有資料域在該類之外是不可訪問的；不是所有是一種關係都應該用繼承來建模，但是繼承是

一、基礎篇--1.1Java基礎-抽象類和介面的區別

抽象類和介面的區別 抽象類和介面在設計層面的區別主要體現在：介面是對動作的抽象，抽象類是對根源、類的抽象。抽象類表示的是，這個物件是什麼，介面表示的是，這個物件可以做什麼。 比如，男人、女人是人，人是男人女人的抽象類。人可以吃東西，動物也可以吃東西，人還有各種行為，吃東西就可以定義為一種介面。 語法上具

抽象類、介面、委託

抽象類：提供了部分功能的實現，不能被例項化的類，               除了不能被例項化和含有抽象方法，其餘使用和正常類使用一樣。 特點：不能被例項化      

python 抽象類、抽象方法、介面、依賴注入、SOLIP

python 抽象類、抽象方法、介面、依賴注入、SOLIP    1、程式設計原則：SOLIP SOLIP設計原則 　　1、單一責任原則(SRP) 　　　　一個物件對只應該為一個元素負責 　　2、開放封閉原則(OCP) 　　　　對擴充套件開放，修改封閉 　　3、里

Java三大特性、抽象類以及介面相關

封裝 概念：物件屬性的封裝隱藏，方法的公開；屬性私有化後，則其他類不能直接使用物件名.屬性名訪問，必須通過提供的公開方法。控制在程式中屬性的讀和修改的訪問級別。 目的：增強安全性和簡化程式設計，使用者不必瞭解具體的實現細節，而只是要通過外部介面，一特定的訪問許可

Java序列化的方式、object類中的方法、介面和抽象類的區別、ArrayList在迴圈過程中刪除

Java序列化的方式 a.是相應的物件實現了序列化介面Serializable，這個使用的比較多，對於序列化介面Serializable介面是一個空的介面，它的主要作用就是標識這個物件時可序列化的，jre物件在傳輸物件的時候會進行相關的封裝。 b.Externlizab

Python全棧學習筆記day 25：抽象類和介面類、多型、鴨子型別

一、介面類 python中沒有介面類 ： python中自帶多繼承 所以我們直接用class來實現了介面類 抽象類、介面類 ： 都是面向物件的開發規範 所有的介面類和抽象類都不能例項化 介面類 ： python原生不支援 抽象類 ： python原生支援的 栗子： c

（個人筆記）2018-11-09 包、訪問許可權、抽象類、介面、final

目錄 包 包-引入包 訪問許可權 抽象類 介面 final 包 包-三大作用 1. 區分相同名字的類 2. 當類很多事，可以很多的管理類 3. 控制訪問範圍 包- 打包命令 package 包名 包-命名規範 字母

抽象類和介面的區別，內部類引用外部方法final引數，守護執行緒和使用者執行緒

abstract class和interface有什麼區別？         答：宣告方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要建立一個體現某些基本行為的類，併為該類宣告方法，但不能在該類中實現該類的情況。不能建立abstract 類的

Java基礎學習之介面和抽象類的概念、區別及適用的場景

1.介面   介面是抽象方法的集合，一個介面只有方法的形狀而沒有方法的具體實現，介面是Java面向物件提供的一種機制。   Java語言是一種單繼承的，在類的繼承中通過實現多個介面間接實現了多繼承功能。介面的宣告： [public] interface InterfaceName{