java傳遞類
⑴ java 變數賦值後 如何傳遞給其他類
在第一個類中new一個A類的對象，你定義的這個參數作為此對象的構造方法的參數，A中就可以取得這個變數的值用了。
⑵ java 中怎樣實現類類型作為參數傳遞
直接把參數類型定義為對應的類，就是類類型。
1、定一個類
publicclassA{//定義一個類A
}2、定一個方法，類A作為參數傳遞
publicclassB{//定義一個類B
publicvoidshow(Aa){//類作為參數傳遞
}
}
⑶ java 類與類之間怎麼傳遞信息,前提是不實例化
這個B類的對象中的int數據應該對類A是public的或者A和B有繼承關系，假如傳B類的b對象中的bb給A類的對象a，可以這樣：a.function(b.bb)
⑷ JAVA關於類型之間的傳遞
a當然不會變,不過傳過去的值會變,這里相當於
long b=(long)a;
不過是隱式的
⑸ JAVA中如何把一個類中賦值的變數傳遞到另一個類中使用
1.使用實例調用
public class A() {
public void useN(String N) {
System.out.println(N);
}
}
public class Main() {
public static void main(String[] args){
N=read from console
A a = new A();
a.useN(N);
}
}
2.
//靜態調用
public class B{
public static int N;
public static void main(String[] args){
N=..... read from console.
}
}
//在A中調用B的靜態成員N
class A{
static void printBN(){System.out.println(B.N);}
}
⑹ java入門，如何將這個參數傳遞給另外一個類，如下截圖
class Student{ int id; String name; public void paly(){ ...... } }===========public void showStudent(Student student){ System.out.println(student.id); System.out.println(student.name); }
類似這百樣把，
這時你可以把Student看成一個數據類型度
但是准確來說是專一個類
student代表Student類的一個變數
這樣就能訪屬問student中的數據了
⑺ Java類是值傳遞還是引用傳遞
在Java中，事實上底層工作原理不存在傳引用的概念，這也象《Practical Java》中所說的那樣，Java中只有傳值。這句話理解起來需要費一定的周折。
熟悉C的程序員都用過指針，對指針可謂愛之深恨之切。指針是指向一塊內存地址的內存數據（有些拗口），也就是說指針本身是一個佔用4位元組內存的int（32 位系統內），而這個int值恰恰又是另一塊內存的地址。比如"hello"這個字串，存放在@0x0000F000這個地址到@0x0000F005這段內存區域內（包括0x00的結束位元組）。而在@0x0000FFF0到@0x0000FFF03這四個位元組內存放著一個int，這個int的值是 @0x0000F000。這樣就形成了一個指向"hello"字串的指針。
在Java中，很多人說沒有指針，事實上，在Java更深層次里，到處都是大師封裝好的精美絕倫的指針。為了更容易的講解Java中關於類和類型的調用，Java中出現了值與引用的說法。淺顯的來說，我們可以認為 Java中的引用與C中的指針等效（其實差別非常非常大，但是為了說明我們今天的問題，把他們理解為等效是沒有任何問題的）。
所謂傳引用的說法是為了更好的講解調用方式。基於上面對指針的理解，我們不難看出，指針其實也是一個int值，所謂傳引用，我們是復制了復制了指針的int值進行傳遞。為了便於理解，我們可以姑且把指針看作一種數據類型，透明化指針的int特性，從而提出傳引用的概念。
重申一遍：Java中只有傳值。
1所謂傳值和傳引用
傳值和傳引用的問題一直是Java里爭論的話題。與C++不同的，Java裡面沒有指針的概念，Java的設計者巧妙的對指針的操作進行了管理。事實上，在懂C++的Java程序員眼中，Java到處都是精美絕倫的指針。
下面舉個簡單的例子，說明什麼是傳值，什麼是傳引用。
//例1
void method1(){
int x=0;
this.change(x);
System.out.println(x);
}
void int change(int i){
i=1;
}
很顯然的，在mothod1中執行了change(x)後，x的值並不會因為change方法中將輸入參數賦值為1而變成1，也就是說在執行change(x)後，x的值z依然是0。這是因為x傳遞給change(int i)的是值。這就是最簡單的傳值。
同樣的，進行一點簡單的變化。
//例2
void method1(){
StringBuffer x=new StringBuffer("Hello");
this.change(x);
System.out.println(x);
}
void int change(StringBuffer i){
i.append(" world!");
}
看起來沒什麼變化，但是這次mothed1中執行了change (x)後，x的值不再是"Hello"了，而是變成了"Hello world!"。這是因為x傳遞給change(i)的是x的引用。這是最經典的傳引用。
似乎有些奇怪了，兩段程序沒有特別的不同，可是為什麼一個傳的是值而另一個傳的是引用呢？......
2非要搞清楚傳值還是傳引用的問題嗎？
搞清楚這自然是有必要的，不然我也不需要寫這么多了，不過的確沒有到"非要"的地步。
首先，如果我們不太關心什麼是傳值什麼是傳引用，我們一樣能寫出漂亮的代碼，但是這些代碼在運行過程中可能會存在著極大的隱患。
全局變數是讓大家深惡痛絕（又難以割捨）的東西，原因就是使用全局變數要特別注意數據的保護。如果在多線程的程序里使用全局變數簡直就等於跟自己過不去。不了解傳值和傳引用的問題，跟使用全局變數不考慮數據保護的罪過是不相上下下的，甚至有時候比它還要糟。你會莫名其妙，為什麼我的返回參數沒有起作用，為什麼我傳進去的參數變成了這樣......？
一個例子：
//例3
void mothed1(){
int x=0;
int y=1;
switchValue(x,y);
System.out.println("x="+x);
System.out.println("y="+y);
}
void switchValue(int a,int b){
int c=a;
a=b;
b=c;
}
上面是一個交換a,b值的函數，看起來似乎蠻正確的，但是這個函數永遠也不會完成你想要的工作。
還有一個例子：
//例4
StringBuffer a=new StringBuffer("I am a ");
StringBuffer b=a;
a.append("after append");
a=b;
System.out.println("a="+a);
在編程過程中，經常會遇到這種情況，一個變數的值要被臨時改變一下，等用完之後再恢復到開始的值。就好像上面的例子，a為了保持它的值，使用b=a做賦值，之後a被改變，再之後a把暫存在b裡面的值取回來。這是我們一廂情願的想法，而事實上，這段代碼執行後，你會發現a的值已經改變了。
以上是兩個最簡單的例子，真正的程序開發過程中，比這要復雜的情況每天都會遇到。
3類型和類
Java 提出的思想，在Java裡面任何東西都是類。但是Java裡面同時還有簡單數據類型：int,byte,char,boolean，與這些數據類型相對應的類是Integer，Byte，Character，Boolean，這樣做依然不會破壞Java關於任何東西都是類的提法。
這里提到數據類型和類似乎和我們要說的傳值和傳引用的問題無關，但這是我們分辨傳值和傳引用的基礎。
4試圖分辨傳值還是傳引用
為什麼是"試圖分辨"呢？很簡單，傳值和傳引用的問題無處不在，但是似乎還沒有人能正統的給出標准，怎樣的就是值拷貝調用，怎樣的就是引用調用。面對這個問題，我們更多的應該是來自平時積累對Java的理解。
回過頭來，我們分析一下上面的幾個例子：
先看例1，即使你不明白為什麼，但是你應該知道這樣做肯定不會改變x的值。為了方便說明，我們給例子都加上行號。
//例1
1 void method1(){
2 int x=0;
3 this.change(x);
4 }
5
6 void int change(int i){
7 i=7;
8}
讓我們從內存的存儲方式看一下x和I之間到底是什麼關系。
在執行到第2行的時候，變數x指向一個存放著int 0的內存地址。
變數x---->[存放值0]
執行第3行調用change(x)方法的時候，內存中是這樣的情形：x把自己值在內存中復制一份，然後變數i指向這個被復制出來的0。
變數x---->[存放值0]
↓進行了一次值復制
變數x---->[存放值0]
這時候再執行到第7行的時候，變數i的被賦值為7，而這一步的操作已經跟x沒有任何關系了。
變數x---->[存放值0]
變數x---->[存放值7]
說到這里應該已經理解為什麼change(x)不能改變x的值了吧？因為這個例子是傳值的。
那麼，試著分析一下為什麼例三中的switchValue()方法不能完成變數值交換的工作？
再看例2。
//例2
1void method1(){
2 StringBuffer x=new StringBuffer("Hello");
3 this.change(x);
4}
5
6void int change(StringBuffer i){
7 i.append(" world!");
8}
例2似乎和例1從代碼上看不出什麼差別，但是執行結果卻是change(x)能改變x的值。依然才從內存的存儲角度來看看例2的蹊蹺在哪裡。
在執行到第2行時候，同例1一樣，x指向一個存放"Hello"的內存空間。
變數x---->[存放值"Hello"]
接下來執行第三行change(x)，注意，這里就與例1有了本質的不同：調用change(x)時，變數i也指向了x指向的內存空間，而不是指向x的一個拷貝。
變數x \
-->[存放值"Hello"]
變數x /
於是，第7行對i調用append方法，改變i指向的內存空間的值，x的值也就隨之改變了。
變數x \
-->[追加為"Hello World!"]
變數x /
為什麼x值能改變呢？因為這個例子是傳引用的。
這幾個例子是明白了，可是很多人會開始有另一個疑問了：這樣看來，到底什麼時候是傳的值什麼時候是傳得引用呢？於是，我們前面講到的類型和類在這里就派上了用場：對於參數傳遞，如果是簡單數據類型，那麼它傳遞的是值拷貝，對於類的實例它傳遞的是類的引用。需要注意的是，這條規則只適用於參數傳遞。為什麼這么說呢？我們看看這樣一個例子：
//例5
String str="abcdefghijk";
str.replaceAll("b","B");
這兩句執行後，str的內容依然是"abcdefghijk"，但是我們明明是對str操作的，為什麼是這樣的呢？因為str的值究竟會不會被改變完全取決於replaceAll這個方法是怎麼實現的。類似的，有這樣一個例子：
//例6
1 void method1() {
2 StringBuffer x = new StringBuffer("Hello");
3 change1(x);
4 System.out.println(x);
5 }
6
7 void method2() {
8 StringBuffer x = new StringBuffer("Hello");
9 change2(x);
10 System.out.println(x);
11 }
12
13 void change1(StringBuffer sb) {
14 sb.append(" world!");
15 }
16
17 void change2(StringBuffer sb) {
18 sb = new StringBuffer("hi");
19 sb.append(" world!");
20 }
調用method1()，屏幕列印結果為："Hello world!"
調用method2()，我們認為結果應該是"hi world"，因為sb傳進來的是引用。可是實際執行的結果是"Hello"！
難道change2()又變成傳值了？！其實change1()和change2()的確都是通過參數傳入引用，但是在方法內部因為處理方法的不同而使結果大相徑庭。我們還是從內存的角度分析：
執行method1()和change1()不用再多說了，上面的例子已經講解過，這里我們分析一下method2()和change2()。
程序執行到第8行，x指向一個存放著"Hello"的內存空間。
變數x---->[存放值"Hello"]
第9行調用change2，將sb指向x指向的內存空間，也就是傳入x的引用。
變數x \
-->[存放值"Hello"]
變數x /
到這里為止還沒有什麼異樣，接下來執行18行，這里就出現了類似傳入值拷貝的變化：new 方法並沒有改變sb指向內存的內容，而是在內從中開辟了一塊新的空間存放串"hi"，同時sb指向了這塊空間。
變數x---->[存放值"Hello"]
×原有的引用被切斷
變數x---->[另一塊存放"hi"的空間]
接下來再對sb進行append已經和x沒有任何關系了。
所以，還有一條不成規則的規則：對於函數調用，最終效果是什麼完全看函數內部的實現。比較標準的做法是如果會改變引用的內容，則使用void作為方法返回值，而不會改變引用內容的則在返回值中返回新的值。
雖然已經說了這么多，但是感覺傳值還是傳引用的問題依然沒有完全說清楚。因為這個問題本身就是很難歸納總結的問題，所以更多的理解要靠平時的積累和形成。下面幾個例子，給大家嘗試進行分析。
//例7，列印結果是什麼？
public static void main(String[] args) {
int a;
int b;
StringBuffer c;
StringBuffer d;
a = 0;
b = a;
c = new StringBuffer("This is c");
d = c;
a = 2;
c.append("!!");
System.out.println("a=" + a);
System.out.println("b=" + b);
System.out.println("c=" + c);
System.out.println("d=" + d);
}
//例8，列印結果是什麼？
public class Test{
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("Hello ");
System.out.println("Before change, sb = " + sb);
changeData(sb);
System.out.println("After changeData(n), sb = " + sb);
}
public static void changeData(StringBuffer strBuf) {
StringBuffer sb2 = new StringBuffer("Hi ");
strBuf = sb2;
sb2.append("World!");
}
}
⑻ Java中如何將一個類中的JTextArea內容傳遞到另一個類中
當前類創建對象。設置JtextArea的值。然後創建另外一個類。定義具體類型的變數。然後賦值就可以了、 獲取JtextArea中的值應該是利用方法getText();
當前類：JTextArea應該是成員變數。可以設置值、如果返回String類型
另外一個類：定義成員變數 public String str 然後定義方法。獲取當前類的對象，設置str的值就可以了 。
⑼ java參數的傳輸類型有哪些,有什麼特徵 簡述!!!
傳遞參數，這個術語描述的是： 傳遞是一種方式，參數是一種類型。
在C#中有引用傳遞，值傳遞。那麼綜合就可能出現以下情況：
引用傳遞值類型參數，引用傳遞引用類型參數，值傳遞值類型參數，值傳遞引用類型參數
但是java中只有值傳遞，沒有引用傳遞。所以值傳遞引用類型，值傳遞值類型
引用類型參數就是改參數類型是個類，不是基本類型（java中8個基本類型） ， 值類型參數就那8中。byte，char，short，int，long，float，double，boolean。
值類型和引用類型區別在於，值類型保存在內存中的棧區，引用保存在堆區。
值傳遞沒有將參數本身傳進去，而是復制一個傳進去，也就是說，當傳遞一個值類型參數，在方法裡面改變參數值，外面的是不會改變的。因為方法裡面改的是副本參數（復制的）。而傳的是引用類型參數的話，方法裡面改變外面也要跟著變，雖然是副本，可是兩個引用指向的是一個對象，復制的是引用。
⑽ Java支持哪種參數傳遞類型
因為Java里方法參數的傳遞實際上只有值傳遞（不管基本類型或引用類型），對基本類型來說是把其值傳遞了一份過去，而對引用類型來說實際是把引用地址的值復制一份傳遞了過去。 另外，只有用new方法創建的對象的實際成員數據是存放在堆裡面的，而其他方法內部定義的變數都存放在棧中，一旦出了方法的范圍就失效，會被內存回收。 知道了以上兩點，就可以分析了，swap方法里t1,t2,temp都是存放在棧里的只保存引用類型地址的變數，不管他們怎麼交換，實際上不會改變堆裡面的內容，而main方法里的time1, time2的引用類型雖然其地址仍在棧中，而實際數據在堆中，程序中沒有任何改變其內容的語句，因此，不會產生交換。