A. 怎麼分java中的主類和子類
好像只有父類和子類吧。extends前面的類叫父類，extends後面的叫子類，二者是繼承關系。整個程序只有一個主方法，就是main方法。但是類有很多。
B. java如何判斷一個類是不是另一個的子類
ClassclazzA=A.class;
ClassclazzB=B.class;
booleanisFather=clazzB.isAssignableFrom(clazzA));
if(isFather){
System.out.println("B是A的父類");
}else{
System.out.println("B不是A的父類");
}
C. java instanceof 判斷子類的問題
Object o = new Test();
關鍵還是看你實現的那個類Test，而不是看Object
D. 問個問題： java 中，函數調用，傳入參數是個父類，要判斷傳入參數是父類的哪個子類怎麼判斷啊
一般這種東西不建議這樣用，因為強轉畢竟是不好的
有2種方法
1 instanceof 關鍵字 object instanceof class ，
2 getClass() 方法
E. 在java 中 父類定義的靜態方法 子類 調用時候 如何 知道 是哪個子類調用的
1)父類構造函數
java中當調用某個類的構造方法的時候，系統總會調用父類的非靜態初始化塊進行初始化，這個調用是隱式的，而且父類的靜態初始化代碼
塊總是會被執行，接著調用父類的一個或者多個構造器執行初始化，這個調用也可以通過super進行顯式調用。
例如：
父類代碼如下：
public class Creature {//父類
{//非靜態代碼塊
System.out.println("creature的非靜態代碼塊正在執行");
}
public Creature(){
System.out.println("creature的構造函數正在執行");
}
}
子類代碼如下：
public class Animal extends Creature {
{
System.out.println("animal的初始化代碼塊正在執行");
}
public Animal(){
System.out.println("animal的構造方法正在執行");
}
public static void main(String[] args){
Animal a = new Animal() ;
}
}
則運行程序後的結果為：
creature的非靜態代碼塊正在執行
creature的構造函數正在執行
animal的初始化代碼塊正在執行
animal的構造方法正在執行
從結果中可以看出：調用某個類的構造方法的時候總是會先執行父類的非靜態代碼塊，然後執行父類的構造方法，最後才是執行當前類的。
非靜態代碼塊和構造方法。執行過程中有先後順序。
若果想要顯式調用父類的構造方法則可以使用super()，來調用，但是super關鍵字和this關鍵字都必須放在構造放的第一行，而且只能使用第一個。
註：super用於顯式調用父類的構造器，this可以顯式調用本類中的重載的構造器。
2）訪問子類對象的實例變數
子類的方法可以訪問父類中的實例變數，這是因為子類繼承父類就會獲得父類中的成員變數和方法，但是父類方法不能訪問子類的實例變數，因為父類根本無法知道它將被哪個類繼承，它的子類將會增加怎麼樣的成員變數。但是，在極端的情況下，父類也可以訪問子類中的變數。
例如：
父類代碼如下：
public class Base {//父類
private int i = 2 ;
public Base(){
this.display() ;
}
public void display(){
System.out.println(i);
}
}
子類中代碼如下：
public class Derived extends Base {
private int i = 22 ;
public Derived(){
i = 222 ;
}
public void display(){
System.out.println(i);
}
}
測試用例如下：
public class Test {
public static void main(String[] args) {
new Derived() ;
}
}
程序的執行結果為：
0
調用new Derived() ;創建Derived
實例的時候，系統會為Derived對象分配內存空間，Derived會有兩個i實例變數，會分配兩個空間來保存i的值。分配完空間以後i的值為0
，如果有引用類型則引用類型的值為null。接下來程序在執行Derived的構造器之前會執行Base的構造器，表面上看Base的構造器中只有
一行代碼，但是在父類中定義i的時候執行的初始值2，因此經過編譯之後，該構造方法中應該包含如下兩行代碼：
i =2 ;
this.display() ;
程序先將Base中的i賦值為2，然後執行display方法。此處有一個關鍵字this，this到底代表誰呢？表面上看this代表的是Base的當前實例，但是實際上代碼是放在Derived的構造器中的，所以this最終代表的是Derived的當前實例（編譯類型是Base而實際引用一個Derived對象），所以如果在父類的構造方法中直接輸出System.out.println(this.i) ;則輸出的結果為2。但是調用this.display()方法，此時調用的是子類中重寫的display方法，輸出的變數i也是子類中的i，但是此時子類中的變數i還沒有賦值，所以輸出結果為0。
為了詳細的看清楚this變數到底代表什麼實例，我們將Base的構造方法修改如下：
public Base(){
System.out.println(this.i);
System.out.println(this.getClass());
this.display() ;
}
再次運行程序，結果為：
2
class e.qichao.chapter2.Derived
0
可以看到this代表的是Derived的實例，但是編譯的時候類型為Base，所以輸出this.i的值為2。
3）調用被子類重寫的方法
默認情況下，子類可以調用父類的方法，但是父類不能調用子類的方法，因為父類不知道它將被哪個子類繼承，也不知道子類將增加怎麼
樣的方法。
例如：
父類Animal的代碼如下：
public class Animal {
private String desc ;
public Animal(){
this.desc = getDesc() ;
}
public String getDesc(){
return "Animal" ;
}
public String toString(){
return desc ;
}
}
子類Wolf的代碼如下：
public class Wolf extends Animal {
private String name ;
private double weight ;
public Wolf(String name , double weight){
this.name = name ;
this.weight = weight ;
}
public String getDesc(){
return "Wolf[name=" + name + ",weight=" + weight + "]" ;
}
public static void main(String[] args){
System.out.println(new Wolf("灰太狼" , 3));
}
}
程序的運行結果為：
Wolf[name=null,weight=0.0]
在main方法中通過new Wolf("灰太狼" , 3)；來創建一個Wolf的實例，子類會隱式調用父類的構造方法，在父類構造方法中初始化desc變數this.desc = getDesc() ;此處需要注意this變數，雖然這個this放在Animal的構造放中，但是是在Wolf的構造方法中調用父類的構造方法，所以this編譯時類型為Animal，運行時類型為Wolf，此處調用的getDesc方法是子類Wolf的方法，但是子類中的name和weight變數都沒有初始化，默認為null和0.0.所以程序的最終結果為：Wolf[name=null,weight=0.0]
4）繼承成員變數和成員方法的區別
java中隊成員變數的繼承和成員方法的繼承是不同的。
例如：
父類代碼如下：
public class Base {
int count = 2 ;
public void display(){
System.out.println(this.count);
}
}
子類代碼如下：
public class Derived extends Base {
int count = 20 ;
@Override
public void display(){
System.out.println(this.count);
}
}
測試用例如下：
public class Test {
public static void main(String[] args) {
Base b = new Base() ;
System.out.println(b.count);
b.display() ;
System.out.println("-----------------");
Derived d = new Derived() ;
System.out.println(d.count);
d.display() ;
System.out.println("-----------------");
Base bd = new Derived() ;
System.out.println(bd.count);
bd.display() ;
System.out.println("-----------------");
Base d2b = d ;
System.out.println(d2b.count);
}
}
程序運行結果為：
2
2
-----------------
20
20
-----------------
2
20
-----------------
2
F. Java中判斷父類是否為子類的實例這句話什麼意思！
這句話好像有錯，要說也應該是「子類是否為父類的實例」
例如Throwable是Exception類的父類，要判斷Exception是否是Throwable的子類實例，使用instanceof操作符號。
boolean
isTrue
=
子類實例變數名稱
instanceof
父類類名;
G. Java中怎麼判斷一個子類是這個子類
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.Reader;
import org.junit.Test;
public class InstanceTest {
@Test
public void test() throws FileNotFoundException {
FileReader fr = new FileReader("d:\\abc.txt");
System.out.println(fr instanceof Reader);
//這里是多態，父類引用指向子類對象
Reader reader = new FileReader("d:\\abc.txt");
System.out.println(reader instanceof FileReader);
System.out.println(reader instanceof Reader);
H. java 如何判斷使用父類的哪個子類
判斷class的getSuperclass() 是否和父類的class相同 。。。。。。。。。
I. 什麼是後面類 在JAVA中instanceof運算符 的作用是判斷對象是否是後面類 子類、實現類的實例.
舉例說明下吧:
定義三個類
public class Bill {//省略細節}
public class PhoneBill extends Bill {//省略細節}
public class GasBill extends Bill {//省略細節}
在處理程序里有一個方法，接受一個Bill類型的對象，計算金額。假設兩種賬單計算方法不同，而傳入的Bill對象可能是兩種中的任何一種，所以要用instanceof來判斷：
public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//計算電話賬單
}
if (bill instanceof GasBill) {
//計算燃氣賬單
}
...
}
這樣就可以用一個方法處理兩種子類。
J. java中什麼叫子類
java中子類的定義為在有繼承關系的類中extends前面的類則是子類。