java子類

❶ java中怎樣獲取一個類的所有子類

1、面向對象思想的繼承是子類繼承父類，父類被其它子類繼承在JAVA虛擬機的容器中並沒有直接介面獲取；

2、如果是在一個項目內獲取父類的子類繼承情況，參考這個代碼：

packagefind;

importjava.io.File;
importjava.io.IOException;
importjava.net.URL;
importjava.util.ArrayList;
importjava.util.List;

importfind.test.Intf;
importfind.test.Man;

publicclassClassUtil{
publicstaticvoidmain(String[]args){
try{
System.out.println("介面實現類：");
for(Class<?>c:getAllAssignedClass(Intf.class)){
System.out.println(c.getName());
}
System.out.println("子類：");
for(Class<?>c:getAllAssignedClass(Man.class)){
System.out.println(c.getName());
}
}catch(ClassNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}

/**
*獲取同一路徑下所有子類或介面實現類
*
*@paramintf
*@return
*@throwsIOException
*@throwsClassNotFoundException
*/
publicstaticList<Class<?>>getAllAssignedClass(Class<?>cls)throwsIOException,
ClassNotFoundException{
List<Class<?>>classes=newArrayList<Class<?>>();
for(Class<?>c:getClasses(cls)){
if(cls.isAssignableFrom(c)&&!cls.equals(c)){
classes.add(c);
}
}
returnclasses;
}

/**
*取得當前類路徑下的所有類
*
*@paramcls
*@return
*@throwsIOException
*@throwsClassNotFoundException
*/
publicstaticList<Class<?>>getClasses(Class<?>cls)throwsIOException,
ClassNotFoundException{
Stringpk=cls.getPackage().getName();
Stringpath=pk.replace('.','/');
ClassLoaderclassloader=Thread.currentThread().getContextClassLoader();
URLurl=classloader.getResource(path);
returngetClasses(newFile(url.getFile()),pk);
}

/**
*迭代查找類
*
*@paramdir
*@parampk
*@return
*@throwsClassNotFoundException
*/
privatestaticList<Class<?>>getClasses(Filedir,Stringpk)throwsClassNotFoundException{
List<Class<?>>classes=newArrayList<Class<?>>();
if(!dir.exists()){
returnclasses;
}
for(Filef:dir.listFiles()){
if(f.isDirectory()){
classes.addAll(getClasses(f,pk+"."+f.getName()));
}
Stringname=f.getName();
if(name.endsWith(".class")){
classes.add(Class.forName(pk+"."+name.substring(0,name.length()-6)));
}
}
returnclasses;
}
}

❷ java中什麼叫子類

java中子類的定義為在有繼承關系的類中extends前面的類則是子類。

❸ java中什麼是基類和子類

基類就是父類，Object類是所有類的父類，子類繼承父類，繼承並重寫父類的方法和非私有成員變數。舉個例子，車是父類，能走，有輪子是他的方法和屬性，汽車，自行車，火車就是子類，繼承了父類走的方法，又重載了輪子的個數這個屬性。大概就是這樣，不理解可以看看Java核心技術第一卷

❹ java定義類和子類中的方法

{
	privateStringname;
	privateintage;
	privateStringfavor;

	publicFather(Stringname,intage,Stringfavor)
	{
		super(name,age);
		this.favor=favor;
	}

	publicStringgetName()
	{
		returnname;
	}

	publicvoidsetName(Stringname)
	{
		this.name=name;
	}

	publicintgetAge()
	{
		returnage;
	}

	publicvoidsetAge(intage)
	{
		this.age=age;
	}

	publicStringgetFavor()
	{
		returnfavor;
	}

	publicvoidsetFavor(Stringfavor)
	{
		this.favor=favor;
	}

	voidSys()
	{
		System.out.println("我是父親，"+"我的名字是"+this.getName()+"，我的年齡是"+this.getAge()+"歲，我的愛好是"
				+this.getFavor());
	}
}

classParents
{
	publicParents(Stringname,intage)
	{}
}

❺ java子類有什麼用

通俗點說
JAVA是一種高級語言,現在流行於網路和手機軟體游戲方面,JAVA軟體現在是免費下載和使用的。很受編程愛好者的青睞. 一般有J2SE J2EE等.

Java簡介

Java 是 Sun 公司推出的一種編程語言。它是一種通過解釋方式來執行的語言，語法規則和 C++ 類似。

同時， Java 也是一種跨平台的程序設計語言。用 Java 語言編寫的程序叫做 「Applet」 （小應用程序），用編譯器將它編譯成類文件後，將它存在 WWW 頁面中，並在 HTML 檔上作好相應標記，用戶端只要裝上 Java 的客戶軟體就可以在網上直接運行 「Applet」 。 Java 非常適合於企業網路和 Internet 環境，現在已成為 Internet 中最受歡迎、最有影響的編程語言之一。 Java 有許多值得稱道的優點，如簡單、面向對象、分布式、解釋性、可靠、安全、結構中立性、可移植性、高性能、多線程、動態性等。 Java 擯棄了 C++ 中各種弊大於利的功能和許多很少用到的功能。 Java 可以運行與任何微處理器，用 Java 開發的程序可以在網路上傳輸，並運行於任何客戶機上。 JAVA的特點

Java是一種跨平台，適合於分布式計算環境的面向對象編程語言。具體來說，它具有如下特性：簡單性、面向對象、分布式、解釋型、可靠、安全、平台無關、可移植、高性能、多線程、動態性等。下面我們將重點介紹Java語言的面向對象、平台無關、分布式、多線程、可靠和安全等特性。
- 面向對象

面向對象其實是現實世界模型的自然延伸。現實世界中任何實體都可以看作是對象。對象之間通過消息相互作用。另外，現實世界中任何實體都可歸屬於某類事物，任何對象都是某一類事物的實例。如果說傳統的過程式編程語言是以過程為中心以演算法為驅動的話，面向對象的編程語言則是以對象為中心以消息為驅動。用公式表示，過程式編程語言為：程序=演算法+數據；面向對象編程語言為：程序=對象+消息。

所有面向對象編程語言都支持三個概念：封裝、多態性和繼承，Java也不例外。現實世界中的對象均有屬性和行為，映射到計算機程序上，屬性則表示對象的數據，行為表示對象的方法（其作用是處理數據或同外界交互）。所謂封裝，就是用一個自主式框架把對象的數據和方法聯在一起形成一個整體。可以說，對象是支持封裝的手段，是封裝的基本單位。Java語言的封裝性較強，因為Java無全程變數，無主函數，在Java中絕大部分成員是對象，只有簡單的數字類型、字元類型和布爾類型除外。而對於這些類型，Java也提供了相應的對象類型以便與其他對象交互操作。

多態性就是多種表現形式，具體來說，可以用"一個對外介面，多個內在實現方法"表示。舉一個例子，計算機中的堆棧可以存儲各種格式的數據，包括整型，浮點或字元。不管存儲的是何種數據，堆棧的演算法實現是一樣的。針對不同的數據類型，編程人員不必手工選擇，只需使用統一介面名，系統可自動選擇。運算符重載（operator overload)一直被認為是一種優秀的多態機制體現，但由於考慮到它會使程序變得難以理解，所以Java最後還是把它取消了。

繼承是指一個對象直接使用另一對象的屬性和方法。事實上，我們遇到的很多實體都有繼承的含義。例如，若把汽車看成一個實體，它可以分成多個子實體，如：卡車、公共汽車等。這些子實體都具有汽車的特性，因此，汽車是它們的"父親"，而這些子實體則是汽車的"孩子"。Java提供給用戶一系列類（class），Java的類有層次結構，子類可以繼承父類的屬性和方法。與另外一些面向對象編程語言不同，Java只支持單一繼承。

Java是平台無關的語言是指用Java寫的應用程序不用修改就可在不同的軟硬體平台上運行。平台無關有兩種：源代碼級和目標代碼級。C和C++具有一定程度的源代碼級平台無關，表明用C或C++寫的應用程序不用修改只需重新編譯就可以在不同平台上運行。

Java主要靠Java虛擬機（JVM）在目標碼級實現平台無關性。JVM是一種抽象機器，它附著在具體操作系統之上，本身具有一套虛機器指令，並有自己的棧、寄存器組等。但JVM通常是在軟體上而不是在硬體上實現。（目前，SUN系統公司已經設計實現了Java晶元，主要使用在網路計算機NC上。另外，Java晶元的出現也會使Java更容易嵌入到家用電器中。）JVM是Java平台無關的基礎，在JVM上，有一個Java解釋器用來解釋Java編譯器編譯後的程序。Java編程人員在編寫完軟體後，通過Java編譯器將Java源程序編譯為JVM的位元組代碼。任何一台機器只要配備了Java解釋器，就可以運行這個程序，而不管這種位元組碼是在何種平台上生成的（過程如圖1所示）。另外，Java採用的是基於IEEE標準的數據類型。通過JVM保證數據類型的一致性，也確保了Java的平台無關性。

Java的平台無關性具有深遠意義。首先，它使得編程人員所夢寐以求的事情（開發一次軟體在任意平台上運行）變成事實，這將大大加快和促進軟體產品的開發。其次Java的平台無關性正好迎合了"網路計算機"思想。如果大量常用的應用軟體（如字處理軟體等）都用Java重新編寫，並且放在某個Internet伺服器上，那麼具有NC的用戶將不需要佔用大量空間安裝軟體，他們只需要一個Java解釋器，每當需要使用某種應用軟體時，下載該軟體的位元組代碼即可，運行結果也可以發回伺服器。目前，已有數家公司開始使用這種新型的計算模式構築自己的企業信息系統。
- 分布式
Java支持WWW客戶機/伺服器計算模式，因此，它支持這兩種分布性。對於前者，Java提供了一個叫作URL的對象，利用這個對象，你可以打開並訪問具有相同URL地址上的對象，訪問方式與訪問本地文件系統相同。對於後者，Java的applet小程序可以從伺服器下載到客戶端，即部分計算在客戶端進行，提高系統執行效率。
Java提供了一整套網路類庫，開發人員可以利用類庫進行網路程序設計，方便得實現Java的分布式特性。
分布式包括數據分布和操作分布。數據分布是指數據可以分散在網路的不同主機上，操作分布是指把一個計算分散在不同主機上處理。

- 可靠性和安全性
Java最初設計目的是應用於電子類消費產品，因此要求較高的可靠性。Java雖然源於C++，但它消除了許多C++不可靠因素，可以防止許多編程錯誤。首先，Java是強類型的語言，要求顯式的方法聲明，這保證了編譯器可以發現方法調用錯誤，保證程序更加可靠；其次，Java不支持指針，這杜絕了內存的非法訪問；第三，Java的自動單元收集防止了內存丟失等動態內存分配導致的問題；第四，Java解釋器運行時實施檢查，可以發現數組和字元串訪問的越界，最後，Java提供了異常處理機制，程序員可以把一組錯誤代碼放在一個地方，這樣可以簡化錯誤處理任務便於恢復。

由於Java主要用於網路應用程序開發，因此對安全性有較高的要求。如果沒有安全保證，用戶從網路下載程序執行就非常危險。Java通過自己的安全機制防止了病毒程序的產生和下載程序對本地系統的威脅破壞。當Java位元組碼進入解釋器時，首先必須經過位元組碼校驗器的檢查，然後，Java解釋器將決定程序中類的內存布局，隨後，類裝載器負責把來自網路的類裝載到單獨的內存區域，避免應用程序之間相互干擾破壞。最後，客戶端用戶還可以限制從網路上裝載的類只能訪問某些文件系統。上述幾種機制結合起來，使得Java成為安全的編程語言。

- 多線程
線程是操作系統的一種新概念，它又被稱作輕量進程，是比傳統進程更小的可並發執行的單位。C和C++採用單線程體系結構，而Java卻提供了多線程支持。

Java在兩方面支持多線程。一方面，Java環境本身就是多線程的。若干個系統線程運行負責必要的無用單元回收，系統維護等系統級操作；另一方面，Java語言內置多線程式控制制，可以大大簡化多線程應用程序開發。Java提供了一個類Thread，由它負責啟動運行，終止線程，並可檢查線程狀態。Java的線程還包括一組同步原語。這些原語負責對線程實行並發控制。利用Java的多線程編程介面，開發人員可以方便得寫出支持多線程的應用程序，提高程序執行效率。必須注意地是，Java的多線程支持在一定程度上受運行時支持平台的限制。例如，如果操作系統本身不支持多線程，Java的多線程特性可能就表現不出來。
參考資料：http://bbs.inzone.cn/viewthread.php?tid=7461

❻ java 小問題 子類的子類是父類的子類還是間接子類

你應該這樣去理解 「所有「 的 Exception 類。

在 java 中 java.lang.Exception 是 java.lang.Throwable 的子類，而 java.lang.RuntimeException 也是 java.lang.Throwable 的子類。

因此，如果有一段代碼，不管是會發生 Exception 還是 RuntimeException ，而你想一次性捕獲所有錯誤的時候，這樣寫：

publicstaticvoidmain(String[]args){
System.out.println("----------測試輸出1----------");
try{
Strings=null;
//註：這一個會拋出NullPointException，即RuntimeException的子類。
s=s.substring(0);
}catch(Throwableex){
ex.printStackTrace();
}
System.out.println("----------測試輸出2----------");
try{
Strings="123";
//註：這一個會拋出IndexOutOfBoundsException，即RuntimeException的子類。
inti=s.indexOf(200);
}catch(Throwableex){
ex.printStackTrace();
}
System.out.println("----------測試輸出3----------");
}

你在上面的代碼裡面可以看到，即使是發生了 RuntimeException ，但是使用了 Throwable 也可以捕獲到，而且你不用關心具體是什麼原因出錯了，只要有錯誤，用 Throwable 都可捕獲到。

如果不使用 Throwable ，又是一個什麼情況呢，這個時候，你就需要在程序中針對某一個 Exception 或 RuntimeException 來寫 catch 了：

publicstaticvoidmain(String[]args){
System.out.println("----------測試輸出4----------");
try{
Strings=null;
//註：這一個會拋出NullPointException，即RuntimeException的子類。
s=s.substring(0);
}catch(NullPointExceptionex){
ex.printStackTrace();
}
System.out.println("----------測試輸出5----------");
try{
Strings="123";
//註：這一個會拋出IndexOutOfBoundsException，即RuntimeException的子類。
inti=s.indexOf(200);
}catch(IndexOutOfBoundsExceptionex){
ex.printStackTrace();
}
System.out.println("----------測試輸出6----------");
}

但是，其實所有 RuntimeException 及其子類都不需要在程序中顯式調用的，如果不進行顯式調用，則表明你不需要理會錯誤，當有任何錯誤發生時，讓程序自動終止：

publicstaticvoidmain(String[]args){
System.out.println("----------測試輸出7----------");

Strings=null;
//註：這一個會拋出NullPointException，即RuntimeException的子類。
s=s.substring(0);

System.out.println("----------測試輸出8----------");

Strings="123";
//註：這一個會拋出IndexOutOfBoundsException，即RuntimeException的子類。
inti=s.indexOf(200);

System.out.println("----------測試輸出9----------");}

這個時候，在上面代碼中，因為沒有進行 catch ，所以，第 2 句 「測試輸出 8」 就不會執行到了。

❼ java什麼叫子類

父子類：存在繼承關系，關鍵字extends，例如你說的：classSonextendsFather{Stringname；}兒子是父親的一個子類，是兩個獨立的類，只是子類繼承父類的成員變數和成員方法

內部類：與繼承無關，是定義在一個類內部的類，可以看成是類的一部分，分為：

例如：classFather{{}}這個表示「父親的衣服FatherClother」定義在父親類裡面(沒有繼承關系)，並繼承衣服類Clother（有繼承關系）

此時「父親的衣服類」可以看成是父親類的一個一個成員變數，但他們沒有繼承關系，可以寫成：Father.FatherCloter，而那個「.」，表示成員運算符表示FatherClother是Father的一個成員，就像上面Son類中的Son.name一樣，但是我們不能寫成Father.Son。

所以樓主說的「classa1extendsa2{}那麼a1是a2的子類嗎？」是對的。

「我們寫B1.B2.C3(中間是點號)的時候，就表示c3是b2的子類，b2是b1的子類？」不是子類，是內部類

「那classa1{classa2{}}這樣a2也是a1的子類嗎？也可以寫成a1.a2？」不是子類，是內部類

內部類在解決這樣的問題的時候，很有用（當然只是一個方面，還有別的用處）：

一個介面A中有p（）方法，一個類B中也有p（）方法，那麼我想讓這個介面被B實現，然後調用p（）方法（B類中的p（）方法，我不想覆蓋），但是我們調用的哪個？

此時我們可以在B的內部聲明一個內部類C，讓C去實現A介面，然後調用B中原有的p（）方法，可以用B的對象b.p（），調用介面中被實現的p（）方法，可以b..c.p（）（c是類C的一個實例）

繼承，太熟悉了，熟悉到都不知道說什麼了，只能想到這么一句：繼承意味著基於一個已經定義好的類創建一個新的類，新的類將以某種方式擴展原有的類，可以認為就是一個類得到另一個類所有屬性的過程（構造函數木有被繼承，但子類可以通過super調用）。

後面還有匿名內部類，有興趣可以網路一下了解了解。

❽ java中子類和子類型的區別

子類化(subclass) 和 子類型化(subtype)的區別[原創，未經作者許可不得轉載]

subtype具有更加嚴格的要求，就是父類的任何子類都可以在運行時可無縫的代替父類的工作，子類的介面具有更加相比父類更加強的前置條件，父類的介面在子類中得到繼承，並且不得在子類中修改父類方法的簽名.子類型化的好處是實現依賴倒置，參見參考讀物的Bicycle一圖，

subclass主要目的為了更加方便的重用，通常不需要符合Is-a的要求，如果採用組合，那麼必須手寫大量介面，然後Delegate給這個成員變數，如果父類很大的話，使用組合需要大量的工作量，而採用繼承則方便很多，另外通過繼承可以訪問protected的成員及其方法，這也是組合所不具備的。

❾ JAVA子類構造方法

首先指出一點不足：
構造方法最好是指明訪問許可權。
一般是public的，如果是不想被外界調用可以設置為private的比如以後你會學到設計模式中的單例模式，或者是protected只允許本類本包和子類調用，如果什麼都不寫就像你的例子中那樣默認是只允許本類本包。如果你是刻意省略，建議養成習慣還是寫上public或者你需要的對應的訪問許可權。
再者，解決你的疑惑：
你問「怎麼在子類中運用父類的Super方法？？？？？子類不是繼承了父類嗎？」。
在子類中調用父類的方法還有很多種情況的，比如你「super(1,2);」調用父類的構造方法，是很正確的。這里要首先注意一點，構造方法是不會被繼承的包括後來會學到的析構方法。所以，子類繼承不了父類的構造方法（無論是什麼許可權），想要調用，那麼可以，只能通過super來調用。
那麼繼承不了構造方法，子類可以繼承么呢？一句話，子類可以繼承父類的所有非private的成員，這里說的成員指的是屬性和方法。比如父類有個非private的fun()方法，那麼子類可以通過super.fun()來調用或者直接一個fun()來調用，為么，因為子類已經繼承了父類的了，fun()不僅是爹爹的而且還是自己的。或者子類可以重寫父類的方法，重寫fun()，那麼子類重寫了父類的fun()了，這時候可以通過this.fun()和super.fun()來分別調用子類和父類的fun()，但是這種情況並不常見。最常用的就是使用super調用父類的構造方法除此super並不常用了。

❿ 怎麼分java中的主類和子類

好像只有父類和子類吧。extends前面的類叫父類，extends後面的叫子類，二者是繼承關系。整個程序只有一個主方法，就是main方法。但是類有很多。