① java 中當把子類對象賦值給父類對象後，父類調用的重構函數是子類的還是父類的，這個是不是和C++不一樣啊
子類,偽代碼
//2個類Text 父類,Text2 子類
Text aaa = new Text2();//子類對象賦給父類
aaa.outprint();//父子中都有這個方法,列印一句話,System.out.println("我是父(子)類");
結果是答應出"我是子類"
其實很好理解,子類的對象副職敬空賣給亮逗父類,但是NEW的還是子類的,引用還是指向子類的空間,通常我虧碼們用對象副職,副職的也是引用,如
B b = new B();
A a = b;
此時是將b對象的引用副職給a,並沒有重新new出空間
所以調用的還是子類的那片空間里的方法
② java中將子類的變數賦值給父類變數的問題
A是父類，B是子類
B b = new B()；b是B類的實例對象的句柄
a = (A)b ; 是上溯類型，是安全的，b會上溯造型成A，
這樣b便丟失了它的身份或者標識信息。
再次使用它的時候，會得到一個a（A類型）句柄，
而非指向B類型的句柄。
A a = new A();
B b = (B)a; 是下溯類型，是不安全的，A類型句柄會下溯造型成B類稿橘余型句柄
雖然通過下溯造型把a句柄變成了B類型句柄，
但通過句柄b調用的還是內存中存儲的對象a的數據，在運行期檢查時就會出現cast（溯型）違例或稱異常
B b = (B)(A)new B();
(A)new B() 是上溯類型,B會上溯造型成A
(B)((A)new B())是下溯類型,A類型句柄會下溯造型鍵滾成B類型句柄
這樣運行期檢查是就不會拋出異常對象了；
通常使用下伍模溯類型簡單舉例：
ArrayList al = new ArrayList();
al.add(new String("我是字元串類型，是object子類"));
String str = (String)al.get(0);
//al.get(0); 返回的是object類型的，需要下溯類型成String。
因為我們知道放進去的時候是String類型的，取出時下溯轉換成String是（程序員控制的）安全；
③ java父類對象給子類對象賦值強制轉換後子類對象的屬性是怎麼一回事
代碼要寫在代碼首散陸塊者頃、方法裡面。
class c{
public static void main(String args[]){
a a1, a2=new a();
b b1.b2=new b();
b1=(b)a2;
System.out.println(b1.b);
}
}
但還不能用的掘李，因為
b1=(b)a2; /// a2本來是a的實例，轉換失敗。
④ Java子類對象賦值給父類對象的問題
UseCase是基類
UseCase2 u=new UseCase();只能用UseCase的方法
而UseCase2 u=new sub(); 定義念純sub類對象的同時也初始陪租化了UseCase2，這是可以同時用子類和父類的方法！
Sub extends UseCase2的蘆高兆意思是Sub是子類，從UseCase2中繼承的
希望你能明白~hehe，有問題給我message
⑤ 在java中實例化一個子類對象賦給父類對象引用或一個實現了介面的類的對象賦給介面的引用，有什麼好處
這個問題不難!這是多態的一種應用：
把不同的子類對象都當作父類來看，可以屏蔽不同子類對象之間的差異，寫出通用的代碼，做出通用的編程，以適應需團帆消求的不斷變化。
賦值之後，父對象就可以根據當前賦值給它的子對象的特性以不同的方式運作。也就是說，父親的行為像兒子，而不是兒子的行為像父親。
舉個例子：從一個基類中派生，響應一個虛命令，產生不同的結果。
比如從某個基類繼承出多個對象，其基類有一個虛方法Tdoit，然後其子類也有這個方法，但行為不同，然後這些子對象中的任何一個可以賦轎凱給其基類的對象，這樣其基類的對象就可以執行不同的操作了。實際上你是在通過其基類來訪問其子對象的，你要做的就是一個賦值操作。
使用繼承性的結果就是可以創建一個類的家族，在認識這個類的家族時，就是把導出類的對象當作基類的對象，這種認識又叫作upcasting。這樣認識的重要性在於：我們可以只針對基類寫出一段程序，但它可以適應於這個類的家族，因為編譯器會自動就找出合適的對象來執行操作。這種現象又稱為多態性。而實現多態性的手段又叫稱動態綁定(dynamicbinding)。
簡單的說，建立一個父類的對象，它的內容可以是這個父類的，也可以是它的子類的,當子類擁有和父類同樣的函數，當使用這個對象調用這個函數的時候，定義這個對象的類（也就是父類）里的同名函數將被調用，當在父類里的這個函數前加virtual關鍵字，那麼子類的同名函塌知數將被調用。
例子在C++中：
classA{
public:
A(){}
virtualvoidfoo(){
coutfoo();
if(a!=NULL)
deletea;
return0;
}
這將顯示：
ThisisB.
如果把virtual去掉，將顯示：
ThisisA.
前面的多態實現使用抽象類,並定義了虛方法.
在java中：
多態，是面向對象的程序設計語言最核心的特徵。多態，意味著一個對象有著多重特徵，可以在特定的情況下，表現不同的狀態，從而對應著不同的屬性和方法。從程序設計的角度而言，多態可以這樣來實現（以java語言為例）：
publicinterfaceParent{
publicvoidsimpleCall();
}
publicclassChild_AimplementsParent{
publicvoidsimpleCall(){
//具體的實現細節；
}
}
publicclassChild_BimplementsParent{
publicvoidsimpleCall(){
//具體的實現細節；
}
}
//當然還可以有其他的實現
然後，我們就可以看到多態所展示的特性了：
Parentpa=newChild_A();
pa.simpleCall()則顯然是調用Child_A的方法；
Parentpa=newChild_B();
pa.simpleCall()則是在調用Child_B的方法。所以，我們對於抽象的父類或者介面給出了我們的具體實現後，pa可以完全不用管實現的細節，只訪問我們定義的方法，就可以了。事實上，這就是多態所起的作用，可以實現控制反轉這在大量的J2EE輕量級框架中被用到，比如Spring的依賴注射機制。
⑥ java中子類如何對父類中的變數進行賦值並引用
用super關鍵字啊
比如你父類又一個int的實例變數i
在子類里用
super.i=10;
這樣就行
⑦ c#或java里子類對象賦值給父類有什麼用，舉幾個例子啊。
里氏替換原則：
定義一：如果對每一個類型為S的對象o1，都有類型為T的對象o2，使得以T定義的所有程序P在所有的對象o1都代換成o2時，程序P的行為沒有發生變化，那麼類型S是類型T的子類型。
定義二：所有引用基滑租類的地方必須能透明地使用其子類的對象。
大概的要求是：
1、父類對象指向子類實例，向上轉型和向下轉型是里氏替換的一種應用。
2、子類必須完全實現父類的方法，父類對象出現的地方都可以用子類對象進行替換。
這是里氏替換的主要內涵，下面對這兩種體現分別進行代碼舉例。
定義一個抽象類Person：
public abstract class Person{
public abstract String getDetails();
}
用Student類來繼承Person
public class Student extends Person{
private String stuName;
private int age;
private double score;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String stuName, int age, double score) {
super();
this.stuName = stuName;
this.age = age;
this.score = score;
}
@Override
public String getDetails() {
// TODO Auto-generated method stub
return this.stuName + this.age + this.score;
}
}
在Test類裡面可以用：
Person person = new Student();//這舉笑是向上轉型。
也可以定義:
Student student = new Student(「stu」,19,99);
可以將student對象用在所有應該使用Person類型的地方。
Private List<Person> person = new ArrayList<Person>信答兆();
Person.add(student);
⑧ java子類對象賦值給父類對象的問題
是，這是java的基本特性，向上繼承。對於父類的引用一定可以使用子類。
⑨ java如何在子類中賦值給父類的變數
使侍神用世孝super關鍵字就可以了，比如：
父類里的ele屬性
如果是public的直接super.ele="abc";
但如果是private的，並有set方法就調用set方法
super.setEle("abc"老返虧);